changeset 94:6650624647cf

8072018: DIO1.0.1: merge with latest spec repo Summary: Merge DIO1.0.1 related spec updates. No code changes Reviewed-by: alkonsta
author snazarki
date Mon, 02 Feb 2015 13:46:41 +0400
parents d61f9ce3dacd
children 5ac0112afff2
files README README_Tests src/doc-files/overview.html src/share/classes/com/oracle/dio/uart/impl/UARTImpl.java src/share/classes/jdk/dio/Device.java src/share/classes/jdk/dio/DeviceConfig.java src/share/classes/jdk/dio/DeviceEvent.java src/share/classes/jdk/dio/DeviceManager.java src/share/classes/jdk/dio/DeviceMgmtPermission.java src/share/classes/jdk/dio/DevicePermission.java src/share/classes/jdk/dio/RoundCompletionEvent.java src/share/classes/jdk/dio/adc/ADCChannel.java src/share/classes/jdk/dio/adc/AcquisitionRoundListener.java src/share/classes/jdk/dio/adc/MonitoringListener.java src/share/classes/jdk/dio/atcmd/ATDevice.java src/share/classes/jdk/dio/atcmd/ATDeviceConfig.java src/share/classes/jdk/dio/counter/CountingListener.java src/share/classes/jdk/dio/counter/PulseCounter.java src/share/classes/jdk/dio/counter/package-info.java src/share/classes/jdk/dio/dac/DACChannel.java src/share/classes/jdk/dio/dac/GenerationRoundListener.java src/share/classes/jdk/dio/generic/GenericDevice.java src/share/classes/jdk/dio/generic/GenericDeviceControl.java src/share/classes/jdk/dio/generic/package-info.java src/share/classes/jdk/dio/gpio/GPIOPin.java src/share/classes/jdk/dio/gpio/GPIOPortConfig.java src/share/classes/jdk/dio/gpio/PinListener.java src/share/classes/jdk/dio/gpio/PortListener.java src/share/classes/jdk/dio/gpio/package-info.java src/share/classes/jdk/dio/i2cbus/I2CCombinedMessage.java src/share/classes/jdk/dio/power/PowerManaged.java src/share/classes/jdk/dio/power/PowerSavingHandler.java src/share/classes/jdk/dio/pwm/GenerationEvent.java src/share/classes/jdk/dio/pwm/GenerationListener.java src/share/classes/jdk/dio/pwm/GenerationRoundListener.java src/share/classes/jdk/dio/pwm/PWMChannel.java src/share/classes/jdk/dio/pwm/package-info.java src/share/classes/jdk/dio/spi/DeviceProvider.java src/share/classes/jdk/dio/spi/package-info.java src/share/classes/jdk/dio/uart/UART.java src/share/classes/jdk/dio/uart/UARTConfig.java src/share/classes/jdk/dio/uart/UARTEventListener.java src/share/classes/jdk/dio/uart/package-info.java src/share/classes/jdk/dio/watchdog/WatchdogTimer.java src/share/classes/jdk/dio/watchdog/WatchdogTimerConfig.java src/share/classes/jdk/dio/watchdog/WindowedWatchdogTimer.java src/share/classes/jdk/dio/watchdog/package-info.java test/build.xml test/jdk/dio/runner/interview/i18n.properties
diffstat 49 files changed, 746 insertions(+), 314 deletions(-) [+]
line wrap: on
line diff
--- a/README	Fri Jan 30 12:21:52 2015 +0300
+++ b/README	Mon Feb 02 13:46:41 2015 +0400
@@ -1,7 +1,7 @@
 README:
 
 This file should be located at the root of the device-io OpenJDK Mercurial repository.
- 
+
 People unfamiliar with Mercurial should read the first few chapters of
   the Mercurial book: http://hgbook.red-bean.com/read/
 
@@ -16,4 +16,4 @@
   make
 
 The resulting Device I/O library files should be found in build/jar and build/so
- 
+
--- a/README_Tests	Fri Jan 30 12:21:52 2015 +0300
+++ b/README_Tests	Mon Feb 02 13:46:41 2015 +0400
@@ -1,5 +1,5 @@
 README:
- 
+
 People unfamiliar with Mercurial should read the first few chapters of
   the Mercurial book: http://hgbook.red-bean.com/read/
 
@@ -10,12 +10,12 @@
 
 JDK 8
 	download JDK8
-	
+
 apache-ant
 	download apache-ant distribution
-	
+
 jtharness
-	wiki 
+	wiki
 		https://wiki.openjdk.java.net/display/CodeTools/JT+Harness
 	download link
 		https://adopt-openjdk.ci.cloudbees.com/job/jtharness/lastSuccessfulBuild/artifact/jtharness-62.tar.gz
@@ -25,24 +25,24 @@
 	download link
 		https://google-gson.googlecode.com/files/google-gson-2.1-release.zip
 	gson-2.1.jar from the distribution must be placed in de/tests/lib folder
-	
-Start JT Harness:    
+
+Start JT Harness:
 
 	export JAVA_HOME=<location of JDK8 install>
 	export ANT_HOME=<location of apache-ant distribution>
-	
+
 	to compile:
 	${ANT_HOME}/bin/ant compile
-	
+
 	to build jar:
 	${ANT_HOME}/bin/ant jar
-	
+
 	to run JT Harness GUI:
 	${ANT_HOME}/bin/ant -Djavatest.mode.batch=false run-javatest
-	
+
 	to run JT Harness in batch mode:
 	${ANT_HOME}/bin/ant run-javatest
-	
+
 All information related to JT Harness configuration and tests can be found on a wiki page
 
 	https://wiki.openjdk.java.net/display/dio/Tests+Configuration+And+Execution
\ No newline at end of file
--- a/src/doc-files/overview.html	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/doc-files/overview.html	Mon Feb 02 13:46:41 2015 +0400
@@ -11,15 +11,15 @@
         <!Don't remove this line. Otherwise the first few parts shows twice in the generated overview>
 
     <h1>Overview</h1>
-    This specification defines a generic peripheral device I/O API for Java 
-    applications running on small embedded devices. 
+    This specification defines a generic peripheral device I/O API for Java
+    applications running on small embedded devices.
     <h2>Targeted Platforms</h2>
     This specification is targeted at embedded Java platforms.
     It is an optional package primarily targeting the Java Platform, Micro Edition 8 Connected Limited Device Configuration
     for small embedded devices. It is also compatible with Java Platform Standard Edition 8.
     <h2>Devices</h2>
     In this specification, a <i>Device</i> designates any kind
-    of <em>peripheral</em> devices, from a peripheral device external to the <em>host</em> device 
+    of <em>peripheral</em> devices, from a peripheral device external to the <em>host</em> device
     to a peripheral chip embedded in the <em>host</em> device.
     Moreover, a peripheral <em>device</em> may not always designate the complete
     hardware peripheral device but may sometimes designate a component or a resource
@@ -27,7 +27,7 @@
     the other components or resources of that same hardware peripheral device.
     For example, a single pin of a GPIO (General Purpose I/O) controller
     may be viewed as an individual <i>Device</i>.
-    Conversely, a <i>Device</i> may not always correspond to 
+    Conversely, a <i>Device</i> may not always correspond to
     a single hardware peripheral device or component thereof, but
     may be composed of several other <i>Devices</i>: a <i>Composite Device</i>. For example,
     a Touch Screen <i>Device</i> may be assembled from a Touch Screen
@@ -62,14 +62,14 @@
         <dt><b>Analog to Digital Converter (ADC)</b></dt>
         <dd>
             ADC channels of an ADC converter can be accessed and controlled as
-            individual <i>Devices</i>. 
+            individual <i>Devices</i>.
             Any number of ADC converters can be supported.
             See <a href="jdk/dio/adc/package-summary.html">jdk.dio.adc</a>.
         </dd>
         <dt><b>Digital to Analog Converter (DAC)</b></dt>
         <dd>
             DAC channels of a DAC converter can be accessed and controlled as
-            individual <i>Devices</i>. 
+            individual <i>Devices</i>.
             Any number of DAC converters can be supported.
             See <a href="jdk/dio/dac/package-summary.html">jdk.dio.dac</a>.
         </dd>
@@ -109,14 +109,14 @@
         <dt><b>Pulse Width Modulation (PWM) Generators</b></dt>
         <dd>
             PWM channels of a PWM generator can be accessed and controlled as
-            individual <i>Devices</i>. 
+            individual <i>Devices</i>.
             Any number of PWM generators can be supported.
             See <a href="jdk/dio/pwm/package-summary.html">jdk.dio.pwm</a>.
         </dd>
         <dt><b>Generic Devices</b></dt>
         <dd>
             Other types of devices can be supported through
-            a set of generic device interfaces. 
+            a set of generic device interfaces.
             See <a href="jdk/dio/generic/package-summary.html">jdk.dio.generic</a>.
         </dd>
         <dt><b><i>Future Extension</i></b></dt>
@@ -130,7 +130,7 @@
     <p />
     Additionally, this API defines a framework for registering new <code>Devices</code>, or in essence
     new device drivers (see <a href="jdk/dio/spi/package-summary.html">jdk.dio.spi</a>). The {@link jdk.dio.Device} interface can be extended to provide new
-    types of devices such as a Real Time Clock or a Touch Screen device. 
+    types of devices such as a Real Time Clock or a Touch Screen device.
     New implementations of the {@link jdk.dio.Device} sub-interfaces defined in this specification may also be
     registered. For example, access to the pins and ports of an I2C GPIO expander primarily
     supported as an I2C slave device may be provided by new {@link jdk.dio.gpio.GPIOPin}
@@ -153,7 +153,7 @@
     <p />
     The version for each of the optional packages is that of this specification.
     <p />
-    Additionally, device features vary greatly from hardware to hardware. Therefore some features defined 
+    Additionally, device features vary greatly from hardware to hardware. Therefore some features defined
     by device APIs may be optionally supported. Such optional supports are handled as follows:
     <ol>
         <li>a {@link jdk.dio.UnsupportedDeviceTypeException} is thrown when attempting to {@link jdk.dio.DeviceManager#open open} a device whose type is not supported by the platform.</li>
@@ -183,32 +183,32 @@
         </dd>
         <dt><b>Device Names</b></dt>
         <dd>
-            Names of devices are free-form strings. The names of devices may not be unique. 
+            Names of devices are free-form strings. The names of devices may not be unique.
             But a name would typically correspond to a single hardware device that may
-            be accessible through different instances of {@link jdk.dio.Device} 
+            be accessible through different instances of {@link jdk.dio.Device}
             offering different levels of abstractions. Each of these instances would have the same name.
-            In the last example above, both implementations of 
+            In the last example above, both implementations of
             the real-time clock device may have the same name "RTC" though they have different IDs and interfaces.
         </dd>
         <dt><b>Device Properties</b></dt>
         <dd>
-            Properties of devices are free-form strings describing the properties of a 
-            device such as its capabilities. These strings are platform and device-specific. 
+            Properties of devices are free-form strings describing the properties of a
+            device such as its capabilities. These strings are platform and device-specific.
             For example, {@link jdk.dio.atcmd.ATDevice} defines - as properties - certain capabilities
             for modems.
             <p />
             Properties can be use to represent intrinsic properties of a device such as its capabilities as well as
-            extrinsic properties of a device such as its placement on the board or whether a device is embedded, 
-            removable or even external to a module. Properties defined for a device driver may be published as part of its specification.  
+            extrinsic properties of a device such as its placement on the board or whether a device is embedded,
+            removable or even external to a module. Properties defined for a device driver may be published as part of its specification.
             <p />
             Using the RTC example,
-            because of the tight dependency to its hardware chip, the memory-mapped Real-Time Clock 
+            because of the tight dependency to its hardware chip, the memory-mapped Real-Time Clock
             device may have been registered with the following property: "com.acme.rtc.chip=146818", which actually refers to the RTC chip designation.
             The user-defined {@link jdk.dio.Device} implementation
-            may then rely on this property to lookup the {@link jdk.dio.mmio.MMIODevice} for which it wants to provide 
+            may then rely on this property to lookup the {@link jdk.dio.mmio.MMIODevice} for which it wants to provide
             a higher-level abstraction.
             Another example is the properties of an I2C slave device which could include whether it supports the SMBus
-            specification (see <a href="http://smbus.org/specs/index.html">http://smbus.org/specs/index.html</a>) or the 
+            specification (see <a href="http://smbus.org/specs/index.html">http://smbus.org/specs/index.html</a>) or the
             properties of a temperature sensor which may include its placement on the board or module.
             <p />
             By convention properties should use the following format:
@@ -220,7 +220,7 @@
             the corresponding positively asserted boolean property (eg. "com.foobar.rtc.alarm=true").
             <br />
             To avoid conflicts, it is highly recommended that properties be named in accordance with the reverse domain name
-            convention. The property name prefixes {@code "java."}, {@code "javax."} are reserved for definition by this 
+            convention. The property name prefixes {@code "java."}, {@code "javax."} are reserved for definition by this
             specification. According to this convention, the property of an I2C slave device to support the SMBus
             specification should be named with the prefix {@code "org.smbus."}.
         </dd>
@@ -242,7 +242,7 @@
         <li>Several devices of the same type may have the same name but different properties.
             <br />
             Eg.: name={@code "TEMP_SENSOR"}, interface={@code "ADCChannel"}, property={@code "com.foobar.temp.orientation=TOP"|"com.foobar.temp.orientation=BOTTOM"|...}</li>
-        <li>A new device can be registered at runtime with a dynamically allocated ID; and applications may 
+        <li>A new device can be registered at runtime with a dynamically allocated ID; and applications may
             rely on a well-known name or a name defined in the spec of the device driver or of the application
             registering the device.</li>
         <li>A hardware device may be exposed as distinct virtualized abstractions registered with the same name but under different IDs.
@@ -270,33 +270,33 @@
             An open device topology allows for (in addition to what a closed topology allows for) the installation and de-installation of devices
             during runtime and allows for already installed or newly installed applications to access these devices.
             <p />
-            In such a topology, some of the devices may be pre-registered and pre-configured at the platform level 
+            In such a topology, some of the devices may be pre-registered and pre-configured at the platform level
             and will have a fixed device ID (in a same way as in a closed topology). Applications will not be able to change the configuration of pre-configured device beyond what is being exposed in the {@link jdk.dio.Device}
             interfaces.
             Still applications will be able to discover or address devices which are not part of the pre-configured set
             and especially new devices that may be added to the platform, for example on an I2C bus.
             To address and access such a newly plugged in I2C slave device, an application may use an instance of {@link jdk.dio.i2cbus.I2CDeviceConfig}
             with the bus number and slave address properly set.
-            In order to open a device with an adhoc configuration, an application must be granted the permission to use 
+            In order to open a device with an adhoc configuration, an application must be granted the permission to use
             {@link jdk.dio.DeviceManager#open(DeviceConfig)}.
             <p />
         </dd>
     </dl>
     <h2>Device Provider Lookup</h2>
-    Drivers for devices may be dynamically looked up and loaded at runtime from 
+    Drivers for devices may be dynamically looked up and loaded at runtime from
     shared libraries containing for each device both the <i>driver</i> code for the device and
     its associated meta-data describing the provided <em>Service</em> (provider configuration file) as per
     the <em>Service-Provider Loading</em> facility supported by the platform.
     <p />
-    When attempting to open or register a specific device using its supported interface, configuration and properties such as by calling one of the 
+    When attempting to open or register a specific device using its supported interface, configuration and properties such as by calling one of the
     {@link jdk.dio.DeviceManager#open(Class, jdk.dio.DeviceConfig) open} methods
     or the {@link jdk.dio.DeviceManager#register(int, Class, jdk.dio.DeviceConfig, String, String[]) register}
-    method of the {@code DeviceManager} 
-    the device manager MUST use the <em>Service-Provider Loading</em> facility supported by the platform 
+    method of the {@code DeviceManager}
+    the device manager MUST use the <em>Service-Provider Loading</em> facility supported by the platform
     (typically going through the class path of shared libraries)
     to locate a {@link jdk.dio.spi.DeviceProvider} that can open {@code Device} instances of the requested type,
     configuration and properties.
-    The class implementing the {@link jdk.dio.spi.DeviceProvider} interface as well as the class implementing 
+    The class implementing the {@link jdk.dio.spi.DeviceProvider} interface as well as the class implementing
     the {@link jdk.dio.Device} interface or sub-interface and all associated classes must be located in a shared library or already part of the platform'system libraries.
     <h2>Device Registration</h2>
     Devices of defined types are registered under a device ID and with optionally a name and a set of properties.
@@ -308,12 +308,12 @@
         <dt><b>Application-registered Devices</b></dt>
         <dd>
             Devices may be programmatically registered at runtime by applications.
-            Because applications that may need access to these devices may run as separate 
+            Because applications that may need access to these devices may run as separate
             tasks in different contexts, the <i>driver</i> code for devices registered
             by applications should be part of shared libraries or already part of the platform'system libraries.
             Note that whether a device instance registered by an application is accessible
             by other applications is constrained by the security policy implemented by the platform.
-            An application may explicitly register a device by invoking the 
+            An application may explicitly register a device by invoking the
             {@link jdk.dio.DeviceManager#register jdk.dio.DeviceManager.register}
             method.
             An application may unregister an application-registered device provided it is granted the {@link jdk.dio.DeviceMgmtPermission#UNREGISTER}
@@ -322,8 +322,8 @@
     </dl>
     <h2><a name="access-model">Exclusive And Shared Access, And Thread-safety</a></h2>
     The defined framework provides a fine access granularity to device hardware. For example,
-    individual GPIO pins are modeled as separate {@link jdk.dio.gpio.GPIOPin} instances and can be accessed concurrently even 
-    though they may be supported by the same GPIO controller hardware; individual ADC channels are modeled as separate {@link jdk.dio.adc.ADCChannel} 
+    individual GPIO pins are modeled as separate {@link jdk.dio.gpio.GPIOPin} instances and can be accessed concurrently even
+    though they may be supported by the same GPIO controller hardware; individual ADC channels are modeled as separate {@link jdk.dio.adc.ADCChannel}
     instances and can be accessed concurrently. While access to the underlying hardware device may be <em>shared</em> and the sharing controlled by the underlying device driver,
     access to individual device resources modeled as {@link jdk.dio.Device} instances may be <em>exclusive</em> or <em>shared</em>.
     Whether access to individual device resources modeled as {@code Device} instances is <em>exclusive</em> or <em>shared</em>
@@ -342,10 +342,10 @@
         <dt><b>Virtualized Device Resource Abstraction</b></dt>
         <dd>
             A {@code Device} instance may be a <em>virtualized</em> abstraction of a device resource. Several {@code Device} instances
-            mapped onto that same individual device resource may be open concurrently and access to the resource through the {@code Device} instances 
+            mapped onto that same individual device resource may be open concurrently and access to the resource through the {@code Device} instances
             may appear as <em>exclusive</em> as if <em>dedicated</em> abstractions.
             <br />
-            A particular platform or driver implementation may for example map a <em>virtualized</em> abstraction of a device resource to a single 
+            A particular platform or driver implementation may for example map a <em>virtualized</em> abstraction of a device resource to a single
             device (configuration) ID or name that may allow for a unlimited or for a bound number of concurrently open instances. Or, a particular implementation
             may map a <em>virtualized</em> abstraction of a device resource to distinct device (configuration) IDs or names that can be concurrently
             open.
@@ -356,14 +356,14 @@
         <dt><b>Shared Device Resource Abstraction</b></dt>
         <dd>
             A {@code Device} instance may be a <em>shared</em> abstraction of a device resource. Several {@code Device} instance
-            mapped onto that same individual device resource may be open concurrently but access to the resource through the {@code Device} instances 
+            mapped onto that same individual device resource may be open concurrently but access to the resource through the {@code Device} instances
             must be explicitly synchronized.
             <br />
             When a device is open in shared mode then to synchronize access to the shared resource an application may invoke
             {@link jdk.dio.Device#tryLock Device.tryLock} and
             {@link jdk.dio.Device#unlock Device.unlock}. An application may also rely
-            on device protocol-specific means to synchronize access to a shared device resource. For example, a particular implementation may 
-            configure a specific I2C EEPROM device to be shared. Access to the I2C EEPROM device 
+            on device protocol-specific means to synchronize access to a shared device resource. For example, a particular implementation may
+            configure a specific I2C EEPROM device to be shared. Access to the I2C EEPROM device
             through {@link jdk.dio.i2cbus.I2CDevice} instances will be by default synchronized on I2C transactions.
         </dd>
     </dl>
@@ -382,8 +382,8 @@
     (instances of {@link jdk.dio.DeviceEvent})
     and are dispatched for processing by application-registered event listeners
     (instances of {@link jdk.dio.DeviceEventListener}).
-    Because some events may be time-sensitive, events are time-stamped. Additionally, 
-    to account for event bursts, that is cases where events are produced more rapidly than they are handled, 
+    Because some events may be time-sensitive, events are time-stamped. Additionally,
+    to account for event bursts, that is cases where events are produced more rapidly than they are handled,
     events may be coalesced. Coalesced events regroup in one event object several occurrences of events
     of the same type and keep track of the number of events that have been coalesced.
     Only the last occurring value that may be attached to the event such as the state of a GPIO pin, is retained.
@@ -392,9 +392,9 @@
     <p />
     Event handling methods should be implemented in such a way that they quickly process the events and return.
     <p />
-    Event notification implements a unicast model. A single listener can be registered for a particular event type. 
+    Event notification implements a unicast model. A single listener can be registered for a particular event type.
     <h2><a name="security-model">Security Model</a></h2>
-    The security model of this API is designed to protect the access to individual device hardware resources as well as 
+    The security model of this API is designed to protect the access to individual device hardware resources as well as
     the namespace under which their abstractions (provided as instances of {@code Device}-implementing classes) are registered.
     <dl>
         <dt><b>Protection Upon Registering A Device</b></dt>
@@ -410,37 +410,37 @@
         <dt><b>Protection Upon Opening A Device</b></dt>
         <dd>
             Prior to opening the {@code Device} instance with an adhoc configuration using one of the
-            {@link jdk.dio.DeviceManager#open(jdk.dio.DeviceConfig) DeviceManager.open(config, ...)} methods 
-            the permission (subclass of {@link jdk.dio.DevicePermission}) 
+            {@link jdk.dio.DeviceManager#open(jdk.dio.DeviceConfig) DeviceManager.open(config, ...)} methods
+            the permission (subclass of {@link jdk.dio.DevicePermission})
             specific to that {@code Device} instance, if any defined, is checked with a target name
-            composed of the relevant hardware addressing information and with the action 
+            composed of the relevant hardware addressing information and with the action
             {@link jdk.dio.DevicePermission#OPEN DevicePermission.OPEN}.
-            In the case of a custom device driver, this permission check SHOULD be performed by the 
-            {@link jdk.dio.spi.DeviceProvider#open DeviceProvider.open} method of the device provider. 
+            In the case of a custom device driver, this permission check SHOULD be performed by the
+            {@link jdk.dio.spi.DeviceProvider#open DeviceProvider.open} method of the device provider.
             <p />
             For example,
             if a device of type {@link jdk.dio.gpio.GPIOPin GPIOPin} is to be opened the
             {@link jdk.dio.gpio.GPIOPinPermission GPIOPinPermission} is checked with a target name
-            composed of the relevant hardware addressing information (the device name or device 
+            composed of the relevant hardware addressing information (the device name or device
             number and the pin number) and with the action {@link jdk.dio.gpio.GPIOPinPermission#OPEN GPIOPinPermission.OPEN}.
             <p />
             Prior to opening the {@code Device} instance with a registered configuration using one of the
             {@link jdk.dio.DeviceManager#open(int) DeviceManager.open(id, ...)} or
-            {@link jdk.dio.DeviceManager#open(String, Class, int, String[]) DeviceManager.open(name, ...)} methods 
+            {@link jdk.dio.DeviceManager#open(String, Class, int, String[]) DeviceManager.open(name, ...)} methods
             the {@link jdk.dio.DeviceMgmtPermission} is checked with a target name
             composed of the requested device ID and/or name and with the action
             {@link jdk.dio.DeviceMgmtPermission#OPEN DeviceMgmtPermission.OPEN}.
             Note that this permission check is performed prior to any permission checks that the device driver may performed when opening the device with
-            the designated configuration. 
+            the designated configuration.
             <p />
-            <em>Note on Protection Upon Opening Compound Devices:</em> 
+            <em>Note on Protection Upon Opening Compound Devices:</em>
             A compound/composite device is composed of different device components such as a Touch Screen Device assembled from
-            a Touch Screen SPI (Serial Peripheral Interface bus) slave Device and a GPIO pin Device handling the Pen-Down signal or a 
+            a Touch Screen SPI (Serial Peripheral Interface bus) slave Device and a GPIO pin Device handling the Pen-Down signal or a
             GPIO port configured from a set of individual GPIO pins. When a {@code Device} abstraction for such a compound device is assembled from
             component {@code Device} abstractions the permissions that apply upon opening the component {@code Device} abstractions must be granted to the
             calling application when opening the compound {@code Device} abstraction. Note that depending on the security architecture of the underlying platform (Java ME or Java SE -based) these permission
             checks may or may not require the corresponding permissions to be explicitly granted to the calling application; either because (e.g. on Java SE) the preripheral's
-            driver code is marked as priviledged and is granted the necessary permission(s) (see <a href="http://docs.oracle.com/javase/7/docs/technotes/guides/security/doprivileged.html">API for Priviledged Code</a>) and/or 
+            driver code is marked as priviledged and is granted the necessary permission(s) (see <a href="http://docs.oracle.com/javase/7/docs/technotes/guides/security/doprivileged.html">API for Priviledged Code</a>) and/or
             because (e.g. on Java ME) the {@code Device} configuration being opened is a <em>platform-registered</em> configuration for which the
             required privileges and permissions are implicitly or explictly granted.
         </dd>
@@ -454,8 +454,8 @@
     the {@code RealTimeClockPermission} below.
     <h1>Examples</h1>
     <h2><a name="examples">Providing a Higher-Level Abstraction For a Memory-Mapped Real Time Clock</a></h2>
-    Below is a complete example showing how a new higher-level device 
-    abstraction <code>RealTimeClock</code>  can be provided for a memory-mapped Real-Time Clock 
+    Below is a complete example showing how a new higher-level device
+    abstraction <code>RealTimeClock</code>  can be provided for a memory-mapped Real-Time Clock
     chip accessible as an {@link jdk.dio.mmio.MMIODevice} device.
     <p />
     The Real Time Clock device interface:
@@ -754,12 +754,12 @@
                     <p class="TableText">
                         <cite>"Java™ Product Versioning Specification"</cite>,
                         Sun Microsystems, 2002, Roger Riggs.
-                        Available at : 
+                        Available at :
                         <a href="http://docs.oracle.com/javase/1.5.0/docs/guide/versioning/spec/versioning2.html">
                             http://docs.oracle.com/javase/1.5.0/docs/guide/versioning/spec/versioning2.html</a>
                     </p>
                 </td>
-            </tr>  
+            </tr>
         </tbody>
     </table>
 </body>
--- a/src/share/classes/com/oracle/dio/uart/impl/UARTImpl.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/com/oracle/dio/uart/impl/UARTImpl.java	Mon Feb 02 13:46:41 2015 +0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -384,6 +384,11 @@
         return getDataBits0();
     }
 
+    @Override
+    public int getFlowControlMode() throws IOException, UnavailableDeviceException, ClosedDeviceException {
+        throw new UnsupportedOperationException();
+    }
+
     /**
      * Gets the current parity.
      *
@@ -481,6 +486,12 @@
         UARTEventHandler.getInstance().removeEventListener(eventId, this);
         removeEventListener0(eventId);
     }
+
+    @Override
+    public void setFlowControlMode(int flowcontrol) throws IOException, UnavailableDeviceException, ClosedDeviceException {
+        throw new UnsupportedOperationException();
+    }
+
     /**
      * Sets the parity.
      */
--- a/src/share/classes/jdk/dio/Device.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/Device.java	Mon Feb 02 13:46:41 2015 +0400
@@ -73,7 +73,7 @@
      * @throws IllegalArgumentException
      *             if {@code timeout} is negative.
      * @throws UnavailableDeviceException
-     *             if this device is not currently available.
+     *             if this device is still not available after the specified timeout has expired.
      * @throws ClosedDeviceException
      *             if this device has been closed.
      * @throws IOException
@@ -99,7 +99,7 @@
     void close() throws IOException;
 
     /**
-     * Indicates whether this device is open/available to the calling application.
+     * Indicates whether or not this device is open/available to the calling application.
      *
      * @return {@code true} if, and only if, this device is open; {@code false} otherwise.
      */
--- a/src/share/classes/jdk/dio/DeviceConfig.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/DeviceConfig.java	Mon Feb 02 13:46:41 2015 +0400
@@ -36,7 +36,7 @@
  * I2C slave device address or a GPIO controller number and pin index.</dd>
  * <dt><b>Static Configuration Parameters</b></dt>
  * <dd>Configuration parameters that must be set before the device is opened and which
- * may not be changed afterward. Examples are an SPI slave device clock mode or word length.</dd>
+ * may not be changed afterwards. Examples are an SPI slave device clock mode or word length.</dd>
  * <dt><b>Dynamic Configuration Parameters</b></dt>
  * <dd>Configuration parameters for which a default value may be set before the device is
  * opened and which may still be changed while the device is open. Dynamic configuration
--- a/src/share/classes/jdk/dio/DeviceEvent.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/DeviceEvent.java	Mon Feb 02 13:46:41 2015 +0400
@@ -93,7 +93,7 @@
      * @return the time (in milliseconds) when this event last occurred.
      */
     public final long getLastTimeStamp() {
-        return timeStamp;
+        return lastTimeStamp;
     }
 
     /**
@@ -104,7 +104,7 @@
      *         occurred.
      */
     public final int getLastTimeStampMicros() {
-        return timeStampMicros;
+        return lastTimeStampMicros;
     }
 
     /**
--- a/src/share/classes/jdk/dio/DeviceManager.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/DeviceManager.java	Mon Feb 02 13:46:41 2015 +0400
@@ -96,6 +96,20 @@
  * {@link DeviceMgmtPermission#REGISTER} and {@link DeviceMgmtPermission#UNREGISTER}).
  * <br />
  * For more details see <a href="{@docRoot}/overview-summary.html#security-model">Security Model</a>.
+ * <h3><a name="probing">Device Probing</a></h3>
+ * For some peripheral hardware such as I2C bus or SPI bus, opening (or registering) a device
+ * such as a slave device on a bus does not necessarily entail immediately
+ * accessing the device. Upon opening the device the underlying platform or
+ * driver may probe for the device to check whether the device exists and is
+ * addressable and whether the requested configuration is valid; if the probing
+ * for device determines that the device does not exist or is not addressable
+ * or, that it does not support the requested configuration a
+ * {@code DeviceNotFoundException} or respectively an
+ * {@code InvalidDeviceConfigException} is thrown. If the underlying platform or
+ * driver does not implement any probing facility then a {@code Device} instance
+ * is returned; I/O operations on the device will later fail - typically with an
+ * {@code IOException} - if the device does not exist or is not addressable or,
+ * if it does not support the requested configuration.
  *
  * @see UnavailableDeviceException
  * @see DeviceMgmtPermission
@@ -170,6 +184,9 @@
      * matching {@code Device} is returned. If a matching {@code Device} is already open
      * (therefore <em>not available</em>) the next matching {@code Device} is considered.
      * <p />
+     * Opening a {@code Device} instance with hardware addressing information and configuration
+     * may be subject to <a href="#probing">device probing limitations </a>.
+     * <p />
      * The device is opened in exclusive access mode.
      * <p />
      * The returned {@code Device} instance's ID and name are undefined.
@@ -219,6 +236,9 @@
      * is returned. If a matching {@code Device} is already open in a mode that is not
      * compatible with the requested mode the next matching {@code Device} is considered.
      * <p />
+     * Opening a {@code Device} instance with hardware addressing information and configuration
+     * may be subject to <a href="#probing">device probing limitations </a>.
+     * <p />
      * The device is opened in the designated access mode. A device may be
      * opened in shared mode if supported by the underlying driver and hardware and if it is not
      * already opened in exclusive mode. A device may be opened in exclusive mode if
@@ -412,8 +432,6 @@
      *             if the designated device type is not supported.
      * @throws DeviceNotFoundException
      *             if the designated device is not found.
-     * @throws UnsupportedDeviceTypeException
-     *             if the designated device type is not supported.
      * @throws UnavailableDeviceException
      *             if the designated device is not currently available - such as when it is
      *             already open in an access mode incompatible with the requested access mode.
@@ -528,6 +546,9 @@
      * {@code Device} is already open (therefore <em>not available</em>) the next matching
      * {@code Device} is considered.
      * <p />
+     * Opening a {@code Device} instance with hardware addressing information and configuration
+     * may be subject to <a href="#probing">device probing limitations </a>.
+     * <p />
      * The device is opened in exclusive access mode.
      * <p />
      * The returned {@code Device} instance's ID and name are undefined.
@@ -571,6 +592,9 @@
      * matching {@code Device} is already open in a mode that is not compatible with the
      * requested mode the next matching {@code Device} is considered.
      * <p />
+     * Opening a {@code Device} instance with hardware addressing information and configuration
+     * may be subject to <a href="#probing">device probing limitations </a>.
+     * <p />
      * The device is opened in the designated access mode. A device may be
      * opened in shared mode if supported by the underlying driver and hardware and if it is not
      * already opened in exclusive mode. A device may be opened in exclusive mode if
@@ -580,6 +604,8 @@
      * <p />
      * A new instance is returned upon each call.
      *
+     * @param <P>
+     *            the type of the device to open.
      * @param config
      *            the device configuration (which includes hardware addressing information as
      *            well as configuration parameters).
@@ -801,7 +827,8 @@
      * registering a device is the first one to get notified (in the event it has registered a
      * {@code RegistrationListener} for that type of devices).
      * <p />
-     * The designated device may be probed to check if the provided configuration is valid.
+     * The designated device may be probed to check if the provided configuration is valid
+     * (see <a href="#probing">device probing limitations </a>).
      * <p />
      * Prior to registering a new device of a certain type the
      * {@link DeviceMgmtPermission} is checked with the action
--- a/src/share/classes/jdk/dio/DeviceMgmtPermission.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/DeviceMgmtPermission.java	Mon Feb 02 13:46:41 2015 +0400
@@ -71,7 +71,7 @@
  * <p />
  * The target name {@code "*:*"} matches all device names and all device IDs as is the target name {@code "*"}.
  * </dd>
- * </dt>
+ * </dl>
  * The actions to be granted are passed to the constructor in a string containing a list of one or more comma-separated
  * keywords. The possible keywords are {@code register} and {@code unregister}. Their
  * meaning is defined as follows:
@@ -176,7 +176,7 @@
      * More specifically, this method returns {@code true} if:
      * <ul>
      * <li>{@code permission} is an instance of {@code DeviceMgmtPermission}, and
-     * <li>{@code permission}'s actions are a proper subset of this action list, and</i>
+     * <li>{@code permission}'s actions are a proper subset of this action list, and</li>
      * <li>{@code permission}'s device name, ID or range thereof
      * is included in this device name or ID range, whichever is defined.
      * </ul>
--- a/src/share/classes/jdk/dio/DevicePermission.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/DevicePermission.java	Mon Feb 02 13:46:41 2015 +0400
@@ -89,7 +89,7 @@
  * <dd>manage the power saving mode of a device (see
  * {@link jdk.dio.power.PowerManaged})</dd>
  * </dl>
- * </dd> </dl> Additional actions to be granted may be defined by subclasses of
+ * Additional actions to be granted may be defined by subclasses of
  * {@code DevicePermission}.
  *
  * @see DeviceManager#open DeviceManager.open
@@ -225,7 +225,7 @@
      * More specifically, this method returns {@code true} if:
      * <ul>
      * <li>{@code permission} is an instance of {@code DevicePermission}, and</li>
-     * <li>{@code permission}'s actions are a proper subset of this object's action list, and</i></li>
+     * <li>{@code permission}'s actions are a proper subset of this object's action list, and</li>
      * <li>{@code permission}'s hardware addressing information or range thereof is included in this
      * {@code DevicePermission}'s hardware addressing information range.</li>
      * </ul>
--- a/src/share/classes/jdk/dio/RoundCompletionEvent.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/RoundCompletionEvent.java	Mon Feb 02 13:46:41 2015 +0400
@@ -30,7 +30,7 @@
 /**
  * The {@code RoundCompletionEvent} class encapsulates the completion condition of a round of I/O
  * operation. <br />
- * This kind of events is <em>never coalesced</em>.
+ * {@code RoundCompletionEvent}s are <em>never coalesced</em>.
  *
  * @param <P>
  *            the device type the event is defined for.
@@ -60,7 +60,7 @@
 
     /**
      * Creates a new {@link RoundCompletionEvent} with the specified I/O buffer and time-stamped
-     * with the current time.
+     * with the current time. The {@code onError} flag is set to {@code false}.
      *
      * @param device
      *            the source device.
@@ -79,6 +79,7 @@
 
     /**
      * Creates a new {@link RoundCompletionEvent} with the specified I/O buffer and timestamp.
+     * The {@code onError} flag is set to {@code false}.
      *
      * @param device
      *            the source device.
@@ -111,6 +112,56 @@
     }
 
     /**
+     * Creates a new {@link RoundCompletionEvent} with the specified I/O buffer and error status
+     * and time-stamped with the current time.
+     *
+     * @param device
+     *            the source device.
+     * @param buffer
+     *            the input or output buffer.
+     * @param number
+     *            the number of elements input or output during the round.
+     * @param onError
+     *            whether an input buffer overrun or output buffer underrun condition occurred.
+     * @throws NullPointerException
+     *             if {@code device} or {@code buffer} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if {@code number} is negative.
+     */
+    public RoundCompletionEvent(P device, B buffer, int number, boolean onError) {
+        this(device, buffer, number, onError, System.currentTimeMillis(), 0);
+    }
+
+    /**
+     * Creates a new {@link RoundCompletionEvent} with the specified I/O buffer, error status and timestamp.
+     *
+     * @param device
+     *            the source device.
+     * @param buffer
+     *            the I/O buffer.
+     * @param number
+     *            the number of elements input or output during the round.
+     * @param onError
+     *            whether an input buffer overrun or output buffer underrun condition occurred.
+     * @param timeStamp
+     *            the timestamp (in milliseconds).
+     * @param timeStampMicros
+     *            the additional microseconds to the timestamp.
+     * @throws NullPointerException
+     *             if {@code device} or {@code buffer} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if {@code timeStamp}, {@code timeStampMicros} or {@code number} is negative.
+     */
+    public RoundCompletionEvent(P device, B buffer, int number, boolean onError, long timeStamp, int timeStampMicros) {
+        this.device = device;
+        this.buffer = buffer;
+        this.number = number;
+        this.onError = onError;
+        this.timeStamp = timeStamp;
+        this.timeStampMicros = timeStampMicros;
+    }
+
+    /**
      * Returns the input or output buffer.
      *
      * @return the input or output buffer.
--- a/src/share/classes/jdk/dio/adc/ADCChannel.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/adc/ADCChannel.java	Mon Feb 02 13:46:41 2015 +0400
@@ -94,7 +94,7 @@
 public interface ADCChannel extends Device<ADCChannel>, BufferAccess<IntBuffer> {
 
     /**
-     * Returns the maximum raw value this channel can convert. If the ADC device resolution is
+     * Returns the maximum raw value this channel can convert to. If the ADC device resolution is
      * {@code n} then the {@code min} value returned by {@link #getMinValue() getMinValue} and the
      * {@code max} value returned by {@link #getMaxValue() getMaxValue} are such that: <blockquote>
      *
@@ -104,7 +104,7 @@
      *
      * </blockquote>
      *
-     * @return the maximum raw value this channel can convert.
+     * @return the maximum raw value this channel can convert to.
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws UnavailableDeviceException
@@ -131,7 +131,7 @@
     int getMinSamplingInterval() throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Returns the minimum raw value this channel can convert. If the ADC device resolution is
+     * Returns the minimum raw value this channel can convert to. If the ADC device resolution is
      * {@code n} then the {@code min} value returned by {@link #getMinValue getMinValue} and the
      * {@code max} value returned by {@link #getMaxValue getMaxValue} are such that: <blockquote>
      *
@@ -141,7 +141,7 @@
      *
      * </blockquote>
      *
-     * @return the minimum raw value this channel can convert.
+     * @return the minimum raw value this channel can convert to.
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws UnavailableDeviceException
@@ -155,7 +155,9 @@
     /**
      * Gets the input sampling interval (in microseconds). If the sampling interval was not set
      * previously using {@link #setSamplingInterval setSamplingInterval} the device
-     * configuration-specific default value is returned.
+     * configuration-specific default value is returned.  Additionally, the value returned may differ
+     * from the previously set or configured value as it may have been adjusted to account
+     * for the resolution or discrete sampling interval values supported by the underlying platform or driver.
      *
      * @return the input sampling interval (in microseconds).
      * @throws IOException
@@ -186,7 +188,7 @@
      * @throws ClosedDeviceException
      *             if the device has been closed.
      * @throws IllegalStateException
-     *             if another asynchronous acquisition is already active.
+     *             if an asynchronous acquisition is already active.
      */
     int acquire() throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
@@ -227,7 +229,7 @@
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws IllegalStateException
-     *             if another asynchronous acquisition is already active.
+     *             if an asynchronous acquisition is already active.
      * @throws UnsupportedOperationException
      *             if an asynchronous monitoring is already active and acquisition and monitoring
      *             cannot be performed concurrently.
@@ -261,6 +263,12 @@
      * Sets the input sampling interval (in microseconds). Whether changing the sampling interval
      * has an immediate effect or not on an active (synchronous or asynchronous) acquisition is
      * device- as well as platform-dependent.
+     * <p />
+     * The sampling time interval is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested interval value
+     * then {@code interval} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete interval value. The resulting, actual
+     * sampling interval can be retrieved by a call to {@link #getSamplingInterval() getSamplingInterval}.
      *
      * @param interval
      *            the input sampling interval (in microseconds).
@@ -307,21 +315,27 @@
      * {@link #stopAcquisition stopAcquisition} is not predictable unless called from within the
      * listener.
      * <p />
+     * Upon notification of the provided {@code AcquisitionRoundListener}
+     * the reference to the provided {@code dst} buffer can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A buffer with {@code 0} integers remaining to be read (that is a buffer already
      * full) at the moment this method is initially invoked or then subsequently when the listener
      * is returning will not stop the asynchronous operation; the listener is guaranteed to be
      * called back again at the latest as soon as all other events pending at the time of
-     * notification have been dispatched.
-     * <p />
-     * Interfering with the asynchronous operation by accessing and modifying the provided buffer
-     * concurrently may yield unpredictable results.
+     * notification have been dispatched. The overrun condition resulting from the listener notification
+     * returning with an already-full buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * The input will be sampled according to the current input sampling interval as returned by
      * {@link #getSamplingInterval getSamplingInterval}.
      * <p />
-     * Only one acquisition (synchronous or asynchronous) can be going on at any time. Buffers are
-     * not safe for use by multiple concurrent threads so care should be taken to not access the
-     * working buffer until the operation (or a round thereof) has completed.
+     * Only one acquisition (synchronous or asynchronous) can be going on at any time.
+     * <p />
+     * Buffers are not safe for use by multiple concurrent threads so care should
+     * be taken to not access the provided buffer until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffer
+     * concurrently may yield unpredictable results.
      *
      * @param dst
      *            The buffer into which integer raw sampled input values are to be transferred.
@@ -352,21 +366,35 @@
      * <p />
      * This method behaves identically to
      * {@link #startAcquisition(IntBuffer, AcquisitionRoundListener)} excepts that it uses
-     * double-buffering. Notification will happen when the current working buffer (initially
+     * double-buffering - the provided buffers must not have a zero-capacity and must not overlap
+     * - that is the backing array sections or memory regions they refer to must not overlap.
+     * Notification will happen when the current working buffer (initially
      * {@code dst1}) has been filled with raw sampled input values and reading will asynchronously
      * proceed with the alternate buffer (which becomes the current working buffer). Reading will
      * only be suspended if the previous event has not yet been handled (this may result in the case
-     * of continuous sampling in subsequent sampled input values to be lost).
+     * of continuous sampling in subsequent sampled input values to be lost). Also,
+     * the position of the current working buffer upon stopping this asynchronous operation by a call to
+     * {@link #stopAcquisition stopAcquisition} is not predictable even if called from within the
+     * listener.
      * <p />
+     * Upon notification of the provided {@code AcquisitionRoundListener}
+     * the reference to the  current working buffer (initially {@code dst1}) can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A working buffer with {@code 0} integers remaining to be read (that is a buffer
      * already full) at the moment this method is initially invoked or then subsequently when the
      * listener is returning will not stop the asynchronous operation; the listener is guaranteed to
      * be called back again at the latest as soon as all other events pending at the time of
-     * notification have been dispatched.
+     * notification have been dispatched. The overrun condition resulting from the listener notification
+     * returning with an already-full buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
-     * Only one acquisition (synchronous or asynchronous) can be going on at any time. Buffers are
-     * not safe for use by multiple concurrent threads so care should be taken to not access the
-     * working buffer until the operation (or a round thereof) has completed.
+     * Only one acquisition (synchronous or asynchronous) can be going on at any time.
+     * <p />
+     * Buffers are not safe for use by multiple concurrent threads so care should
+     * be taken to not access the provided buffers until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffers
+     * concurrently may yield unpredictable results.
      *
      * @param dst1
      *            The first buffer into which integer raw sampled input values are to be
@@ -388,6 +416,9 @@
      *             if the device has been closed.
      * @throws IllegalStateException
      *             if another synchronous or asynchronous acquisition is already active.
+     * @throws IllegalArgumentException
+     *             if any of the buffers {@code dst1} and {@code dst2} has a zero-capacity or
+     *             if they are the same or overlap.
      * @throws UnsupportedOperationException
      *             if an asynchronous monitoring is already active and acquisition and monitoring
      *             cannot be performed concurrently.
@@ -449,6 +480,8 @@
     /**
      * Stops the asynchronous analog input acquisition on this channel as started by a call to one
      * of the {@link #startAcquisition startAcquisition} methods.
+     * <p />
+     * This method return silently if no asynchronous analog input acquisition is currently active.
      *
      * @throws IOException
      *             if some other I/O error occurs.
@@ -463,6 +496,8 @@
     /**
      * Stops the range monitoring of this channel analog input as started by a call to the
      * {@link #startMonitoring startMonitoring} method.
+     * <p />
+     * This method return silently if no range monitoring is currently active.
      *
      * @throws IOException
      *             if some other I/O error occurs.
--- a/src/share/classes/jdk/dio/adc/AcquisitionRoundListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/adc/AcquisitionRoundListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -32,11 +32,11 @@
 /**
  * The {@code AcquisitionRoundListener} interface defines methods for getting notified of the
  * availability of sampled input values. <br />
- * A {@code AcquisitionRoundListener} can be registered using the
- * {@link ADCChannel#startAcquisition ADCChannel.startAcquisition} method.
- * <p />
  * This interface also indirectly extends the {@link jdk.dio.AsyncErrorHandler
  * AsyncErrorHandler} interface for getting notified of asynchronous I/O errors.
+ * <p />
+ * An {@code AcquisitionRoundListener} can be registered using one of the
+ * {@link ADCChannel#startAcquisition ADCChannel.startAcquisition} methods.
  *
  * @see ADCChannel#startAcquisition ADCChannel.startAcquisition
  * @since 1.0
--- a/src/share/classes/jdk/dio/adc/MonitoringListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/adc/MonitoringListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -30,7 +30,8 @@
 
 /**
  * The {@code MonitoringListener} interface defines methods for getting notified of ADC channel under- and
- * over-threshold input value conditions as well as device errors. <br />
+ * over-threshold input value conditions as well as device errors.
+ * <p />
  * A {@code MonitoringListener} can be registered using the
  * {@link ADCChannel#startMonitoring ADCChannel.startMonitoring} method.
  *
--- a/src/share/classes/jdk/dio/atcmd/ATDevice.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/atcmd/ATDevice.java	Mon Feb 02 13:46:41 2015 +0400
@@ -317,7 +317,7 @@
      *             if some other I/O error occurs.
      */
     void setUnsolicitedResponseHandler(UnsolicitedResponseHandler handler) throws IOException,
-            UnavailableDeviceException, ClosedDeviceException;
+            ClosedDeviceException;
 
     /**
      * {@inheritDoc}
--- a/src/share/classes/jdk/dio/atcmd/ATDeviceConfig.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/atcmd/ATDeviceConfig.java	Mon Feb 02 13:46:41 2015 +0400
@@ -73,7 +73,7 @@
      * @param channelNumber
      *            the hardware channel's number (a positive or zero integer) or {@link #DEFAULT}.
      * @throws IllegalArgumentException
-     *             if {@code channelNumber} is not in the defined range.</li>
+     *             if {@code channelNumber} is not in the defined range.
      * @throws NullPointerException
      *             if {@code controller name} is {@code null}.
      */
@@ -95,7 +95,7 @@
      * @param channelNumber
      *            the hardware channel's number (a positive or zero integer) or {@link #DEFAULT}.
      * @throws IllegalArgumentException
-     *             if {@code channelNumber} is not in the defined range.</li>
+     *             if {@code channelNumber} is not in the defined range.
      */
     public ATDeviceConfig(int controllerNumber, int channelNumber) {
         this.controllerNumber = controllerNumber;
--- a/src/share/classes/jdk/dio/counter/CountingListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/counter/CountingListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -31,7 +31,9 @@
 /**
  * The {@code CountingListener} interface defines methods for getting notified of pulse counter
  * counting conditions such as counter terminal value reached or counting session time interval
- * expired as well of device errors. A {@code CountingListener} can be registered using the
+ * expired as well of device errors.
+ * <p />
+ * A {@code CountingListener} can be registered using the
  * {@link PulseCounter#startCounting(int, long, jdk.dio.counter.CountingListener)}
  * method.
  *
--- a/src/share/classes/jdk/dio/counter/PulseCounter.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/counter/PulseCounter.java	Mon Feb 02 13:46:41 2015 +0400
@@ -162,9 +162,10 @@
      * only after the time specified by {@code interval} has passed. If {@code interval} is equal to
      * or less than {@code 0} then the counting time interval will end only after the pulse count
      * has reached the terminal count value specified by {@code limit}. The counting time interval
-     * is expressed in microseconds; if the underlying platform does not support a microsecond timer
-     * resolution then {@code interval} will be <em>rounded up</em> to accommodate the supported timer
-     * resolution.
+     * is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested interval value
+     * then {@code interval} will be <em>rounded up</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest greater supported interval value.
      * <p/>
      * Pulse counting and notification will immediately start and will repeat until it is stopped by
      * a call to {@link #stopCounting stopCounting}.
@@ -198,6 +199,8 @@
     /**
      * Stops the pulse counting and freezes the current count value. The count value will be reset
      * upon the next start.
+     * <p />
+     * This method return silently if no pulse counting session is currently active.
      *
      * @throws IOException
      *             if some other I/O error occurs.
--- a/src/share/classes/jdk/dio/counter/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/counter/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -79,7 +79,7 @@
  *
  *     public void start(int counterID) throws IOException, NonAvailableDeviceException, DeviceNotFoundException {
  *         counter = (PulseCounter) DeviceManager.open(counterID);
- *         counter.startCounting(-1, 1000, this); // Count events occurring during 1 second (without terminal count value)
+ *         counter.startCounting(-1, 1000, this); // Count events occuring during 1 second (without terminal count value)
  *     }
  *
  *     public void countValueAvailable(CountingEvent event) {
--- a/src/share/classes/jdk/dio/dac/DACChannel.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/dac/DACChannel.java	Mon Feb 02 13:46:41 2015 +0400
@@ -145,7 +145,9 @@
     /**
      * Gets the output sampling interval (in microseconds). If the output sampling interval was not
      * set previously using {@link #setSamplingInterval setSamplingInterval} the device
-     * configuration-specific default value is returned.
+     * configuration-specific default value is returned. Additionally, the value returned may differ
+     * from the previously set or configured value as it may have been adjusted to account
+     * for the resolution or discrete sampling interval values supported by the underlying platform or driver.
      *
      * @return the output sampling interval (in microseconds).
      * @throws IOException
@@ -185,6 +187,12 @@
      * Sets the output sampling interval (in microseconds). Whether changing the sampling interval
      * has an immediate effect or not on an active (synchronous or asynchronous) generation is
      * device- as well as platform-dependent.
+     * <p />
+     * The sampling time interval is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested interval value
+     * then {@code interval} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete interval value. The resulting, actual
+     * sampling interval can be retrieved by a call to {@link #getSamplingInterval() getSamplingInterval}.
      *
      * @param interval
      *            the output sampling interval (in microseconds).
@@ -233,7 +241,7 @@
     void generate(int value) throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Writes {@code count} raw output values from the provided buffer to this channel for
+     * Writes a sequence of raw output values from the provided buffer to this channel for
      * conversion.
      * <p />
      * The raw output values will be converted according to the current output sampling interval as
@@ -284,7 +292,7 @@
     /**
      * Starts asynchronous analog output generation on this channel from a series of raw output
      * values (samples). More values to be converted are asynchronously fetched by notifying the
-     * provided {@link GenerationRoundListener} instance once {@code count} raw output values have
+     * provided {@link GenerationRoundListener} instance once the whole sequence of raw output values have
      * been converted. The raw output values to be converted are read from the provided buffer.
      * <p />
      * Analog output generation can be stopped by a call to {@link #stopGeneration stopGeneration}.
@@ -306,19 +314,24 @@
      * The raw output values (samples) will be converted according to the current output sampling
      * interval as returned by {@link #getSamplingInterval getSamplingInterval}.
      * <p />
+     * Upon notification of the provided {@code GenerationRoundListener}
+     * the reference to the provided {@code src} buffer can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A buffer with {@code 0} integers remaining to be written (that is a buffer already
      * empty) at the moment this method is initially invoked or then subsequently when the listener
      * is returning will not stop the asynchronous operation; the listener is guaranteed to
      * be called back again at the latest as soon as all other events pending at the time of
-     * notification have been dispatched.
-     * <p />
-     * Interfering with the asynchronous operation by accessing and modifying the provided buffer
-     * concurrently may yield unpredictable results.
+     * notification have been dispatched. The underrun condition resulting from the listener notification
+     * returning with an empty buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one output generation (synchronous or asynchronous) can be going on at any time.
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
      * be taken to not access the provided buffer until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffer
+     * concurrently may yield unpredictable results.
      * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the
      * designated raw values is not within the range defined by {@link #getMinValue getMinValue}
@@ -353,21 +366,34 @@
      * <p />
      * This method behaves identically to
      * {@link #startGeneration(IntBuffer, GenerationRoundListener)} excepts that it uses
-     * double-buffering. Notification will happen when all the raw output values remaining in the
+     * double-buffering - the provided buffers must not have a zero-capacity and must not overlap
+     * - that is the backing array sections or memory regions they refer to must not overlap.
+     * Notification will happen when all the raw output values remaining in the
      * current working buffer (initially {@code src1}) have been converted and conversion will
      * proceed with the alternate buffer (which will become the current working buffer). Conversion
-     * will only be suspended if the previous event has not yet been handled.
+     * will only be suspended if the previous event has not yet been handled. Also,
+     * the position of the current working buffer upon stopping this asynchronous operation by a call to
+     * {@link #stopGeneration stopGeneration} is not predictable even if called from within the
+     * listener.
      * <p />
+     * Upon notification of the provided {@code GenerationRoundListener}
+     * the reference to the  current working buffer (initially {@code src1}) can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A working buffer with {@code 0} integers remaining to be written (that is a buffer
      * already empty) at the moment this method is initially invoked or then subsequently when the
      * listener is returning will not stop the asynchronous operation; the listener is guaranteed to
      * be called back again at the latest as soon as all other events pending at the time of
-     * notification have been dispatched.
+     * notification have been dispatched. The underrun condition resulting from the listener notification
+     * returning with an empty buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one output generation (synchronous or asynchronous) can be going on at any time.
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
-     * be taken to not access the working buffer until the operation (or a round thereof) has completed.
+     * be taken to not access the provided buffers until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffers
+     * concurrently may yield unpredictable results.
      * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the
      * designated raw values is not within the range defined by {@link #getMinValue getMinValue}
@@ -396,6 +422,9 @@
      *             if the device has been closed.
      * @throws IllegalStateException
      *             if another synchronous or asynchronous output generation is already active.
+     * @throws IllegalArgumentException
+     *             if any of the buffers {@code src1} and {@code src2} has a zero-capacity or
+     *             if they are the same or overlap.
      */
     void startGeneration(IntBuffer src1, IntBuffer src2, GenerationRoundListener listener) throws IOException,
             UnavailableDeviceException, ClosedDeviceException;
@@ -403,6 +432,8 @@
     /**
      * Stops the asynchronous analog output generation on this channel as started by a call to one
      * of the {@link #startGeneration startGeneration} methods.
+     * <p />
+     * This method return silently if no asynchronous analog output generation is currently active.
      *
      * @throws IOException
      *             if some other I/O error occurs.
--- a/src/share/classes/jdk/dio/dac/GenerationRoundListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/dac/GenerationRoundListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -32,13 +32,12 @@
 /**
  * The {@code GenerationRoundListener} interface defines methods for getting notified of the
  * completion of the conversion of a set of raw output values and that more output values to be
- * converted may be provided.
- * <p />
+ * converted may be provided. <br />
  * This interface also indirectly extends the {@link jdk.dio.AsyncErrorHandler
  * AsyncErrorHandler} interface for getting notified of asynchronous I/O errors.
  * <p />
- * A {@code GenerationRoundListener} can be registered using the {@link DACChannel#startGeneration}
- * method.
+ * A {@code GenerationRoundListener} can be registered using one of the {@link DACChannel#startGeneration DACChannel.startGeneration}
+ * methods.
  *
  * @see DACChannel#startGeneration DACChannel.startGeneration
  * @since 1.0
--- a/src/share/classes/jdk/dio/generic/GenericDevice.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/generic/GenericDevice.java	Mon Feb 02 13:46:41 2015 +0400
@@ -153,5 +153,5 @@
      *             if the device has been closed.
      */
     void setEventListener(int eventId, GenericEventListener listener) throws IOException,
-            UnavailableDeviceException, ClosedDeviceException;
+            ClosedDeviceException;
 }
--- a/src/share/classes/jdk/dio/generic/GenericDeviceControl.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/generic/GenericDeviceControl.java	Mon Feb 02 13:46:41 2015 +0400
@@ -29,7 +29,7 @@
  * The class {@code GenericDeviceControl} encapsulates a generic device's configuration
  * and access (I/O) controls. A control can be set or gotten using the
  * {@link GenericDevice#setControl GenericDevice.setControl} and {@link GenericDevice#getControl
- * GenericDevice.getControl} methods. Controls can be used to configure a generic device
+ * GenericDevice.getControl} methods. Controls can be used to configured a generic device
  * a well as performing basic input/output operations. The list of controls supported by a
  * device is device-specific.
  *
--- a/src/share/classes/jdk/dio/generic/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/generic/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -114,8 +114,8 @@
  *     }
  * }
  * </pre>
- * </blockquote> The preceding example is using a <em>try-with-resources</em> statement.
- * The {@link jdk.dio.generic.GenericDevice#close GenericDevice.close}
+ * </blockquote> The preceding example is using a <em>try-with-resources</em> statement;
+ * the {@link jdk.dio.generic.GenericDevice#close GenericDevice.close}
  * method is automatically invoked by the platform at the end of the statement. <blockquote>
  *
  * <pre>
--- a/src/share/classes/jdk/dio/gpio/GPIOPin.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/gpio/GPIOPin.java	Mon Feb 02 13:46:41 2015 +0400
@@ -184,7 +184,7 @@
      *            , {@link GPIOPinConfig#TRIGGER_LOW_LEVEL},
      *            {@link GPIOPinConfig#TRIGGER_BOTH_LEVELS}.
      * @throws IOException
-     *             if an I/O error occurred.
+     *             if an IO error occurred.
      * @throws UnsupportedOperationException
      *             if this GPIO pin cannot be configured with the desired trigger mode.
      * @throws IllegalArgumentException
--- a/src/share/classes/jdk/dio/gpio/GPIOPortConfig.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/gpio/GPIOPortConfig.java	Mon Feb 02 13:46:41 2015 +0400
@@ -188,13 +188,14 @@
     /**
      * Gets the pins composing the port (in the exact same order they compose the port).
      * <p />
-     * A concurrent runtime change of the dynamic configuration parameters of any of the pins composing the port (such
-     * as of its direction) may result in {@code IOException} being thrown by port operations.
+     * A concurrent runtime change of the
+     * dynamic configuration parameters of any of the pins composing the port (such as of its direction) may result in
+     * {@code IOException} being thrown by port operations.
      *
      * @return the pins composing the port (a defensive copy is returned); or {@code null}
-     * if this {@code GPIOPortConfig} instance is not associated to an actual GPIOPort instance - that is the
-     * GPIOPortConfig instance was not retrieved from a call to getDescriptor().getConfiguration() on the {@code
-     * GPIOPort} instance.
+     * if this {@code GPIOPortConfig} instance is not associated to an actual {@code GPIOPort} instance -
+     * that is the {@code GPIOPortConfig} instance was not retrieved from a call to
+     * {@code getDescriptor().getConfiguration()} on the {@code GPIOPort} instance.
      */
     public GPIOPin[] getPins() {
         if (pins != null) {
--- a/src/share/classes/jdk/dio/gpio/PinListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/gpio/PinListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -28,7 +28,8 @@
 import jdk.dio.DeviceEventListener;
 
 /**
- * The {@code PinListener} interface defines methods for getting notified of GPIO pin value changes. <br />
+ * The {@code PinListener} interface defines methods for getting notified of GPIO pin value changes.
+ * <p />
  * A {@code PinListener} can be registered using the {@link GPIOPin#setInputListener
  * GPIOPin.setInputListener} method.
  *
--- a/src/share/classes/jdk/dio/gpio/PortListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/gpio/PortListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -27,7 +27,8 @@
 
 /**
  * The {@code PortListener} interface defines methods for getting notified of GPIO port value
- * changes. <br />
+ * changes.
+ * <p />
  * A {@code PortListener} can be registered using the {@link GPIOPort#setInputListener
  * GPIOPort.setInputListener} method.
  *
--- a/src/share/classes/jdk/dio/gpio/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/gpio/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -94,8 +94,8 @@
  *     // handle exception
  * }
  * </pre>
- * </blockquote> The preceding example is using a <em>try-with-resources</em> statement.
- * The {@link jdk.dio.gpio.GPIOPin#close GPIOPin.close} method is
+ * </blockquote> The preceding example is using a <em>try-with-resources</em> statement;
+ * the {@link jdk.dio.gpio.GPIOPin#close GPIOPin.close} method is
  * automatically invoked by the platform at the end of the statement.
  * <p />
  * The underlying platform configuration may allow for some GPIO pins or ports to be set
--- a/src/share/classes/jdk/dio/i2cbus/I2CCombinedMessage.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/i2cbus/I2CCombinedMessage.java	Mon Feb 02 13:46:41 2015 +0400
@@ -87,8 +87,8 @@
      * @param rxBuf the buffer into which the data is read.
      * @return a reference to this {@code I2CCombinedMessage} object.
      * @throws NullPointerException if {@code rxBuf} is {@code null}.
-     * @throws IllegalStateException if this message has already been
-     * transferred once and therefore the message assembling is over.
+     * @throws IllegalStateException if this message has already been assembled
+     * and transferred once.
      * @throws ClosedDeviceException if the device has been closed.
      * @throws IllegalArgumentException if appending the read operation to a
      * slave on a different bus than the one this {@code I2CCombinedMessage} object was created for.
@@ -115,8 +115,8 @@
      * @param rxBuf the buffer into which the data is read.
      * @return a reference to this {@code I2CCombinedMessage} object.
      * @throws NullPointerException if {@code rxBuf} is {@code null}.
-     * @throws IllegalStateException if this message has already been
-     * transferred once and therefore the message assembling is over.
+     * @throws IllegalStateException if this message has already been assembled
+     * and transferred once.
      * @throws ClosedDeviceException if the device has been closed.
      * @throws IllegalArgumentException if {@code rxSkip} is negative or if
      * appending the read operation to a slave on a different bus than the one this {@code I2CCombinedMessage} object was created for.
@@ -141,8 +141,8 @@
      * @param txBuf the buffer containing the bytes to write.
      * @return a reference to this {@code I2CCombinedMessage} object.
      * @throws NullPointerException if {@code txBuf} is {@code null}.
-     * @throws IllegalStateException if this message has already been
-     * transferred once and therefore the message assembling is over.
+     * @throws IllegalStateException if this message has already been assembled
+     * and transferred once.
      * @throws ClosedDeviceException if the device has been closed.
      * @throws IllegalArgumentException if appending the write operation to a
      * slave on a different bus than the one this {@code I2CCombinedMessage} object was created for.
@@ -156,16 +156,16 @@
      * contained messages/operations to be sent/executed in the same order they
      * have been appended to this combined message.
      * <p />
-     * This method may be invoked at any time. If another thread has already initiated a read or write
-     * operation upon this slave device, however, then an invocation of this method will block until
-     * the first operation is complete.
+     * This method may be invoked at any time. If another thread has already initiated a transaction
+     * (see {@link jdk.dio.Transactional}) or, a read or write operation upon any of the targeted slave devices,
+     * however, then an invocation of this method will block until the first operation is complete.
      * <p />
      * Once transferred no additional operation can be appended anymore to this
      * combined message. Any such attempt will result in a
      * {@link IllegalStateException} to be thrown.
      * Nevertheless, this {@code I2CCombinedMessage} object can be reused several times to perform
      * the same sequence of operations. The data transferred
-     * to or from each of the provided {@code ByteBuffer}s is determined by its current {@code position}
+     * to or from each of the provided {@code ByteBuffer}s is determined by their respective current {@code position}
      * and {@code remaining} attributes at the time this method is call.
      * <br />
      * Buffers are not safe for use by multiple concurrent threads so care should
--- a/src/share/classes/jdk/dio/power/PowerManaged.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/power/PowerManaged.java	Mon Feb 02 13:46:41 2015 +0400
@@ -113,7 +113,6 @@
  * {@link #requestPowerStateChange requestPowerStateChange} has expired the device's power state always transitions to
  * {@link #POWER_ON}.</dd>
  * </dl>
- * <p />
  *
  * @see PowerSavingHandler
  * @since 1.0
--- a/src/share/classes/jdk/dio/power/PowerSavingHandler.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/power/PowerSavingHandler.java	Mon Feb 02 13:46:41 2015 +0400
@@ -68,6 +68,9 @@
      * {@link #handlePowerStateChange handlePowerStateChange} method is invoked on these same {@code PowerSavingHandler}s with the smallest
      * of the negotiated durations unless the power state change has been vetoed.
      *
+     * @param <P>
+     *            the type of the device for which a power state change is requested.
+     *
      * @param device
      *            the {@link Device} instance for which a power state change is requested or {@code null} if this
      *            {@link PowerSavingHandler} is registered for group notifications.
@@ -98,6 +101,9 @@
      * <li>upon an urgent (non-vetoable) power state change requested by the power management facility.</li>
      * </ul>
      *
+     * @param <P>
+     *            the type of the device for which a power state change is requested.
+     *
      * @param device
      *            the {@link Device} instance for which a power state change is requested or {@code null} if this
      *            {@link PowerSavingHandler} is registered for group notifications.
--- a/src/share/classes/jdk/dio/pwm/GenerationEvent.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/pwm/GenerationEvent.java	Mon Feb 02 13:46:41 2015 +0400
@@ -30,7 +30,7 @@
 /**
  * The {@code GenerationEvent} class encapsulates pulse a generation completion condition (i.e. generated pulse count
  * value reached). <br />
- * This kind of events is <em>never coalesced</em>.
+ * {@code GenerationEvent}s are <em>never coalesced</em>.
  *
  * @see PWMChannel
  * @see GenerationListener
--- a/src/share/classes/jdk/dio/pwm/GenerationListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/pwm/GenerationListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -31,8 +31,8 @@
 /**
  * The {@code GenerationListener} interface defines methods for getting notified of pulse generation completion
  * conditions (i.e. maximum generated pulse count value reached) as well as device errors.
- * A {@code GenerationListener} can be registered using
- * one of the {@link PWMChannel#startGeneration} methods.
+ * <p />
+ * A {@code GenerationListener} can be registered using the {@link PWMChannel#startGeneration(int, int, jdk.dio.pwm.GenerationListener) PWMChannel.startGeneration} method.
  *
  * @see PWMChannel#startGeneration(int, int, GenerationListener)
  * @since 1.0
--- a/src/share/classes/jdk/dio/pwm/GenerationRoundListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/pwm/GenerationRoundListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -31,12 +31,11 @@
 
 /**
  * The {@code GenerationRoundListener} interface defines methods for getting notified of the completion of the
- * generation of a sequence of pulses and that more pulses (the width thereof) to generate may be specified.
- * <p />
+ * generation of a sequence of pulses and that more pulses (the width thereof) to generate may be specified. <br />
  * This interface also indirectly extends the {@link jdk.dio.AsyncErrorHandler AsyncErrorHandler} interface for getting notified of asynchronous I/O errors.
  * <p />
  * A {@code GenerationRoundListener} can be registered using one of the
- * {@link PWMChannel#startGeneration PWMChannel.startGeneration} methods.
+ * {@link PWMChannel#startGeneration(java.nio.IntBuffer, jdk.dio.pwm.GenerationRoundListener) PWMChannel.startGeneration} methods.
  *
  * @see PWMChannel#startGeneration PWMChannel.startGeneration
  * @since 1.0
--- a/src/share/classes/jdk/dio/pwm/PWMChannel.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/pwm/PWMChannel.java	Mon Feb 02 13:46:41 2015 +0400
@@ -65,7 +65,7 @@
  * close the PWM channel. Any further attempt to use a PWM channel which has been closed will result in a
  * {@link ClosedDeviceException} been thrown.
  * <p />
- * Upon opening a PWM channel the default pulse width and duty cycle are always {@code 0}. The idle
+ * Upon opening a PWM channel the default pulse width and duty cycle are always {@code 0}; the idle
  * state is platform or configuration-specific.
  *
  * @see GenerationListener
@@ -78,6 +78,12 @@
 
     /**
      * Sets the pulse period of this PWM channel.
+     * <p />
+     * The pulse period is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested pulse period value
+     * then {@code period} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete period value. The resulting, actual
+     * pulse period can be retrieved by a call to {@link #getPulsePeriod() getPulsePeriod}.
      *
      * @param period
      *            the pulse period as a period in microseconds.
@@ -99,6 +105,8 @@
     /**
      * Gets the pulse period of this PWM channel (in microseconds). If the pulse period was not set previously using
      * {@link #setPulsePeriod setPulsePeriod} the device configuration-specific default value is returned.
+     * Additionally, the value returned may differ from the previously set or configured value as it may have
+     * been adjusted to account for the resolution or discrete pulse period values supported by the underlying platform or driver.
      *
      * @return the pulse period (in microseconds).
      * @throws IOException
@@ -147,6 +155,10 @@
      * float dutyCycle = 0.5f;
      * pwmChannel.generate((pwmChannel.getPulsePeriod() * dutyCycle), count);
      * </pre>
+     * The pulse width is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested width value
+     * then {@code width} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete width value.
      * <p />
      * The operation will return only after generating all of the {@code count} requested pulses.
      * <p />
@@ -177,7 +189,7 @@
     void generate(int width, int count) throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Generates a pulse train containing {@code count} pulses of the specified widths. The provded buffer contains the
+     * Generates a pulse train from the specified sequence of pulse widths. The provided buffer contains the
      * widths of the pulses to generate.
      * <p />
      * <i>r</i> pulses will be generated by this channel, where <i>r</i> is the number of integers (pulse widths)
@@ -201,6 +213,12 @@
      * is greater than the currently set period. If a pulse width value is not within range
      * the actual width of the pulse generated by the PWM device is hardware- or driver-specific: the pulse width
      * may for example be equal to the set period, corresponding to a 100% duty cycle.
+     * <br />
+     * The pulse width is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested width value
+     * then the actual width of the pulse generated by the PWM device is hardware- or driver-specific: the pulse width
+     * may for example be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete width value.
      *
      * @param src
      *            the buffer from which the pulse width integer values can be retrieved.
@@ -222,6 +240,11 @@
      * until explicitly stopped.
      * <p />
      * The pulses will be generated according to the current pulse period as returned by {@link #getPulsePeriod getPulsePeriod}.
+     * <p />
+     * The pulse width is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested width value
+     * then {@code width} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete width value.
      * <p/>
      * Pulse generation will immediately start and proceed asynchronously. It may be stopped prior to completion by a
      * call to {@link #stopGeneration stopGeneration}.
@@ -252,6 +275,11 @@
      * the count of generated pulses reaches the specified count value.
      * <p />
      * The pulses will be generated according to the current pulse period as returned by {@link #getPulsePeriod getPulsePeriod}.
+     * <p />
+     * The pulse width is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested width value
+     * then {@code width} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete width value.
      * <p/>
      * Pulse generation will immediately start and proceed asynchronously. It may be stopped prior to completion by a
      * call to {@link #stopGeneration stopGeneration}.
@@ -308,27 +336,39 @@
      * pulse period can be changed by the provided {@link GenerationRoundListener} instance upon notification of each
      * pulse train subsequence.
      * <p />
+     * Upon notification of the provided {@code GenerationRoundListener}
+     * the reference to the provided {@code src} buffer can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A buffer with {@code 0} integers remaining to be written (that is a buffer already empty) at the moment this method is initially
      * invoked or then subsequently when the listener is returning will not stop the asynchronous operation; the listener is
      * guaranteed to be called back again at the latest as soon as all other events pending at the time of notification have been dispatched.
-     * <p />
-     * Interfering with the asynchronous operation by accessing and modifying the provided buffer concurrently
-     * may yield unpredictable results.
+     * The underrun condition resulting from the listener notification
+     * returning with an empty buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one pulse generation (synchronous or asynchronous) can be going on at any time.
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
      * be taken to not access the provided buffer until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffer concurrently
+     * may yield unpredictable results.
      * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the designated pulse width values
      * is greater than the currently set period. If a pulse width value is not within range
      * the actual width of the pulse generated by the PWM device is hardware- or driver-specific: the pulse width
      * may for example be equal to the set period, corresponding to a 100% duty cycle.
+     * <br />
+     * The pulse width is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support a requested width value
+     * then the actual width of the pulse generated by the PWM device is hardware- or driver-specific: the pulse width
+     * may for example be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete width value.
      *
      * @param src
      *            the buffer for the widths (in microseconds) of the pulses to generate.
      * @param listener
-     *            the {@link GenerationRoundListener} instance to be notified when pulses have been geneerated for all
+     *            the {@link GenerationRoundListener} instance to be notified when pulses have been generated for all
      *            the width values remaining in the buffer.
      * @throws NullPointerException
      *             If {@code src} or {@code listener} is {@code null}.
@@ -348,30 +388,50 @@
      * Starts asynchronous pulse train generation in successive rounds.
      * <p />
      * This method behaves identically to {@link #startGeneration(IntBuffer, GenerationRoundListener)} excepts that it
-     * uses double-buffering. Notification will happen when pulses have been generated for all the width values
+     * uses double-buffering - the provided buffers must not have a zero-capacity and must not overlap
+     * - that is the backing array sections or memory regions they refer to must not overlap.
+     * Notification will happen when pulses have been generated for all the width values
      * remaining in the current working buffer (initially {@code src1}) and generation will proceed with the alternate buffer (which will become the
-     * current working buffer). Generation will only be suspended if the previous event has not yet been handled.
+     * current working buffer). Generation will only be suspended if the previous event has not yet been handled. Also,
+     * the position of the current working buffer upon stopping this asynchronous operation by a call to
+     * {@link #stopGeneration stopGeneration} is not predictable even if called from within the
+     * listener.
      * <p />
+     * Upon notification of the provided {@code GenerationRoundListener}
+     * the reference to the  current working buffer (initially {@code src1}) can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A working buffer with {@code 0} integers remaining to be written (that is a buffer already empty) at the moment this method is initially
      * invoked or then subsequently when the listener is returning will not stop the asynchronous operation; the listener is
      * guaranteed to be called back again at the latest as soon as all other events pending at the time of notification have been dispatched.
+     * The underrun condition resulting from the listener notification
+     * returning with an empty buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one pulse generation (synchronous or asynchronous) can be going on at any time.
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
-     * be taken to not access the working buffer until the operation (or a round thereof) has completed.
+     * be taken to not access the provided buffers until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffers concurrently
+     * may yield unpredictable results.
      * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the designated pulse width values
      * is greater than the currently set period. If a pulse width value is not within range
      * the actual width of the pulse generated by the PWM device is hardware- or driver-specific: the pulse width
      * may for example be equal to the set period, corresponding to a 100% duty cycle.
+     * <br />
+     * The pulse width is expressed in microseconds; if the underlying platform or driver
+     * does not support a microsecond resolution or does not support the requested width value
+     * then the actual width of the pulse generated by the PWM device is hardware- or driver-specific: the pulse width
+     * may for example be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete width value.
      *
      * @param src1
      *            the first buffer for the widths (in microseconds) of the pulses to generate.
      * @param src2
      *            the second buffer for the widths (in microseconds) of the pulses to generate.
      * @param listener
-     *            the {@link GenerationRoundListener} instance to be notified when pulses have been geneerated for all
+     *            the {@link GenerationRoundListener} instance to be notified when pulses have been generated for all
      *            the width values remaining in the working buffer.
      * @throws NullPointerException
      *             If {@code src1}, {@code src2} or {@code listener} is {@code null}.
@@ -383,12 +443,16 @@
      *             if the device has been closed.
      * @throws IllegalStateException
      *             if another synchronous or asynchronous output generation is already active.
+     * @throws IllegalArgumentException
+     *             if any of the buffers {@code src1} and {@code src2} has a zero-capacity or
+     *             if they are the same or overlap.
      */
     void startGeneration(IntBuffer src1, IntBuffer src2, GenerationRoundListener listener) throws IOException,
             UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Stops (cancels) the currently active pulse generation session.
+     * Stops (cancels) the currently active pulse generation session as started by a call to one
+     * of the {@link #startGeneration startGeneration} methods.
      * <p />
      * This method return silently if no pulse generation session is currently active.
      *
--- a/src/share/classes/jdk/dio/pwm/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/pwm/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -24,7 +24,7 @@
  */
 
 /**
- * Interfaces and classes for generating PWM pulses on a digital output line.
+ * Interfaces and classes for generating width-modulated pulses - Pulse Width Modulation (PWM) - on a digital output line.
  * <p />
  * In order to access and control a specific PWM channel, an application should first open and obtain an
  * {@link jdk.dio.pwm.PWMChannel} instance for the PWM generator's channel the application wants to
--- a/src/share/classes/jdk/dio/spi/DeviceProvider.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/spi/DeviceProvider.java	Mon Feb 02 13:46:41 2015 +0400
@@ -47,8 +47,6 @@
  * set of <i>properties</i> the {@link jdk.dio.DeviceManager DeviceManager} looks up a suitable
  * {@code DeviceProvider} using the <em>Service-Provider Loading</em> facility. It iterates over all the
  * {@code DeviceProvider} classes registered as <em>Service Providers</em> until all the following steps succeed:
- * </dt>
- * <dd>
  * <ol>
  * <li>check that the {@code DeviceProvider} is of the proper <i>type</i> by first invoking its {@link #getType()
  * getType} method and/or is supporting the proper <i>configuration type</i> by invoking its {@link #getConfigType()
@@ -60,8 +58,6 @@
  * {@link #open(DeviceConfig, java.lang.String[], int) open} method with the specified
  * <i>configuration</i>, <i>properties</i> and access mode; note that this step may fail with an exception.</li>
  * </ol>
- * </dd>
- * </dl>
  * <p />
  * Classes implementing the {@code DeviceProvider} interface MUST have a zero-argument constructor so that they
  * can be instantiated by the device manager (as per the <em>Service-Provider Loading</em> facility specification
@@ -75,7 +71,7 @@
  * For example, for a JAR file containing the driver for the Real-Time Clock sample, this file
  * may contain the following single line:
  * <blockquote>
- * {@code jdk.dio.samples.rtc.RealTimeClockProvider} #Real-Time Clock sample
+ * {@code jdk.dio.samples.rtc.RealTimeClockProvider #Real-Time Clock sample}
  * </blockquote>
  *
  * @param <P>
--- a/src/share/classes/jdk/dio/spi/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/spi/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -26,7 +26,7 @@
 /**
  * Service-provider classes for the {@link jdk.dio} package.
  *
- * Only developers who are defining new device driver providers can make direct use of this package.
+ * Only developers who are defining new device driver providers should need to make direct use of this package.
  * <p />
  * Unless otherwise noted, passing a {@code null} argument to a constructor or method in any class
  * or interface in this package will cause a {@link java.lang.NullPointerException NullPointerException} to be thrown.
--- a/src/share/classes/jdk/dio/uart/UART.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/uart/UART.java	Mon Feb 02 13:46:41 2015 +0400
@@ -101,6 +101,21 @@
     int getDataBits() throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
+     * Gets the current flow control mode.
+     *
+     * @return the flow control mode: {@link UARTConfig#FLOWCONTROL_NONE} if flow control is disabled; or a valid bit-wise OR combination of
+     *         {@link UARTConfig#FLOWCONTROL_RTSCTS_IN}, {@link UARTConfig#FLOWCONTROL_RTSCTS_OUT}, {@link UARTConfig#FLOWCONTROL_XONXOFF_IN} or
+     *         {@link UARTConfig#FLOWCONTROL_XONXOFF_OUT}.
+     * @throws UnavailableDeviceException
+     *             if this device is not currently available - such as it is locked by another application.
+     * @throws ClosedDeviceException
+     *             if the device has been closed.
+     * @throws IOException
+     *             if some other I/O error occurs.
+     */
+    int getFlowControlMode() throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
      * Gets the current parity.
      *
      * @return the speed parity: {@link UARTConfig#PARITY_ODD}, {@link UARTConfig#PARITY_EVEN},
@@ -200,7 +215,27 @@
      * @throws IOException
      *             if some other I/O error occurs.
      */
-    void setEventListener(int eventId, UARTEventListener listener) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+    void setEventListener(int eventId, UARTEventListener listener) throws IOException, ClosedDeviceException;
+
+    /**
+     * Sets the flow control mode.
+     *
+     * @param flowcontrol
+     *            the flow control mode: {@link UARTConfig#FLOWCONTROL_NONE} if flow control is disabled; or a bit-wise OR combination of
+     *            {@link UARTConfig#FLOWCONTROL_RTSCTS_IN}, {@link UARTConfig#FLOWCONTROL_RTSCTS_OUT}, {@link UARTConfig#FLOWCONTROL_XONXOFF_IN} or
+     *            {@link UARTConfig#FLOWCONTROL_XONXOFF_OUT}.
+     * @throws UnsupportedOperationException
+     *             if this UART cannot be configured with the requested flow control mode.
+     * @throws IllegalArgumentException
+     *             if {@code flowcontrol} is not in the defined range or if more than one input or more than one output flow control mode is specified.
+     * @throws UnavailableDeviceException
+     *             if this device is not currently available - such as it is locked by another application.
+     * @throws ClosedDeviceException
+     *             if the device has been closed.
+     * @throws IOException
+     *             if some other I/O error occurs.
+     */
+    void setFlowControlMode(int flowcontrol) throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
      * Sets the parity.
@@ -271,12 +306,16 @@
      * baud rate and other configuration parameters can be changed by the provided {@link OutputRoundListener} instance
      * upon notification of each round.
      * <p />
+     * Upon notification of the provided {@code OutputRoundListener}
+     * the reference to the provided {@code src} buffer can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A buffer with {@code 0} bytes remaining to be written (that is a buffer already empty) at the moment this method is initially
      * invoked or then subsequently when the listener is returning will not stop the asynchronous operation; the listener is
      * guaranteed to be called back again at the latest as soon as all other events pending at the time of notification have been dispatched.
-     * <p />
-     * Interfering with the asynchronous operation by accessing and modifying the provided buffer concurrently
-     * may yield unpredictable results.
+     * The underrun condition resulting from the listener notification
+     * returning with an empty buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one write operation (synchronous or asynchronous) can be going on at any time.
      * <br />
@@ -288,6 +327,8 @@
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
      * be taken to not access the provided buffer until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffer concurrently
+     * may yield unpredictable results.
      *
      * @param src
      *            the buffer for the data to be written.
@@ -295,7 +336,7 @@
      *            the {@link OutputRoundListener} instance to be notified when the all the data remaining
      * in the buffer has been written.
      * @throws NullPointerException
-     *             If {@code src} or {@code listener} is {@code null}.
+     *             if {@code src} or {@code listener} is {@code null}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
@@ -311,13 +352,25 @@
      * Starts asynchronous writing in successive rounds.
      * <p />
      * This method behaves identically to {@link #startWriting(ByteBuffer, OutputRoundListener)} excepts that it
-     * uses double-buffering. Notification will happen when all the data remaining in the current working buffer (initially {@code src1}) has been written
+     * uses double-buffering - the provided buffers must not have a zero-capacity and must not overlap
+     * - that is their backing arrays or the memory regions they refer to must not overlap.
+     * Notification will happen when all the data remaining in the current working buffer (initially {@code src1}) has been written
      * and writing will proceed with the alternate buffer (which will become the
-     * current working buffer). Writing will only be suspended if the previous event has not yet been handled.
+     * current working buffer). Writing will only be suspended if the previous event has not yet been handled. Also,
+     * the position of the current working buffer upon stopping this asynchronous operation by a call to
+     * {@link #stopWriting stopWriting} is not predictable even if called from within the
+     * listener.
      * <p />
+     * Upon notification of the provided {@code OutputRoundListener}
+     * the reference to the  current working buffer (initially {@code src1}) can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A working buffer with {@code 0} bytes remaining to be written (that is a buffer already empty) at the moment this method is initially
      * invoked or then subsequently when the listener is returning will not stop the asynchronous operation; the listener is
      * guaranteed to be called back again at the latest as soon as all other events pending at the time of notification have been dispatched.
+     * The underrun condition resulting from the listener notification
+     * returning with an empty buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one write operation (synchronous or asynchronous) can be going on at any time.
      * <br />
@@ -325,10 +378,11 @@
      * notified to the registered {@code UARTEventListener}
      * independently from the invocation of the provided {@code OutputRoundListener} attempting to call
      * the {@code write} method from within the registered {@code UARTEventListener} will result in an exception.
-     *
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
-     * be taken to not access the working buffer until the operation (or a round thereof) has completed.
+     * be taken to not access the provided buffers until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffers concurrently
+     * may yield unpredictable results.
      *
      * @param src1
      *            the first buffer for the data to be written.
@@ -338,13 +392,16 @@
      *            the {@link OutputRoundListener} instance to be notified when all
      *            the data remaining in the working buffer has been written.
      * @throws NullPointerException
-     *             If {@code src1}, {@code src2} or {@code listener} is {@code null}.
+     *             if {@code src1}, {@code src2} or {@code listener} is {@code null}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
      *             if the device has been closed.
      * @throws IllegalStateException
      *             if another synchronous or asynchronous output operation is already active.
+     * @throws IllegalArgumentException
+     *             if any of the buffers {@code src1} and {@code src2} has a zero-capacity or
+     *             if they are the same or overlap.
      * @throws IOException
      *             if some other I/O error occurs such as the device is not writable.
      */
@@ -352,7 +409,8 @@
             UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Stops (cancels) the currently active writing session.
+     * Stops (cancels) the currently active asynchronous writing session as started by a call to one
+     * of the {@link #startWriting startWriting} methods.
      * <p />
      * This method return silently if no writing session is currently active.
      *
@@ -393,13 +451,17 @@
      * The data will be read according to the current baud rate as returned by {@link #getBaudRate getBaudRate}. The
      * baud rate and other configuration parameters can be changed by the provided {@link InputRoundListener} instance
      * upon notification of each round.
-      * <p />
+     * <p />
+     * Upon notification of the provided {@code InputRoundListener}
+     * the reference to the provided {@code dst} buffer can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A buffer with {@code 0} bytes remaining to be read (that is a buffer already full) at the moment this method is initially
      * invoked or then subsequently when the listener is returning will not stop the asynchronous operation; the listener is
      * guaranteed to be called back again at the latest as soon as all other events pending at the time of notification have been dispatched.
-     * <p />
-     * Interfering with the asynchronous operation by accessing and modifying the provided buffer concurrently
-     * may yield unpredictable results.
+     * The overrun condition resulting from the listener notification
+     * returning with an already-full buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one read operation (synchronous or asynchronous) can be going on at any time.
      * <br />
@@ -411,6 +473,8 @@
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
      * be taken to not access the provided buffer until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffer concurrently
+     * may yield unpredictable results.
      *
      * @param dst
      *            the buffer for the data to be read.
@@ -418,7 +482,7 @@
      *            the {@link InputRoundListener} instance to be notified when the all remaining
      * space in the buffer has been filled with input data.
      * @throws NullPointerException
-     *             If {@code src} or {@code listener} is {@code null}.
+     *             if {@code src} or {@code listener} is {@code null}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
@@ -434,13 +498,25 @@
      * Starts asynchronous reading in successive rounds.
      * <p />
      * This method behaves identically to {@link #startReading(ByteBuffer, InputRoundListener)} excepts that it
-     * uses double-buffering. Notification will happen when all the remaining space in the current working buffer (initially {@code dst1}) has been filled
+     * uses double-buffering - the provided buffers must not have a zero-capacity and must not overlap
+     * - that is the backing array sections or memory regions they refer to must not overlap.
+     * Notification will happen when all the remaining space in the current working buffer (initially {@code dst1}) has been filled
      * and reading will proceed with the alternate buffer (which will become the
-     * current working buffer). Reading will only be suspended if the previous event has not yet been handled.
+     * current working buffer). Reading will only be suspended if the previous event has not yet been handled. Also,
+     * the position of the current working buffer upon stopping this asynchronous operation by a call to
+     * {@link #stopReading stopReading} is not predictable even if called from within the
+     * listener.
      * <p />
+     * Upon notification of the provided {@code InputRoundListener}
+     * the reference to the  current working buffer (initially {@code dst1}) can be retrieved from the
+     * {@code RoundCompletionEvent} using the {@link jdk.dio.RoundCompletionEvent#getBuffer() getBuffer} method.
+     * <br />
      * A buffer with {@code 0} bytes remaining to be read (that is a buffer already full) at the moment this method is initially
      * invoked or then subsequently when the listener is returning will not stop the asynchronous operation; the listener is
      * guaranteed to be called back again at the latest as soon as all other events pending at the time of notification have been dispatched.
+     * The overrun condition resulting from the listener notification
+     * returning with an already-full buffer will be reported on the subsequent notifications through
+     * the {@link jdk.dio.RoundCompletionEvent#isOnError() RoundCompletionEvent.isOnError} method.
      * <p />
      * Only one read operation (synchronous or asynchronous) can be going on at any time.
      * <br />
@@ -448,10 +524,11 @@
      * notified to the registered {@code UARTEventListener}
      * independently from the invocation of the provided {@code InputRoundListener} attempting to call
      * the {@code read} method from within the registered {@code UARTEventListener} will result in an exception.
-     *
      * <p />
      * Buffers are not safe for use by multiple concurrent threads so care should
-     * be taken to not access the working buffer until the operation (or a round thereof) has completed.
+     * be taken to not access the provided buffers until the operation (or a round thereof) has completed.
+     * Interfering with the asynchronous operation by accessing and modifying the provided buffers concurrently
+     * may yield unpredictable results.
      *
      * @param dst1
      *            the first buffer for the data to be read.
@@ -461,13 +538,16 @@
      *            the {@link InputRoundListener} instance to be notified when all
      *            the space remaining in the working buffer has been filled with input data.
      * @throws NullPointerException
-     *             If {@code dst1}, {@code dst2} or {@code listener} is {@code null}.
+     *             if {@code dst1}, {@code dst2} or {@code listener} is {@code null}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
      *             if the device has been closed.
      * @throws IllegalStateException
      *             if another synchronous or asynchronous input operation is already active.
+     * @throws IllegalArgumentException
+     *             if any of the buffers {@code dst1} and {@code dst2} has a zero-capacity or
+     *             if they are the same or overlap.
      * @throws IOException
      *             if some other I/O error occurs such as the device is not readable.
      */
@@ -475,7 +555,8 @@
             UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Stops (cancels) the currently active reading session.
+     * Stops (cancels) the currently active asynchronous reading session as started by a call to one
+     * of the {@link #startReading startReading} methods.
      * <p />
      * This method return silently if no reading session is currently active.
      *
@@ -489,15 +570,24 @@
     void stopReading() throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Generates a break condition for the specified duration.
+     * Generates a line break for the specified duration.
+     * <p />
+     * The operation will return only after the generation of the line break.
+     * <p />
+     * The line break duration is expressed in milliseconds; if the underlying platform or driver
+     * does not support a milliseconds resolution or does not support the requested duration value
+     * then {@code duration} will be <em>rounded down</em> to accommodate the supported resolution
+     * or respectively aligned to the closest lower supported discrete duration value.
      *
-     * @param duration duration of the break condition to generate.
+     * @param duration duration of the line break to generate, in milliseconds.
+     * @throws IllegalArgumentException
+     *             if {@code duration} is negative.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
      *             if the device has been closed.
      * @throws UnsupportedOperationException
-     *             if this UART cannot be configured with the requested receive trigger level.
+     *             if this UART does not support <em>line break</em> generation.
      * @throws IOException
      *             if some other I/O error occurs.
      */
@@ -509,11 +599,15 @@
      * the specified number of bytes have been received in the input buffer.
      * If a synchronous read operation is on-going it may then immediately return
      * with the number of bytes already read.
+     * <p />
+     * If {@code level} is zero then <em>receive trigger</em> is disabled.
      *
      * @param level the trigger level, in bytes.
      *
+     * @throws IllegalArgumentException
+     *             if {@code level} is negative.
      * @throws UnsupportedOperationException
-     *             if this UART cannot be configured with the requested receive trigger level.
+     *             if this UART does not support <em>receive trigger</em>.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
@@ -524,9 +618,12 @@
     void setReceiveTriggerLevel(int level) throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Gets the current receive trigger level.
+     * Gets the current receive trigger level. By default, <em>receive trigger</em> is disabled.
+     * If enabled, the value returned may differ from the value previously set using
+     * set previously using {@link #setReceiveTriggerLevel setReceiveTriggerLevel}
+     * as it may have been adjusted to account for level values supported by the underlying platform or driver.
      *
-     * @return the trigger level, in bytes or {@code 0} if this feature is not supported.
+     * @return the trigger level, in bytes; {@code 0} if <em>receive trigger</em> is disabled; {@code -1} if <em>receive trigger</em> is not supported.
      *
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
@@ -543,11 +640,21 @@
      * there is at least one byte in the input buffer and the specified timeout has elapsed.
      * If a synchronous read operation is on-going it may then immediately return
      * with the number of bytes already read.
+     * <p />
+     * The receive timeout is expressed in milliseconds; if the underlying platform or driver
+     * does not support a milliseconds resolution or does not support the requested timeout value
+     * then {@code timeout} will be <em>rounded down</em> to accommodate the supported resolution
+     * or respectively aligned to the closest lower supported discrete timeout value. The resulting, actual
+     * timeout can be retrieved by a call to {@link #getReceiveTimeout() getReceiveTimeout}.
+     * <p />
+     * If {@code timeout} is equal to {@link Integer#MAX_VALUE} then receive timeout is disabled.
      *
      * @param timeout the timeout, in milliseconds.
      *
+     * @throws IllegalArgumentException
+     *             if {@code timeout} is negative.
      * @throws UnsupportedOperationException
-     *             if this UART cannot be configured with the requested receive timeout.
+     *             if this UART does not support <em>receive timeout</em>.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
@@ -558,9 +665,14 @@
     void setReceiveTimeout(int timeout) throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Gets the current receive timeout.
+     * Gets the current receive timeout. By default, <em>receive timeout</em> is disabled.
+     * If enabled, the value returned may differ from the value previously set using
+     * set previously using {@link #setReceiveTimeout setReceiveTimeout}
+     * as it may have been adjusted to account for the resolution or discrete timeout values
+     * supported by the underlying platform or driver.
      *
-     * @return the timeout, in milliseconds or {@code 0} if this feature is not supported.
+     * @return the timeout, in milliseconds; {@link Integer#MAX_VALUE} if <em>receive timeout</em> is disabled;
+     * {@code -1} if <em>receive timeout</em> is not supported.
      *
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
@@ -572,28 +684,55 @@
     int getReceiveTimeout() throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Reads a sequence of bytes from this UART into the given buffer. The method will block
-     * until the requested number of bytes are read or the receive trigger level (if set) has been reached
-     * or the receive timeout (if set) has elapsed.
+     * Reads a sequence of bytes from this UART into the given buffer.
      * <p />
-     * The availability of new input data may be notified through an {@link UARTEvent} with ID
-     * {@link UARTEvent#INPUT_DATA_AVAILABLE} according to the receive trigger level or receive timeout (if set).
-     *
-     * {@inheritDoc}
+     * <i>r</i> bytes will be read from this device, where
+     * <i>r</i> is the number of bytes remaining in the buffer, that is,
+     * {@code dst.remaining()}, at the moment this method is invoked.
+     * <p />
+     * Suppose that a byte sequence of length <i>n</i> is read, where
+     * <i>{@code 0 <= n <= r}
+     * </i>. This byte sequence will be transferred into the buffer so that the
+     * first byte in the sequence is at index <i>p</i> and the last byte is at
+     * index <i>{@code p + n - 1}</i>, where <i>p</i> is the buffer's position at
+     * the moment this method is invoked. Upon return the buffer's position will
+     * be equal to <i>{@code p + n}</i>; its limit will not have changed.
+     * <p />
+     * A read operation might not fill the buffer. It is guaranteed, however, that
+     * if there is at least one byte remaining in the buffer then this method will
+     * block until the requested number of bytes are read or the receive trigger
+     * level (if set) has been reached or the receive timeout (if set) has
+     * elapsed. The availability of new input data may be notified through an
+     * {@link UARTEvent} with ID {@link UARTEvent#INPUT_DATA_AVAILABLE} according
+     * to the receive trigger level or receive timeout (if set); if this method is
+     * invoked within a listener to handle an {@code INPUT_DATA_AVAILABLE} event
+     * then care should be taken to account for
+     * any concurrent synchronous read operation that may have also been unblocked by
+     * that event and that may have already read all or part of the received bytes
+     * that triggered the event.
+     * <p />
+     * This method may be invoked at any time. If another thread has already
+     * initiated a synchronous read upon this device, however, then an invocation
+     * of this method will block until the first operation is complete.
+     * <p />
+     * Only one read operation (synchronous or asynchronous) can be going on at
+     * any time.
      *
      * @param dst
      *            The buffer into which bytes are to be transferred
      *
-     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached end-of-stream
+     * @return The number of bytes read into {@code dst}, possibly zero.
      *
      * @throws NullPointerException
-     *             If {@code dst} is {@code null}.
+     *             if {@code dst} is {@code null}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
      *             if the device has been closed.
      * @throws IOException
      *             if an I/O error occurred such as the device is not readable.
+     * @throws IllegalStateException
+     *             if an asynchronous reading is already active.
      *
      * @see #setReceiveTriggerLevel setReceiveTriggerLevel
      * @see #setReceiveTimeout setReceiveTimeout
@@ -605,8 +744,29 @@
     /**
      * Writes a sequence of bytes to this UART from the given buffer.
      * <p />
+     * <i>r</i> bytes will be written to this device, where <i>r</i> is the number of bytes
+     * remaining in the buffer, that is, {@code src.remaining()}, at the moment this method is
+     * invoked.
+     * <p />
+     * Suppose that a byte sequence of length <i>n</i> is written, where <i>{@code 0 <= n <= r}
+     * </i>. This byte sequence will be transferred from the buffer starting at index <i>p</i>,
+     * where <i>p</i> is the buffer's position at the moment this method is invoked; the index of
+     * the last byte written will be <i>{@code p + n - 1}</i>. Upon return the buffer's position
+     * will be equal to <i>{@code p + n}</i>; its limit will not have changed.
+     * <p />
+     * The operation will return only after writing all of the <i>r</i> requested bytes.
      * An empty output buffer condition may be notified through an {@link UARTEvent} with ID
-     * {@link UARTEvent#OUTPUT_BUFFER_EMPTY}.
+     * {@link UARTEvent#OUTPUT_BUFFER_EMPTY}; if this method is
+     * invoked within a listener to handle an {@code OUTPUT_BUFFER_EMPTY} event
+     * then care should be taken to account for any concurrent synchronous write operation
+     * that may have also been unblocked by that same condition and that may have already
+     * written bytes filling all or part of the available buffer space.
+     * <p />
+     * This method may be invoked at any time. If another thread has already initiated a synchronous
+     * write operation upon this device, however, then an invocation of this method will block
+     * until the first operation is complete.
+     * <p />
+     * Only one write operation (synchronous or asynchronous) can be going on at any time.
      *
      * {@inheritDoc}
      *
@@ -614,13 +774,15 @@
      *            The buffer from which bytes are to be retrieved
      * @return The number of bytes written from {@code src}, possibly zero.
      * @throws NullPointerException
-     *             If {@code src} is {@code null}.
+     *             if {@code src} is {@code null}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
      *             if the device has been closed.
      * @throws IOException
      *             if an I/O error occurred such as the device is not writable.
+     * @throws IllegalStateException
+     *             if an asynchronous writing is already active.
      */
     @Override
     int write(ByteBuffer src) throws IOException,
--- a/src/share/classes/jdk/dio/uart/UARTConfig.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/uart/UARTConfig.java	Mon Feb 02 13:46:41 2015 +0400
@@ -79,25 +79,25 @@
     /**
      * RTS/CTS (hardware) flow control on input.
      * <p />
-     * This bit flag can be bitwise-combined (OR) with other flow control bit flags.
+     * This bit flag can be bitwise-combined (OR) with other output flow control bit flags.
      */
     public static final int FLOWCONTROL_RTSCTS_IN = 1;
     /**
      * RTS/CTS (hardware) flow control on output.
      * <p />
-     * This bit flag can be bitwise-combined (OR) with other flow control bit flags.
+     * This bit flag can be bitwise-combined (OR) with other output flow control bit flags.
      */
     public static final int FLOWCONTROL_RTSCTS_OUT = 2;
     /**
      * XON/XOFF (software) flow control on input.
      * <p />
-     * This bit flag can be bitwise-combined (OR) with other flow control bit flags.
+     * This bit flag can be bitwise-combined (OR) with other input flow control bit flags.
      */
     public static final int FLOWCONTROL_XONXOFF_IN = 4;
     /**
      * XON/XOFF (software) flow control on output.
      * <p />
-     * This bit flag can be bitwise-combined (OR) with other flow control bit flags.
+     * This bit flag can be bitwise-combined (OR) with other input flow control bit flags.
      */
     public static final int FLOWCONTROL_XONXOFF_OUT = 8;
     /**
@@ -168,7 +168,7 @@
      *            the number of stop bits per character, on of: {@link #STOPBITS_1}, {@link #STOPBITS_1_5}, or
      *            {@link #STOPBITS_2}.
      * @param flowcontrol
-     *            the flow control mode - a bit-wise OR combination of {@link #FLOWCONTROL_NONE},
+     *            the flow control mode: {@link #FLOWCONTROL_NONE} if flow control is disabled; or a bit-wise OR combination of
      *            {@link #FLOWCONTROL_RTSCTS_IN}, {@link #FLOWCONTROL_RTSCTS_OUT}, {@link #FLOWCONTROL_XONXOFF_IN} or
      *            {@link #FLOWCONTROL_XONXOFF_OUT}.
      *
@@ -181,7 +181,7 @@
      *             <li>{@code dataBits} is not in the defined range;</li>
      *             <li>{@code parity} is not in the defined range;</li>
      *             <li>{@code stopBits} is not in the defined range;</li>
-     *             <li>{@code flowcontrol} is not in the defined range.</li>
+     *             <li>{@code flowcontrol} is not in the defined range or if more than one input or more than one output flow control mode is specified.</li>
      *             </ul>
      */
     public UARTConfig(int controllerNumber, int channelNumber, int baudRate, int dataBits, int parity, int stopBits, int flowcontrol) {
@@ -208,7 +208,7 @@
      *            the number of stop bits per character, on of: {@link #STOPBITS_1}, {@link #STOPBITS_1_5}, or
      *            {@link #STOPBITS_2}.
      * @param flowcontrol
-     *            the flow control mode - a bit-wise OR combination of {@link #FLOWCONTROL_NONE},
+     *            the flow control mode: {@link #FLOWCONTROL_NONE} if flow control is disabled; or a bit-wise OR combination of
      *            {@link #FLOWCONTROL_RTSCTS_IN}, {@link #FLOWCONTROL_RTSCTS_OUT}, {@link #FLOWCONTROL_XONXOFF_IN} or
      *            {@link #FLOWCONTROL_XONXOFF_OUT}.
      * @param inputBufferSize
@@ -225,7 +225,7 @@
      *             <li>{@code dataBits} is not in the defined range;</li>
      *             <li>{@code parity} is not in the defined range;</li>
      *             <li>{@code stopBits} is not in the defined range;</li>
-     *             <li>{@code flowcontrol} is not in the defined range;</li>
+     *             <li>{@code flowcontrol} is not in the defined range or if more than one input or more than one output flow control mode is specified.</li>
      *             <li>{@code inputBufferSize} is not in the defined range;</li>
      *             <li>{@code outputBufferSize} is not in the defined range.</li>
      *             </ul>
@@ -263,7 +263,7 @@
      *            the number of stop bits per character, on of: {@link #STOPBITS_1}, {@link #STOPBITS_1_5}, or
      *            {@link #STOPBITS_2}.
      * @param flowcontrol
-     *            the flow control mode - a bit-wise OR combination of {@link #FLOWCONTROL_NONE},
+     *            the flow control mode: {@link #FLOWCONTROL_NONE} if flow control is disabled; or a bit-wise OR combination of
      *            {@link #FLOWCONTROL_RTSCTS_IN}, {@link #FLOWCONTROL_RTSCTS_OUT}, {@link #FLOWCONTROL_XONXOFF_IN} or
      *            {@link #FLOWCONTROL_XONXOFF_OUT}.
      *
@@ -275,7 +275,7 @@
      *             <li>{@code dataBits} is not in the defined range;</li>
      *             <li>{@code parity} is not in the defined range;</li>
      *             <li>{@code stopBits} is not in the defined range;</li>
-     *             <li>{@code flowcontrol} is not in the defined range.</li>
+     *             <li>{@code flowcontrol} is not in the defined range or if more than one input or more than one output flow control mode is specified.</li>
      *             </ul>
      * @throws NullPointerException
      *             if {@code controllerName} is {@code null}.
@@ -304,7 +304,7 @@
      *            the number of stop bits per character, on of: {@link #STOPBITS_1}, {@link #STOPBITS_1_5}, or
      *            {@link #STOPBITS_2}.
      * @param flowcontrol
-     *            the flow control mode - a bit-wise OR combination of {@link #FLOWCONTROL_NONE},
+     *            the flow control mode: {@link #FLOWCONTROL_NONE} if flow control is disabled; or a bit-wise OR combination of
      *            {@link #FLOWCONTROL_RTSCTS_IN}, {@link #FLOWCONTROL_RTSCTS_OUT}, {@link #FLOWCONTROL_XONXOFF_IN} or
      *            {@link #FLOWCONTROL_XONXOFF_OUT}.
      * @param inputBufferSize
@@ -320,7 +320,7 @@
      *             <li>{@code dataBits} is not in the defined range;</li>
      *             <li>{@code parity} is not in the defined range;</li>
      *             <li>{@code stopBits} is not in the defined range;</li>
-     *             <li>{@code flowcontrol} is not in the defined range;</li>
+     *             <li>{@code flowcontrol} is not in the defined range or if more than one input or more than one output flow control mode is specified.</li>
      *             <li>{@code inputBufferSize} is not in the defined range;</li>
      *             <li>{@code outputBufferSize} is not in the defined range.</li>
      *             </ul>
@@ -379,9 +379,9 @@
     }
 
     /**
-     * Gets the configured flow control mode.
+     * Gets the configured default/initial flow control mode.
      *
-     * @return the flow control mode - a bit-wise OR combination of {@link #FLOWCONTROL_NONE},
+     * @return the flow control mode: {@link #FLOWCONTROL_NONE} if flow control is disabled; or a valid bit-wise OR combination of
      *         {@link #FLOWCONTROL_RTSCTS_IN}, {@link #FLOWCONTROL_RTSCTS_OUT}, {@link #FLOWCONTROL_XONXOFF_IN} or
      *         {@link #FLOWCONTROL_XONXOFF_OUT}.
      */
--- a/src/share/classes/jdk/dio/uart/UARTEventListener.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/uart/UARTEventListener.java	Mon Feb 02 13:46:41 2015 +0400
@@ -29,7 +29,8 @@
 
 /**
  * The {@code UARTEventListener} interface defines methods for getting notified of events fired by devices
- * that implement the {@link UART} interface. <br />
+ * that implement the {@link UART} interface.
+ * <p />
  * A {@code UARTEventListener} can be registered using the {@link UART#setEventListener UART.setEventListener} method.
  *
  * @see UART#setEventListener UART.setEventListener
--- a/src/share/classes/jdk/dio/uart/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/uart/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -123,7 +123,7 @@
  * }
  * </pre>
  *
- * </blockquote> The preceding example is using a <em>try-with-resources</em> statement. The
+ * </blockquote> The preceding example is using a <em>try-with-resources</em> statement; the
  * {@link jdk.dio.uart.UART#close UART.close}, {@link java.io.InputStream#close
  * InputStream.close} and {@link java.io.OutputStream#close OutputStream.close} methods are automatically invoked
  * by the platform at the end of the statement.
--- a/src/share/classes/jdk/dio/watchdog/WatchdogTimer.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/watchdog/WatchdogTimer.java	Mon Feb 02 13:46:41 2015 +0400
@@ -33,8 +33,8 @@
 import romizer.WeakDontRenameClass;
 
 /**
- * The {@code WatchdogTimer} interface provides methods for controlling a watchdog timer that forces the
- * device to restart (or depending on the platform, the Java Virtual Machine to restart).
+ * The {@code WatchdogTimer} interface provides methods for controlling a watchdog timer that can be used to force the
+ * device to reboot (or depending on the platform, the Java Virtual Machine to restart).
  * <p />
  * A {@code WatchdogTimer} instance may represent a virtual watchdog timer. If the device has a single physical watchdog
  * timer, all of the virtual watchdog timers are mapped onto this one physical watchdog timer. It gets set to expire
@@ -49,27 +49,32 @@
  * If a watchdog timer is virtualized, a particular platform implementation may allow for several {@code WatchdogTimer}
  * instances representing each a virtual instance of that same physical watchdog timer to be opened concurrently using
  * the same device ID, or,
- * alternatively, it may assign each virtual watchdog timer instance a distinct device ID (and a common name). <br
- * />
+ * alternatively, it may assign each virtual watchdog timer instance a distinct device ID (and a common name). <br />
  * <p />
  * Once the device opened, the application can start using it and can especially start the timer using the
  * {@link jdk.dio.watchdog.WatchdogTimer#start(long) WatchdogTimer.start} method and subsequently
- * refresh the timer periodically using the {@link jdk.dio.watchdog.WatchdogTimer#refresh
- * WatchdogTimer.refresh} method
- * <p/>
+ * refresh the timer repeatedly/regularly using the {@link jdk.dio.watchdog.WatchdogTimer#refresh
+ * WatchdogTimer.refresh} method to prevent the timeout from elapsing.
+ * <p />
  * When done, an application should call the {@link #close WatchdogTimer.close} method to close the watchdog timer.
  * Any further attempt to access or control a watchdog timer which has been closed will result in a
  * {@link ClosedDeviceException} been thrown.
+ * <p />
+ * This specification does not specify nor require any deterministic behavior or
+ * strict time constraint compliance from the underlying platform or driver.
+ * Therefore the use by applications of watchdog timers must account for the latencies
+ * inherent to such platforms.
  *
+ * @since 1.0
  */
 @apimarker.API("device-io_1.0")
 @WeakDontRenameClass
 public interface WatchdogTimer extends Device<WatchdogTimer> {
 
     /**
-     * Checks if the last device restart (or JVM restart) was caused by the watchdog timing out.
+     * Checks if the last device reboot (or JVM restart) was caused by the watchdog timing out.
      *
-     * @return true if the watchdog timer caused the last device restart (or JVM restart).
+     * @return true if the watchdog timer caused the last device reboot (or JVM restart).
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws UnavailableDeviceException
@@ -94,20 +99,25 @@
 
     /**
      * Get the current timeout for the watchdog timer. A value of zero indicates that the watchdog timer is disabled.
+     * Additionally, the value returned may differ from the previously set value as it may have been adjusted to account
+     * for the resolution or discrete time interval values supported by the underlying platform or driver.
      *
-     * @return the time interval (in milliseconds) until watchdog times out.
+     * @return the time interval (in milliseconds) until watchdog times out; or
+     * {@code 0} if the timer is disabled.
+     *
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
      *             if the device has been closed.
+     * @see #start
      */
     public long getTimeout() throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
      * Refreshes the watchdog timer. This method must be called periodically to prevent the watchdog from timing out and
-     * restarting the device (or restarting the JVM).
+     * rebooting the device (or restarting the JVM).
      * <p />
      * This method has no effect if the timer is currently disabled.
      *
@@ -122,7 +132,13 @@
 
     /**
      * Starts the watchdog timer with the specified timeout. If the watchdog timer is not refreshed by a call to
-     * {@link #refresh refresh} before the watchdog timing out, the device will be restarted (or the JVM restarted).
+     * {@link #refresh refresh} prior to the watchdog timing out, the device will be rebooted (or the JVM restarted).
+     * <p />
+     * The timeout is expressed in milliseconds; if the underlying platform or driver
+     * does not support a millisecond resolution or does not support the requested time interval value
+     * then {@code timeout} will be <em>rounded up</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest greater supported discrete time interval value. The resulting, actual
+     * timeout can be retrieved by a call to {@link #getTimeout() getTimeout}.
      * <p />
      * Calling this method twice is equivalent to stopping the timer as per a call to {@link #stop} and starting
      * it again with the new specified timeout.
@@ -132,7 +148,8 @@
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws IllegalArgumentException
-     *             if {@code timeout} is not greater than {@code 0}.
+     *             if {@code timeout} is not greater than {@code 0} or if {@code timeout} is greater than
+     *             the maximum supported timeout as returned buy {@link #getMaxTimeout()}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another application.
      * @throws ClosedDeviceException
--- a/src/share/classes/jdk/dio/watchdog/WatchdogTimerConfig.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/watchdog/WatchdogTimerConfig.java	Mon Feb 02 13:46:41 2015 +0400
@@ -69,7 +69,7 @@
      * @param timerNumber
      *            the hardware timer's number (a positive or zero integer) or {@link #DEFAULT}.
      * @throws IllegalArgumentException
-     *             if {@code timerNumber} is not in the defined range.</li>
+     *             if {@code timerNumber} is not in the defined range.
      * @throws NullPointerException
      *             if {@code controller name} is {@code null}.
      */
@@ -91,7 +91,7 @@
      * @param timerNumber
      *            the hardware timer's number (a positive or zero integer) or {@link #DEFAULT}.
      * @throws IllegalArgumentException
-     *             if {@code timerNumber} is not in the defined range.</li>
+     *             if {@code timerNumber} is not in the defined range.
      * @throws NullPointerException
      *             if {@code controller name} is {@code null}.
      */
--- a/src/share/classes/jdk/dio/watchdog/WindowedWatchdogTimer.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/watchdog/WindowedWatchdogTimer.java	Mon Feb 02 13:46:41 2015 +0400
@@ -31,11 +31,11 @@
 
 /**
  * The {@code WindowedWatchdogTimer} interface provides methods for controlling a watchdog timer that can be used to
- * force the device to restart (or depending on the platform, the Java Virtual Machine to restart).
+ * force the device to reboot (or depending on the platform, the Java Virtual Machine to restart).
  * <p />
  * The windowed watchdog timer must be refreshed within an open time window. If the watchdog is refreshed too soon -
  * during the closed window - or if it is refreshed too late - after the watchdog timeout has expired - the device will
- * be restarted (or the JVM restarted).
+ * be rebooted (or the JVM restarted).
  * <p />
  * A {@code WindowedWatchdogTimer} instance may represent a virtual windowed watchdog timer. If the device has a single
  * physical windowed watchdog timer, all of the virtual watchdog timers are mapped onto this one physical watchdog
@@ -44,15 +44,18 @@
  * expire. The corresponding watchdog timer device is therefore shared and several applications can concurrently
  * acquire the same watchdog timer device.
  *
+ * @since 1.0
  */
 @apimarker.API("device-io_1.0")
 @WeakDontRenameClass
 public interface WindowedWatchdogTimer extends WatchdogTimer {
 
     /**
-     * Get the current closed window delay for the watchdog timer.
-     * <p />
-     * If the timer is disabled {@code 0} is returned.
+     * Get the current closed window delay for the watchdog timer. If the timer
+     * is disabled {@code 0} is returned. Additionally, the value returned may
+     * differ from the previously set value as it may have been adjusted to account
+     * for the resolution or discrete time interval values supported by the underlying
+     * platform or driver.
      *
      * @return the delay (in milliseconds) until the watchdog timer can be refreshed;
      * or {@code 0} if the timer is disabled.
@@ -61,13 +64,20 @@
      *             if some other I/O error occurs.
      * @throws ClosedDeviceException
      *             if the device has been closed.
+     * @see #start(long, long)
      */
     public long getClosedWindowTimeout() throws IOException, ClosedDeviceException;
 
     /**
      * Starts the watchdog timer with the specified timeout and with a closed window delay set to {@code 0}. If the
-     * watchdog timer is not refreshed by a call to {@link #refresh refresh} before the watchdog timing out, the device will
-     * be restarted (or the JVM restarted).
+     * watchdog timer is not refreshed by a call to {@link #refresh refresh} prior to the watchdog timing out, the device will
+     * be rebooted (or the JVM restarted).
+     * <p />
+     * The timeout is expressed in milliseconds; if the underlying platform or driver
+     * does not support a millisecond resolution or does not support the requested time interval value
+     * then {@code timeout} will be <em>rounded up</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest greater supported discrete time interval value. The resulting, actual
+     * timeout can be retrieved by a call to {@link #getTimeout() getTimeout}.
      * <p />
      * Calling this method twice is equivalent to stopping the timer as per a call to {@link #stop} and starting
      * it again with the new specified timeout and with a closed window delay set to {@code 0}.
@@ -77,7 +87,8 @@
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws IllegalArgumentException
-     *             if {@code timeout} is not greater than {@code 0}.
+     *             if {@code timeout} is not greater than {@code 0} or if {@code timeout} is greater than
+     *             the maximum supported timeout as returned buy {@link #getMaxTimeout()}.
      * @throws ClosedDeviceException
      *             if the device has been closed.
      */
@@ -86,8 +97,20 @@
 
     /**
      * Starts the windowed watchdog timer with the specified closed window delay and timeout. If the {@link #refresh refresh}
-     * method is called too soon, that is within the closed window delay, or too late, that is not called before the
-     * watchdog timing out, the device will be restarted (or the JVM restarted).
+     * method is called too soon, that is within the closed window delay, or too late, that is not called prior to the
+     * watchdog timing out, the device will be rebooted (or the JVM restarted).
+     * <p />
+     * The timeout is expressed in milliseconds; if the underlying platform or driver
+     * does not support a millisecond resolution or does not support the requested time interval value
+     * then {@code timeout} will be <em>rounded up</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest greater supported discrete time interval value. The resulting, actual
+     * timeout can be retrieved by a call to {@link #getTimeout() getTimeout}.
+     * <br />
+     * Similarly, the closed window delay is expressed in milliseconds; if the underlying platform or driver
+     * does not support a millisecond resolution or does not support the requested time interval value
+     * then {@code closedWindowDelay} will be <em>rounded down</em> to accommodate the supported timer resolution
+     * or respectively aligned to the closest lower supported discrete time interval value. The resulting, actual
+     * timeout can be retrieved by a call to {@link #getClosedWindowTimeout() getClosedWindowTimeout}.
      * <p />
      * Calling this method twice is equivalent to stopping the timer as per a call to {@link #stop} and starting
      * it again with the new specified closed window delay and timeout.
@@ -97,8 +120,10 @@
      * @param timeout
      *            the time interval (in milliseconds) until watchdog times out.
      * @throws IllegalArgumentException
-     *             if {@code timeout} is not greater than {@code 0} or if {@code closedWindowDelay} is negative or
-     *             {@code closedWindowDelay} is greater than {@code timeout}.
+     *             if {@code timeout} is not greater than {@code 0} or if {@code timeout} is greater than
+     *             the maximum supported timeout as returned by {@link #getMaxTimeout()}; or
+     *             if {@code closedWindowDelay} is negative or {@code closedWindowDelay}
+     *             is greater than or equal to {@code timeout}.
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws ClosedDeviceException
--- a/src/share/classes/jdk/dio/watchdog/package-info.java	Fri Jan 30 12:21:52 2015 +0300
+++ b/src/share/classes/jdk/dio/watchdog/package-info.java	Mon Feb 02 13:46:41 2015 +0400
@@ -26,18 +26,18 @@
 /**
  * Interfaces and classes for using system watchdog timers (WDT).
  * <p />
- * A watchdog timer is used to reset/restart the system in case of hang or critical failure. This is used to reset the
+ * A watchdog timer is used to reset/reboot the system in case of hang or critical failure. This is used to reset the
  * system from a unresponsive state to a normal state. A watchdog timer can be set with a time interval for the
- * reset/restart. Continuously refreshing the watchdog timer within the specified time interval prevents the
- * reset/restart. If the watchdog timer has not been refreshed within the specified time interval a critical failure is
- * assumed and a system reset/restart is carried out. <br />
+ * reset/reboot. Continuously refreshing the watchdog timer within the specified time interval prevents the
+ * reset/reboot. If the watchdog timer has not been refreshed within the specified time interval a critical failure is
+ * assumed and a system reset/reboot is carried out. <br />
  * A windowed watchdog timer must be refreshed within an open time window. If the watchdog is refreshed too soon -
  * during the closed window - or if it is refreshed too late - after the watchdog timeout has expired - the device will
  * be rebooted.
  * <p />
  * In order to use with a specific watchdog timer, an application should first open and obtain an
  * {@link jdk.dio.watchdog.WatchdogTimer} instance for the watchdog timer the application wants to use,
- * using its numeric ID, name, type (interface) or properties:
+ * using its numeric ID, name, type (interface) and/or properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd>
@@ -107,7 +107,7 @@
  *                 // do something more...
  *             } else {
  *                 // Something goes wrong. Timer will not be kick.
- *                 // If status not recovered within 2-3 turns then system will be restart.
+ *                 // If status not recovered within 2-3 turns then system will be reboot.
  *             }
  *             sleep(60000); // sleep for 1 min.
  *         }
--- a/test/build.xml	Fri Jan 30 12:21:52 2015 +0300
+++ b/test/build.xml	Mon Feb 02 13:46:41 2015 +0400
@@ -2,23 +2,23 @@
 <!--
  Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- 
+
  This code is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License version 2 only, as
  published by the Free Software Foundation.  Oracle designates this
  particular file as subject to the "Classpath" exception as provided
  by Oracle in the LICENSE file that accompanied this code.
- 
+
  This code is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  version 2 for more details (a copy is included in the LICENSE file that
  accompanied this code).
- 
+
  You should have received a copy of the GNU General Public License version
  2 along with this work; if not, write to the Free Software Foundation,
  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- 
+
  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  or visit www.oracle.com if you need additional information or have any
  questions.
@@ -28,12 +28,12 @@
     <import file="nbproject/build-impl.xml"/>
     <loadproperties srcfile="build.properties" />
     <property environment="env"/>
-               
+
     <target name="clean">
         <delete dir="${build.dir}" />
         <delete dir="${dist.dir}" />
     </target>
-    
+
     <target name="compile" depends="check-and-copy-libs">
         <mkdir dir="${classes.dir}" />
         <javac srcdir="${tests.dir}"
@@ -52,7 +52,7 @@
         <jar basedir="${classes.dir}" destfile="${dist.dir}/${dist.jar}">
         </jar>
     </target>
-    
+
     <target name="check-and-copy-libs">
         <copy file="${src.build.dir.jar}" todir="${libs.dir}" />
         <fail message="Required libraries are missing">
@@ -72,40 +72,40 @@
         </fail>
     </target>
 
-    <pathconvert property="javahomefixed" dirsep="/">          
-        <path location="${env.JAVA_HOME}${file.separator}bin${file.separator}java.exe"/> 
-    </pathconvert>
-    
-    <pathconvert property="i18nsrcpath" dirsep="/">          
-        <path location="${basedir}${file.separator}${tests.dir}${file.separator}${i18n.file.path}${file.separator}${i18n.file.name}"/> 
-    </pathconvert>    
-    
-    <pathconvert property="i18ndistpath" dirsep="/">          
-        <path location="${basedir}${file.separator}${classes.dir}${file.separator}${i18n.file.path}"/> 
+    <pathconvert property="javahomefixed" dirsep="/">
+        <path location="${env.JAVA_HOME}${file.separator}bin${file.separator}java.exe"/>
     </pathconvert>
 
-    <pathconvert property="librarypathfixed" dirsep="/">          
-        <path location="${basedir}${file.separator}${src.build.dir.so}"/> 
+    <pathconvert property="i18nsrcpath" dirsep="/">
+        <path location="${basedir}${file.separator}${tests.dir}${file.separator}${i18n.file.path}${file.separator}${i18n.file.name}"/>
     </pathconvert>
-    
-    <pathconvert property="policyfilepathfixed" dirsep="/">          
-        <path location="${basedir}${file.separator}${java.policy.file}"/> 
+
+    <pathconvert property="i18ndistpath" dirsep="/">
+        <path location="${basedir}${file.separator}${classes.dir}${file.separator}${i18n.file.path}"/>
     </pathconvert>
-    
-    <pathconvert property="diopropertiesfilepathfixed" dirsep="/">          
-        <path location="${basedir}${file.separator}${dio.properties.file.raspberry}"/> 
+
+    <pathconvert property="librarypathfixed" dirsep="/">
+        <path location="${basedir}${file.separator}${src.build.dir.so}"/>
     </pathconvert>
-    
+
+    <pathconvert property="policyfilepathfixed" dirsep="/">
+        <path location="${basedir}${file.separator}${java.policy.file}"/>
+    </pathconvert>
+
+    <pathconvert property="diopropertiesfilepathfixed" dirsep="/">
+        <path location="${basedir}${file.separator}${dio.properties.file.raspberry}"/>
+    </pathconvert>
+
     <target name="prepare">
         <property name="testsuite_path" value="${basedir}/${tests.dir}"/>
         <property name="test.basedir" value="${build.dir}" />
         <property name="tests.classpath" value="${classes.dir}${path.separator}${javatest.jar}${path.separator}${jh.jar}${path.separator}${dio.jar}${path.separator}${gson.jar}"/>
         <property name="workdir" value="${test.basedir}${file.separator}${workdir.folder.name}"/>
-        <property name="javatest.java" value="${javahomefixed}"/> 
+        <property name="javatest.java" value="${javahomefixed}"/>
         <property name="librarypath" value="${librarypathfixed}"/>
         <property name="policyfilepath" value="${policyfilepathfixed}"/>
         <property name="diopropertiesfilepath" value="${diopropertiesfilepathfixed}"/>
-        <property name="javatest.jti" value="${test.basedir}${file.separator}${jti.file.name}"/> 
+        <property name="javatest.jti" value="${test.basedir}${file.separator}${jti.file.name}"/>
     </target>
 
     <target name="filter">
@@ -113,7 +113,7 @@
         <filter token="testsuite" value="${testsuite_path}"/>
         <filter token="workdir" value="${workdir}"/>
         <filter token="classpath" value="${tests.classpath}"/>
-        <filter token="java" value="${javatest.java}"/>        
+        <filter token="java" value="${javatest.java}"/>
         <filter token="javalibrarypath" value="${librarypath}"/>
         <filter token="javapolicyfilepath" value="${policyfilepath}"/>
         <filter token="diopropertiesfilepath" value="${diopropertiesfilepath}"/>
@@ -136,13 +136,13 @@
     <target name="javatest-mode-warning" if="${batch.mode}" depends="get-batch-mode">
         <echo message="Tests will be run in batch mode. For UI mode use flag -Djavatest.mode.batch=false"  />
     </target>
-            
+
     <target name="get-batch-mode" depends="get-javatest-opt">
         <condition property="batch.mode" value="true" else="false">
             <equals arg1="${javatest.opt}" arg2="-batch" />
         </condition>
     </target>
-    
+
     <target name="get-javatest-opt">
         <condition property="javatest.opt" value="-batch" else="">
             <equals arg1="${javatest.mode.batch}" arg2="true" />
@@ -152,7 +152,7 @@
     <target name="run-javatest" depends="check-java-home, init, prepare, jar, filter, javatest-mode-warning">
         <mkdir dir="${workdir}"/>
 
-        <java classpath="${classes.dir}${path.separator}${javatest.jar}${path.separator}${jh.jar}${path.separator}${gson.jar}" 
+        <java classpath="${classes.dir}${path.separator}${javatest.jar}${path.separator}${jh.jar}${path.separator}${gson.jar}"
               classname="com.sun.javatest.tool.Main" fork="true" failonerror="false" jvm="${javatest.java}">
             <arg line="-testsuite"/>
             <arg line="${testsuite_path}"/>
--- a/test/jdk/dio/runner/interview/i18n.properties	Fri Jan 30 12:21:52 2015 +0300
+++ b/test/jdk/dio/runner/interview/i18n.properties	Mon Feb 02 13:46:41 2015 +0400
@@ -72,7 +72,7 @@
 BasicInterview.parameters.text = The next series DIO questions configure the basic test execution settings used by JT Harness.
 
 BasicInterview.peripheralInterfaces.smry = Supported interfaces
-BasicInterview.peripheralInterfaces.text = Interfaces implemented by the platform: 
+BasicInterview.peripheralInterfaces.text = Interfaces implemented by the platform:
 
 BasicInterview.gpioInterviewEnd.smry = End of GPIO configuration
 BasicInterview.gpioInterviewEnd.text = End of GPIO interface configuration
@@ -90,7 +90,7 @@
 BasicInterview.envEnd.text = End of the environment configuration
 
 GPIOInterview.welcome.smry = GPIO configuration
-GPIOInterview.welcome.text =  
+GPIOInterview.welcome.text =
 
 GPIOInterview.gpioPinConfig.smry = GPIO Pins
 GPIOInterview.gpioPinConfig.text = Add GPIO pin configurations:
@@ -120,10 +120,10 @@
 GPIOInterview.PinConfigBody.gpioPinId.text = Decimal pin ID:
 
 GPIOInterview.PinConfigBody.gpioPinDirection.smry = - Pin direction
-GPIOInterview.PinConfigBody.gpioPinDirection.text = Supported pin directions: 
+GPIOInterview.PinConfigBody.gpioPinDirection.text = Supported pin directions:
 
 GPIOInterview.PinConfigBody.gpioPinTrigger.smry = -    Pin trigger
-GPIOInterview.PinConfigBody.gpioPinTrigger.text = Interrupt trigger: 
+GPIOInterview.PinConfigBody.gpioPinTrigger.text = Interrupt trigger:
 
 GPIOInterview.gpioPortConfig.smry = GPIO Ports
 GPIOInterview.gpioPortConfig.text = Add GPIO port configurations:
@@ -156,7 +156,7 @@
 GPIOInterview.PortConfigBody.gpioPortPins.text = GPIO pins making up the port (NOTE: use decimal index of gpio pins created in GPIO Pins section above, i.e. 0,1,2):
 
 SPIInterview.welcome.smry = SPI bus configuration
-SPIInterview.welcome.text = 
+SPIInterview.welcome.text =
 
 SPIInterview.spiConfig.smry = SPI Devices
 SPIInterview.spiConfig.text = Add SPI device configurations:
@@ -179,19 +179,19 @@
 SPIInterview.SpiConfigQuestionBody.addressSize.smry = Device address size
 SPIInterview.SpiConfigQuestionBody.addressSize.text = Device address size:
 
-SPIInterview.SpiConfigQuestionBody.clockFrequency.smry = Clock frequency 
+SPIInterview.SpiConfigQuestionBody.clockFrequency.smry = Clock frequency
 SPIInterview.SpiConfigQuestionBody.clockFrequency.text = Clock frequency:
 
-SPIInterview.SpiConfigQuestionBody.clockMode.smry = Clock mode 
+SPIInterview.SpiConfigQuestionBody.clockMode.smry = Clock mode
 SPIInterview.SpiConfigQuestionBody.clockMode.text = Clock mode:
 
-SPIInterview.SpiConfigQuestionBody.wordLength.smry = Word length 
+SPIInterview.SpiConfigQuestionBody.wordLength.smry = Word length
 SPIInterview.SpiConfigQuestionBody.wordLength.text = Word length:
 
-SPIInterview.SpiConfigQuestionBody.bitOrdering.smry = Bit ordering 
+SPIInterview.SpiConfigQuestionBody.bitOrdering.smry = Bit ordering
 SPIInterview.SpiConfigQuestionBody.bitOrdering.text = Bit ordering:
 
-SPIInterview.SpiConfigQuestionBody.chipSelectActive.smry = ChipSelect active 
+SPIInterview.SpiConfigQuestionBody.chipSelectActive.smry = ChipSelect active
 SPIInterview.SpiConfigQuestionBody.chipSelectActive.text = ChipSelect active:
 
 SPIInterview.SpiConfigQuestionBody.transmitRequest.smry = Slave device transmit request