changeset 44:306a4efd2ff7

8051945: Transfer DIO Spec From Internal Sources to Open Project Reviewed-by: bobv
author jld
date Thu, 11 Sep 2014 13:40:27 -0400
parents 1ee75426fb8d
children 8472c11f06d8
files Javadoc.gmk src/se/classes/jdk/dio/mmio/AccessOutOfBoundsException.java src/se/classes/jdk/dio/mmio/MMIODevice.java src/se/classes/jdk/dio/mmio/MMIODeviceConfig.java src/se/classes/jdk/dio/mmio/MMIOEvent.java src/se/classes/jdk/dio/mmio/MMIOEventListener.java src/se/classes/jdk/dio/mmio/MMIOPermission.java src/se/classes/jdk/dio/mmio/RawBlock.java src/se/classes/jdk/dio/mmio/RawMemory.java src/se/classes/jdk/dio/mmio/RawRegister.java src/se/classes/jdk/dio/mmio/package-info.java src/share/classes/jdk/dio/AsyncErrorHandler.java src/share/classes/jdk/dio/BufferAccess.java src/share/classes/jdk/dio/ClosedDeviceException.java src/share/classes/jdk/dio/Device.java src/share/classes/jdk/dio/DeviceAlreadyExistsException.java src/share/classes/jdk/dio/DeviceConfig.java src/share/classes/jdk/dio/DeviceDescriptor.java src/share/classes/jdk/dio/DeviceEvent.java src/share/classes/jdk/dio/DeviceEventListener.java src/share/classes/jdk/dio/DeviceException.java src/share/classes/jdk/dio/DeviceManager.java src/share/classes/jdk/dio/DeviceMgmtPermission.java src/share/classes/jdk/dio/DeviceNotFoundException.java src/share/classes/jdk/dio/DevicePermission.java src/share/classes/jdk/dio/InputRoundListener.java src/share/classes/jdk/dio/InvalidDeviceConfigException.java src/share/classes/jdk/dio/OutputRoundListener.java src/share/classes/jdk/dio/RegistrationEvent.java src/share/classes/jdk/dio/RegistrationListener.java src/share/classes/jdk/dio/RoundCompletionEvent.java src/share/classes/jdk/dio/Transactional.java src/share/classes/jdk/dio/UnavailableDeviceException.java src/share/classes/jdk/dio/UnsupportedAccessModeException.java src/share/classes/jdk/dio/UnsupportedDeviceTypeException.java src/share/classes/jdk/dio/adc/ADCChannel.java src/share/classes/jdk/dio/adc/ADCChannelConfig.java src/share/classes/jdk/dio/adc/ADCPermission.java src/share/classes/jdk/dio/adc/AcquisitionRoundListener.java src/share/classes/jdk/dio/adc/InvalidInputSamplingRateException.java src/share/classes/jdk/dio/adc/MonitoringEvent.java src/share/classes/jdk/dio/adc/MonitoringListener.java src/share/classes/jdk/dio/adc/package-info.java src/share/classes/jdk/dio/atcmd/ATDevice.java src/share/classes/jdk/dio/atcmd/ATDeviceConfig.java src/share/classes/jdk/dio/atcmd/ATModem.java src/share/classes/jdk/dio/atcmd/ATPermission.java src/share/classes/jdk/dio/atcmd/CommandResponseHandler.java src/share/classes/jdk/dio/atcmd/DataConnection.java src/share/classes/jdk/dio/atcmd/DataConnectionHandler.java src/share/classes/jdk/dio/atcmd/UnsolicitedResponseHandler.java src/share/classes/jdk/dio/atcmd/package-info.java src/share/classes/jdk/dio/counter/CounterPermission.java src/share/classes/jdk/dio/counter/CountingEvent.java src/share/classes/jdk/dio/counter/CountingListener.java src/share/classes/jdk/dio/counter/PulseCounter.java src/share/classes/jdk/dio/counter/PulseCounterConfig.java src/share/classes/jdk/dio/counter/package-info.java src/share/classes/jdk/dio/dac/DACChannel.java src/share/classes/jdk/dio/dac/DACChannelConfig.java src/share/classes/jdk/dio/dac/DACPermission.java src/share/classes/jdk/dio/dac/GenerationRoundListener.java src/share/classes/jdk/dio/dac/InvalidOutputSamplingRateException.java src/share/classes/jdk/dio/dac/package-info.java src/share/classes/jdk/dio/generic/GenericBufferIODevice.java src/share/classes/jdk/dio/generic/GenericDevice.java src/share/classes/jdk/dio/generic/GenericDeviceConfig.java src/share/classes/jdk/dio/generic/GenericDeviceControl.java src/share/classes/jdk/dio/generic/GenericEvent.java src/share/classes/jdk/dio/generic/GenericEventListener.java src/share/classes/jdk/dio/generic/GenericPermission.java src/share/classes/jdk/dio/generic/package-info.java src/share/classes/jdk/dio/gpio/GPIOPin.java src/share/classes/jdk/dio/gpio/GPIOPinConfig.java src/share/classes/jdk/dio/gpio/GPIOPinPermission.java src/share/classes/jdk/dio/gpio/GPIOPort.java src/share/classes/jdk/dio/gpio/GPIOPortConfig.java src/share/classes/jdk/dio/gpio/GPIOPortPermission.java src/share/classes/jdk/dio/gpio/PinEvent.java src/share/classes/jdk/dio/gpio/PinListener.java src/share/classes/jdk/dio/gpio/PortEvent.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/i2cbus/I2CDevice.java src/share/classes/jdk/dio/i2cbus/I2CDeviceConfig.java src/share/classes/jdk/dio/i2cbus/I2CPermission.java src/share/classes/jdk/dio/i2cbus/package-info.java src/share/classes/jdk/dio/modem/ModemSignalEvent.java src/share/classes/jdk/dio/modem/ModemSignalListener.java src/share/classes/jdk/dio/modem/ModemSignalsControl.java src/share/classes/jdk/dio/modem/package-info.java src/share/classes/jdk/dio/package-info.java src/share/classes/jdk/dio/power/PowerManaged.java src/share/classes/jdk/dio/power/PowerSavingHandler.java src/share/classes/jdk/dio/power/package-info.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/InvalidPulseRateException.java src/share/classes/jdk/dio/pwm/PWMChannel.java src/share/classes/jdk/dio/pwm/PWMChannelConfig.java src/share/classes/jdk/dio/pwm/PWMPermission.java src/share/classes/jdk/dio/pwm/package-info.java src/share/classes/jdk/dio/spi/AbstractDevice.java src/share/classes/jdk/dio/spi/DeviceProvider.java src/share/classes/jdk/dio/spi/package-info.java src/share/classes/jdk/dio/spibus/InvalidWordLengthException.java src/share/classes/jdk/dio/spibus/SPIDevice.java src/share/classes/jdk/dio/spibus/SPIDeviceConfig.java src/share/classes/jdk/dio/spibus/SPIPermission.java src/share/classes/jdk/dio/uart/ModemUART.java src/share/classes/jdk/dio/uart/UART.java src/share/classes/jdk/dio/uart/UARTConfig.java src/share/classes/jdk/dio/uart/UARTEvent.java src/share/classes/jdk/dio/uart/UARTEventListener.java src/share/classes/jdk/dio/uart/UARTPermission.java src/share/classes/jdk/dio/uart/package-info.java
diffstat 118 files changed, 2204 insertions(+), 169 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Javadoc.gmk	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,61 @@
+#########################################################################
+# 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.
+#
+#########################################################################
+
+CP := cp
+MKDIR := mkdir -p
+
+#########################################################################
+
+JAVADOC_BUILD_DIR := ./build/javadocs
+JAVADOC_HEADER := "<FONT size=\"-1\">"
+JAVADOC_FOOTER := ""
+
+ifeq ($(JAVA_HOME),)
+  $(error "JAVA_HOME is not defined. Please set JAVA_HOME to point to the location of the JDK8 installation")
+endif
+
+.PHONY: clean all docs dirs
+
+all: docs
+
+dirs:
+	$(MKDIR) $(JAVADOC_BUILD_DIR)/api
+
+docs: dirs
+	$(JAVA_HOME)/bin/javadoc -locale en_US -d $(JAVADOC_BUILD_DIR) -sourcepath ./src/share/classes:src/se/classes -Xdoclint:none \
+           -subpackages jdk.dio.adc:jdk.dio.counter:jdk.dio.dac:jdk.dio.atcmd:jdk.dio.generic:jdk.dio.gpio:jdk.dio.i2cbus:jdk.dio.spi:jdk.dio.spibus:jdk.dio.modem:jdk.dio.power:jdk.dio.pwm:jdk.dio.uart:jdk.dio.watchdog:jdk.dio.mmio \
+	   jdk.dio \
+	   -overview ./src/doc-files/overview.html -header "<FONT size=\"-1\">Device I/O API 1.0</FONT>" -footer "<FONT size=\"-1\">Device I/O API 1.0</FONT>" \
+	   -use -docencoding "iso-8859-1" -notree \
+	   -bottom "<span class=\"copyrightlogo\">Copyright &copy; 2012, 2014, Oracle and/or its affiliates. All rights reserved.</span><br />"
+
+clean:
+	rm -rf ./build/javadocs
+
+
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/AccessOutOfBoundsException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+/**
+ * Thrown by an instance of {@link MMIODevice} if an offset used is out of valid boundary of the specified memory block.
+ *
+ * @since 1.0
+ */
+public class AccessOutOfBoundsException extends RuntimeException {
+
+    /**
+     * Constructs a new {@code AccessOutOfBoundsException} with {@code null} as its detailed reason message.
+     */
+    public AccessOutOfBoundsException() {
+        super();
+    }
+
+    /**
+     * Constructs a new {@code AccessOutOfBoundsException} with the specified detail message. The error message string
+     * {@code message} can later be retrieved by the {@link Throwable#getMessage getMessage} method.
+     *
+     * @param message
+     *            the detailed reason of the exception
+     */
+    public AccessOutOfBoundsException(String message) {
+        super(message);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/MMIODevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.ClosedDeviceException;
+import jdk.dio.Device;
+import jdk.dio.DeviceManager;
+import jdk.dio.UnavailableDeviceException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * The {@code MMIODevice} class provides methods to retrieve memory-mapped registers and memory blocks of a device
+ * device.
+ * <p />
+ * An MMIO device may be identified by the numeric ID and by the name (if any defined) that correspond to its
+ * registered configuration. An {@code MMIODevice} instance can be opened by a call to one of the
+ * {@link DeviceManager#open(int) DeviceManager.open(id,...)} methods using its ID or by a call to one of the
+ * {@link DeviceManager#open(java.lang.String, java.lang.Class, java.lang.String[])
+ * DeviceManager.open(name,...)} methods using its name. When an {@code MMIODevice} instance is opened with an
+ * ad-hoc {@link MMIODeviceConfig} configuration (which includes its hardware addressing information) using one of the
+ * {@link DeviceManager#open(jdk.dio.DeviceConfig) DeviceManager.open(config,...)} it is not
+ * assigned any ID nor name.
+ * <p />
+ * With memory-mapped I/O, devices can be controlled by directly reading or writing to memory areas
+ * representing the registers or memory blocks of the device. Each register or memory block is represented by
+ * a {@link RawMemory} instance. Each register or memory block is also usually assigned a name which can be used for
+ * name-based lookup. The complete memory area the device is mapped to can also be retrieved as single
+ * {@link RawBlock} instance, allowing for offset-based access to all the registers and memory blocks of the device.
+ * <p/>
+ * An application can register an {@link MMIOEventListener} instance to monitor native events of the designated type
+ * fired by the device. To register a {@link MMIOEventListener} instance, the application must call the
+ * {@link #setMMIOEventListener(int, MMIOEventListener)} method. The registered listener can later on be removed by
+ * calling the same method with a {@code null} listener parameter. Asynchronous notification may not be supported by all
+ * memory-mapped devices. An attempt to set a listener on a memory-mapped device which does not supports it will result
+ * in an {@link UnsupportedOperationException} being thrown.
+ * <p />
+ * When done, an application should call the {@link #close MMIODevice.close} method to close the MMIO device. Any
+ * further attempt to access an MMIO device which has been closed will result in a {@link ClosedDeviceException}
+ * been thrown.
+ * <p />
+ * Opening a {@link MMIODevice} instance is subject to permission checks (see {@link MMIOPermission}).
+ * <p />
+ * The event types (IDs) supported by a memory-mapped device are device as well as platform specific. For
+ * example, each interrupt request line of a device may be mapped to a distinct event type ID. Refer to the
+ * device data sheet and the platform configuration.
+ * <p />
+ * The {@code byte}, {@code short} and {@code int} values passed to and returned by this API have to be
+ * interpreted as 8 bit, 16 bit and 32 bit unsigned quantities. Proper handling is needed when performing integer
+ * arithmetic on these quantities.
+ *
+ * @see MMIOPermission
+ * @see ClosedDeviceException
+ * @since 1.0
+ */
+public interface MMIODevice extends Device<MMIODevice> {
+
+    /**
+     * Gets the complete memory area this device is mapped to as a {@code RawBlock} instance.
+     *
+     * @return a {@link RawBlock} object encapsulating whole memory area this device is mapped to.
+     * @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.
+     */
+    RawBlock getAsRawBlock() throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Gets the designated memory block.
+     *
+     * @param name
+     *            name of the memory block.
+     * @return a {@link RawBlock} object encapsulating the designated memory block.
+     * @throws IOException
+     *             if some other I/O error occurs.
+     * @throws IllegalArgumentException
+     *             if the provided name does not correspond to any memory block.
+     * @throws NullPointerException
+     *             if {@code name} 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.
+     */
+    RawBlock getBlock(String name) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Returns the byte ordering of this memory-mapped device.
+     *
+     * @return {@link #BIG_ENDIAN} if big-endian; {@link #LITTLE_ENDIAN} if little-endian; {@link #MIXED_ENDIAN}
+     *         otherwise.
+     * @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.
+     */
+    int getByteOrdering() throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Gets the designated register holding a value of the designated type.
+     *
+     * @param name
+     *            the name of the register.
+     * @param type
+     *            the type of the value held in the register.
+     * @return a {@link RawRegister} object encapsulating the value of the designated register.
+     * @throws IllegalArgumentException
+     *             if the provided name does not correspond to any register or if the type of of the value held in the
+     *             register does not match.
+     * @throws NullPointerException
+     *             if {@code name} or {@code type} is {@code null}.
+     * @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.
+     */
+    <T extends Number> RawRegister<T> getRegister(String name, Class<T> type) throws IOException,
+            UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Registers a {@link MMIOEventListener} instance to monitor native events of the designated type fired by the
+     * device mapped to this </code>MMIODevice</code> object and capture the content of designated memory
+     * area.
+     * <p />
+     * While the listener can be triggered by hardware interrupts, there are no real-time guarantees of when the
+     * listener will be called.
+     * <p />
+     * The content of the designated memory area will be captured upon the occurrence of the designated event.
+     * Upon notification of the corresponding {@link MMIOEvent}, the captured content of a designated memory area
+     * may be retrieved using {@link MMIOEvent#getCapturedMemoryContent MMIOEvent.getCapturedMemoryContent}.
+      * <p />
+     * If this {@code MMIODevice} is open in {@link DeviceManager#SHARED} access mode
+     * the listeners registered by all the applications sharing the underlying device will get
+     * notified of the events they registered for.
+     * <p />
+     * If {@code listener} is {@code null} then listener previously registered for the specified event type will be
+     * removed.
+     * <p />
+     * Only one listener can be registered at a particular time for a particular event type.
+     *
+     * @param eventId
+     *            ID of the native event to listen to.
+     * @param capturedIndex
+     *            the byte index in this device mapped raw memory area to capture.
+     * @param captureBuffer
+     *            the direct {@link ByteBuffer} to save the captured memory area in; up to {@code captureBuffer.remaining()} bytes will
+     *            be copied from this device mapped raw memory area starting at {@code capturedIndex}
+     *            into this buffer starting at the buffer's position at the moment this method is called.
+     * @param listener
+     *            the {@link MMIOEventListener} instance to be notified upon occurrence of the designated event.
+     * @throws IOException
+     *             if some other I/O error occurs.
+     * @throws AccessOutOfBoundsException
+     *             if {@code capturedIndex} and/or {@code captureBuffer.remaining()} would result in pointing outside this device
+     *             mapped raw memory area.
+     * @throws IllegalArgumentException
+     *             if {@code eventId} does not correspond to any supported event or if {@code captureBuffer} is not a direct {@link ByteBuffer}.
+     * @throws UnsupportedOperationException
+     *             if this {@code MMIODevice} object does not support asynchronous event notification.
+     * @throws IllegalStateException
+     *             if {@code listener} is not {@code null} and a listener is already registered for the specified event
+     *             type.
+     * @throws ClosedDeviceException
+     *             if the device has been closed.
+     * @throws NullPointerException
+     *             if {@code captureBuffer} is {@code null}.
+     */
+    void setMMIOEventListener(int eventId, int capturedIndex, ByteBuffer captureBuffer,
+            MMIOEventListener listener) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Registers a {@link MMIOEventListener} instance to monitor native events of the designated type fired by the
+     * device mapped to this </code>MMIODevice</code> object. While the listener can be triggered by hardware
+     * interrupts, there are no real-time guarantees of when the listener will be called.
+     * <p />
+     * If this {@code MMIODevice} is open in {@link DeviceManager#SHARED} access mode
+     * the listeners registered by all the applications sharing the underlying device will get
+     * notified of the events they registered for.
+     * <p />
+     * If {@code listener} is {@code null} then listener previously registered for the specified event type will be
+     * removed.
+     * <p />
+     * Only one listener can be registered at a particular time for a particular event type.
+     *
+     * @param eventId
+     *            ID of the native event to listen to.
+     * @param listener
+     *            the {@link MMIOEventListener} instance to be notified upon occurrence of the designated event.
+     * @throws IOException
+     *             if some other I/O error occurs.
+     * @throws IllegalArgumentException
+     *             if {@code eventId} does not correspond to any supported event.
+     * @throws UnsupportedOperationException
+     *             if this {@code MMIODevice} object does not support asynchronous event notification.
+     * @throws IllegalStateException
+     *             if {@code listener} is not {@code null} and a listener is already registered for the specified event
+     *             type.
+     * @throws ClosedDeviceException
+     *             if the device has been closed.
+     */
+    void setMMIOEventListener(int eventId, MMIOEventListener listener) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Registers a {@link MMIOEventListener} instance to monitor native events of the designated type fired by the
+     * device mapped to this </code>MMIODevice</code> object and capture the content of designated register
+     * or block.
+     * <p />
+     * While the listener can be triggered by hardware interrupts, there are no real-time guarantees of when the
+     * listener will be called.
+     * <p />
+     * The content of the designated register or block will be captured upon the occurrence of the designated event.
+     * Upon notification of the corresponding {@link MMIOEvent}, the captured value of a designated register may
+     * be retrieved using {@link MMIOEvent#getCapturedRegisterValue MMIOEvent.getCapturedRegisterValue} while the captured content of a designated block
+     * may be retrieved using {@link MMIOEvent#getCapturedMemoryContent MMIOEvent.getCapturedMemoryContent}.
+     * <p />
+     * If this {@code MMIODevice} is open in {@link DeviceManager#SHARED} access mode
+     * the listeners registered by all the applications sharing the underlying device will get
+     * notified of the events they registered for.
+     * <p />
+     * If {@code listener} is {@code null} then listener previously registered for the specified event type will be
+     * removed.
+     * <p />
+     * Only one listener can be registered at a particular time for a particular event type.
+     *
+     * @param eventId
+     *            ID of the native event to listen to.
+     * @param capturedName
+     *            the name of the register or memory block whose content is to be captured at the time of the underlying
+     *            event occurs.
+     * @param listener
+     *            the {@link MMIOEventListener} instance to be notified upon occurrence of the designated event.
+     * @throws IOException
+     *             if some other I/O error occurs.
+     * @throws IllegalArgumentException
+     *             if {@code eventId} does not correspond to any supported event; or if the provided name does not
+     *             correspond to any memory block or register.
+     * @throws UnsupportedOperationException
+     *             if this {@code MMIODevice} object does not support asynchronous event notification.
+     * @throws IllegalStateException
+     *             if {@code listener} is not {@code null} and a listener is already registered for the specified event
+     *             type.
+     * @throws ClosedDeviceException
+     *             if the device has been closed.
+     * @throws NullPointerException
+     *             if {@code capturedName} is {@code null}.
+     */
+    void setMMIOEventListener(int eventId, String capturedName, MMIOEventListener listener) throws IOException,
+            UnavailableDeviceException, ClosedDeviceException;
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/MMIODeviceConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,511 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.DeviceConfig;
+import jdk.dio.InvalidDeviceConfigException;
+import jdk.dio.DeviceManager;
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * The {@code MMIODeviceConfig} class encapsulates the hardware addressing information, and static and dynamic
+ * configuration parameters of an MMIO device.
+ * <p />
+ * Some hardware addressing parameter, and static and dynamic configuration parameters may be set to {@link #DEFAULT}.
+ * Whether such default settings are supported is platform- as well as device driver-dependent.
+ * <p />
+ * An instance of {@code MMIODeviceConfig} can be passed to the {@link DeviceManager#open(DeviceConfig)} or
+ * {@link DeviceManager#open(Class, DeviceConfig)} method to open the designated MMIO device with the specified
+ * configuration. A {@link InvalidDeviceConfigException} is thrown when attempting to open a device with
+ * an invalid or unsupported configuration.
+ *
+ * @see DeviceManager#open(DeviceConfig)
+ * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
+ */
+public final class MMIODeviceConfig implements DeviceConfig<MMIODevice>, DeviceConfig.HardwareAddressing {
+
+    /**
+     * The {@code RawBlockConfig} class encapsulates the configuration parameters of a memory block.
+     */
+    public static final class RawBlockConfig extends RawMemoryConfig {
+
+        private int size;
+
+        /**
+         * Constructs a new {@code RawBlockConfig} with the provided parameters.
+         *
+         * @param offset
+         *            the offset of the register from the base address (a positive or zero integer).
+         * @param name
+         *            the name for the register.
+         * @param size
+         *            the size in bytes of the memory block (a positive integer).
+         *
+         * @throws IllegalArgumentException
+         *             if any of the following is true:
+         *             <ul>
+         *             <li>{@code offset} is lesser than {@code 0};</li>
+         *             <li>{@code size} is lesser than or equal to {@code 0}.</li>
+         *             </ul>
+         * @throws NullPointerException
+         *             if {@code name} is {@code null}.
+         */
+        public RawBlockConfig(int offset, String name, int size) {
+            super(offset, name);
+            this.size = size;
+        }
+
+        /**
+         * Gets the configured size in bytes of the memory block.
+         *
+         * @return the size in bytes of the memory block (a positive integer).
+         */
+        public int getSize() {
+            return size;
+        }
+
+    /**
+     * Returns the hash code value for this object.
+     *
+     * @return a hash code value for this object.
+     */
+        @Override
+        public int hashCode() {
+            int hash = 3;
+            hash = 37 * hash + this.size;
+            return hash;
+        }
+
+    /**
+     * Checks two {@code RawBlockConfig} objects for equality.
+     *
+     * @param obj
+     *            the object to test for equality with this object.
+     *
+     * @return {@code true} if {@code obj} is a {@code RawBlockConfig} and has
+     * the same hardware addressing information and configuration parameter values
+     * as this {@code RawBlockConfig} object.
+     */
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (getClass() != obj.getClass()) {
+                return false;
+            }
+            final RawBlockConfig other = (RawBlockConfig) obj;
+            if (this.size != other.size) {
+                return false;
+            }
+            return true;
+        }
+
+    }
+
+    /**
+     * The {@code RawMemoryConfig} class encapsulates the configuration parameters of a generic raw memory area.
+     */
+    public static abstract class RawMemoryConfig {
+
+        private String name;
+        private int offset;
+
+        /**
+         * Constructs a new {@code RawMemoryConfig} with the provided parameters.
+         *
+         * @param offset
+         *            the offset of the raw memory area from the base address (a positive or zero integer).
+         * @param name
+         *            the name for the raw memory area.
+         *
+         * @throws IllegalArgumentException
+         *             if {@code offset} is lesser than {@code 0}.
+         * @throws NullPointerException
+         *             if {@code name} is {@code null}.
+         */
+        RawMemoryConfig(int offset, String name) {
+            this.offset = offset;
+            this.name = name;
+        }
+
+        /**
+         * Gets the configured name for the raw memory area.
+         *
+         * @return the name for the raw memory area.
+         */
+        public String getName() {
+            return name;
+        }
+
+        /**
+         * Gets the configured offset of the raw memory area from the base address.
+         *
+         * @return the offset of the raw memory area from the base address (a positive or zero integer).
+         */
+        public int getOffset() {
+            return offset;
+        }
+
+    /**
+     * Returns the hash code value for this object.
+     *
+     * @return a hash code value for this object.
+     */
+        @Override
+        public int hashCode() {
+            int hash = 7;
+            hash = 97 * hash + Objects.hashCode(this.name);
+            hash = 97 * hash + this.offset;
+            return hash;
+        }
+
+    /**
+     * Checks two {@code RawMemoryConfig} objects for equality.
+     *
+     * @param obj
+     *            the object to test for equality with this object.
+     *
+     * @return {@code true} if {@code obj} is a {@code RawMemoryConfig} and has
+     * the same hardware addressing information and configuration parameter values
+     * as this {@code RawMemoryConfig} object.
+     */
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (getClass() != obj.getClass()) {
+                return false;
+            }
+            final RawMemoryConfig other = (RawMemoryConfig) obj;
+            if (!Objects.equals(this.name, other.name)) {
+                return false;
+            }
+            if (this.offset != other.offset) {
+                return false;
+            }
+            return true;
+        }
+
+    }
+
+    /**
+     * The {@code RawRegisterConfig} class encapsulates the configuration parameters of a register.
+     *
+     * @param <T>
+     *            the type of the value held by the register.
+     */
+    public static final class RawRegisterConfig<T extends Number> extends RawMemoryConfig {
+        private Class<T> type;
+
+        /**
+         * Constructs a new {@code RawRegisterConfig} with the provided parameters.
+         *
+         * @param offset
+         *            the offset of the register from the base address (a positive or zero integer).
+         * @param name
+         *            the name for the register.
+         * @param type
+         *            the type of the value held by the register, one of: {@link Byte}, {@link Short} or {@link Integer}
+         *            .
+         *
+         * @throws IllegalArgumentException
+         *             if any of the following is true:
+         *             <ul>
+         *             <li>{@code offset} is lesser than {@code 0};</li>
+         *             <li>{@code type} is not one of the defined values.</li>
+         *             </ul>
+         * @throws NullPointerException
+         *             if {@code name} is {@code null}.
+         */
+        public RawRegisterConfig(int offset, String name, Class<T> type) {
+            super(offset, name);
+            this.type = type;
+        }
+
+        /**
+         * Gets the configured type of the value held by the register.
+         *
+         * @return the type of the value held by the register, one of: {@link Byte}, {@link Short} or {@link Integer}.
+         */
+        public Class<T> getType() {
+            return type;
+        }
+
+    /**
+     * Returns the hash code value for this object.
+     *
+     * @return a hash code value for this object.
+     */
+        @Override
+        public int hashCode() {
+            int hash = 5;
+            hash = 67 * hash + Objects.hashCode(this.type);
+            return hash;
+        }
+
+    /**
+     * Checks two {@code RawRegisterConfig} objects for equality.
+     *
+     * @param obj
+     *            the object to test for equality with this object.
+     *
+     * @return {@code true} if {@code obj} is a {@code RawRegisterConfig} and has
+     * the same hardware addressing information and configuration parameter values
+     * as this {@code RawRegisterConfig} object.
+     */
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (getClass() != obj.getClass()) {
+                return false;
+            }
+            final RawRegisterConfig<T> other = (RawRegisterConfig<T>) obj;
+            if (!Objects.equals(this.type, other.type)) {
+                return false;
+            }
+            return true;
+        }
+    }
+
+    private long address;
+    private int controllerNumber = DEFAULT;
+    private String controllerName = null;
+
+    private int byteOrdering = DEFAULT;
+
+    private RawMemoryConfig[] memConfigs = null;
+
+    private int size;
+
+    /**
+     * Creates a new {@code MMIODeviceConfig} with the specified hardware addressing information and configuration
+     * parameters.
+     * <p />
+     * If no raw block and raw register configuration is provided, the specified memory area will be mapped to
+     * the {@link RawBlock} instance returned by a call to {@link MMIODevice#getAsRawBlock MMIODevice.getAsRawBlock}.
+     * <p />
+     * If the designated memory region is protected or if it overlaps with that of an existing
+     * MMIO device configuration and the requested access mode ({@link DeviceManager#EXCLUSIVE} or
+     * {@link DeviceManager#SHARED}) is incompatible or unsupported, attempting to open an {@code MMIODevice}
+     * device using this configuration may result in either a {@code SecurityException} or
+     * a {@link InvalidDeviceConfigException} to be thrown.
+     *
+    * @param address
+     *            the memory address of the device (a positive or zero integer).
+     * @param size
+     *            the size of the memory-mapped area of the device (a positive integer).
+     * @param byteOrdering
+     *            the byte ordering of the device, one of: {@link MMIODevice#BIG_ENDIAN},
+     *            {@link MMIODevice#LITTLE_ENDIAN}, {@link MMIODevice#MIXED_ENDIAN} or {@link MMIODeviceConfig#DEFAULT}.
+     * @param memConfigs
+     *            the raw block and raw register configurations (may be {@code null} or empty).
+     *
+     * @throws IllegalArgumentException
+     *             if any of the following is true:
+     *             <ul>
+     *             <li>{@code address} is not in the defined range;</li>
+     *             <li>{@code size} is not in the defined range;</li>
+     *             <li>{@code byteOrdering} is not one of the defined values.</li>
+     *             </ul>
+     * @throws IndexOutOfBoundsException
+     *             if any of the {@code memConfigs} elements is pointing outside of the defined address range ([
+     *             {@code 0}-</code>size</code>]).
+     */
+    public MMIODeviceConfig(long address, int size, int byteOrdering, RawMemoryConfig... memConfigs) {
+        this.address = address;
+        this.size = size;
+        this.byteOrdering = byteOrdering;
+        if (memConfigs != null) {
+            this.memConfigs = memConfigs.clone();
+        }
+    }
+
+    /**
+     * Creates a new {@code MMIODeviceConfig} with the specified hardware addressing information and configuration
+     * parameters.
+     * <p />
+     * If no raw block and raw register configuration is provided, the specified memory area will be mapped to
+     * the {@link RawBlock} instance returned by a call to {@link MMIODevice#getAsRawBlock MMIODevice.getAsRawBlock}.
+     *
+     * @param controllerName
+     *            the controller name (such as its <em>device file</em> name on UNIX systems).
+     * @param address
+     *            the memory address of the device (a positive or zero integer)or {@link MMIODeviceConfig#DEFAULT}.
+     * @param size
+     *            the size of the memory-mapped area of the device (a positive integer).
+     * @param byteOrdering
+     *            the byte ordering of the device, one of: {@link MMIODevice#BIG_ENDIAN},
+     *            {@link MMIODevice#LITTLE_ENDIAN}, {@link MMIODevice#MIXED_ENDIAN} or {@link MMIODeviceConfig#DEFAULT}.
+     * @param memConfigs
+     *            the raw block and raw register configurations (may be {@code null} or empty).
+     *
+     * @throws IllegalArgumentException
+     *             if any of the following is true:
+     *             <ul>
+     *             <li>{@code address} is not in the defined range;</li>
+     *             <li>{@code size} is not in the defined range;</li>
+     *             <li>{@code byteOrdering} is not one of the defined values.</li>
+     *             </ul>
+     * @throws NullPointerException
+     *             if {@code controllerName} is {@code null}.
+     * @throws IndexOutOfBoundsException
+     *             if any of the {@code memConfigs} elements is pointing outside of the defined address range ([
+     *             {@code 0}-</code>size</code>]).
+     */
+    public MMIODeviceConfig(String controllerName, long address, int size, int byteOrdering, RawMemoryConfig... memConfigs) {
+        this.controllerName = controllerName;
+        this.address = address;
+        this.size = size;
+        this.byteOrdering = byteOrdering;
+        if (memConfigs != null) {
+            this.memConfigs = memConfigs.clone();
+        }
+    }
+
+    /**
+     * Gets the configured memory address of the MMIO device.
+     *
+     * @return the memory address of the MMIO device (a positive or zero integer) or {@link MMIODeviceConfig#DEFAULT}..
+     */
+    public long getAddress() {
+        return address;
+    }
+
+    /**
+     * Gets the configured controller name (such as its <em>device file</em> name on UNIX systems).
+     *
+     * @return the controller name or {@code null}.
+     */
+    @Override
+    public String getControllerName() {
+        return controllerName;
+    }
+
+    /**
+     * Gets the configured controller number.
+     *
+     * @return {@link #DEFAULT}.
+     */
+    @Override
+    public int getControllerNumber() {
+        return controllerNumber;
+    }
+
+    /**
+     * Gets the configured byte ordering of the MMIO device.
+     *
+     * @return the byte ordering of the MMIO device, one of: {@link MMIODevice#BIG_ENDIAN},
+     *         {@link MMIODevice#LITTLE_ENDIAN}, {@link MMIODevice#MIXED_ENDIAN} or {@link MMIODeviceConfig#DEFAULT}.
+     */
+    public int getByteOrdering() {
+        return byteOrdering;
+    }
+
+    /**
+     * Gets the set of configured registers and memory blocks.
+     *
+     * @return an array (a defensive copy thereof) containing the set of configured registers and memory blocks or
+     *         {@code null} if none is defined.
+     */
+    public RawMemoryConfig[] getRawMemoryConfigs() {
+        if (memConfigs != null) {
+            return memConfigs.clone();
+        }
+        return null;
+    }
+
+    /**
+     * Gets the configured size of the memory-mapped area of the MMIO device.
+     *
+     * @return the size of the memory-mapped area of the device (a positive integer).
+     */
+    public int getSize() {
+        return size;
+    }
+
+    /**
+     * Returns the hash code value for this object.
+     *
+     * @return a hash code value for this object.
+     */
+    @Override
+    public int hashCode() {
+        int hash = 5;
+        hash = 97 * hash + (int) (this.address ^ (this.address >>> 32));
+        hash = 97 * hash + this.controllerNumber;
+        hash = 97 * hash + Objects.hashCode(this.controllerName);
+        hash = 97 * hash + this.byteOrdering;
+        for (RawMemoryConfig memConfig : this.memConfigs) {
+            hash = 97 * hash + Objects.hashCode(memConfig);       }
+        hash = 97 * hash + this.size;
+        return hash;
+    }
+
+    /**
+     * Checks two {@code MMIODeviceConfig} objects for equality.
+     *
+     * @param obj
+     *            the object to test for equality with this object.
+     *
+     * @return {@code true} if {@code obj} is a {@code MMIODeviceConfig} and has
+     * the same hardware addressing information and configuration parameter values
+     * as this {@code MMIODeviceConfig} object.
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final MMIODeviceConfig other = (MMIODeviceConfig) obj;
+        if (this.address != other.address) {
+            return false;
+        }
+        if (this.controllerNumber != other.controllerNumber) {
+            return false;
+        }
+        if (!Objects.equals(this.controllerName, other.controllerName)) {
+            return false;
+        }
+        if (this.byteOrdering != other.byteOrdering) {
+            return false;
+        }
+        if (!Arrays.equals(this.memConfigs, other.memConfigs)) {
+            return false;
+        }
+        if (this.size != other.size) {
+            return false;
+        }
+        return true;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/MMIOEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.DeviceEvent;
+import java.nio.ByteBuffer;
+
+/**
+ * The {@code MMIOEvent} class encapsulates events fired by devices mapped to memory.
+ *
+ * @see MMIODevice
+ * @see MMIOEventListener
+ * @since 1.0
+ */
+public class MMIOEvent extends DeviceEvent<MMIODevice> {
+
+    /**
+     * The captured content of the memory area or memory block designated upon registration.
+     */
+    private ByteBuffer capturedMemoryContent = null;
+
+    /**
+     * The captured value of the register designated upon registration.
+     */
+    private Number capturedRegisterValue = null;
+
+    /**
+     * This event ID.
+     */
+    private int id;
+
+    /**
+     * Creates a new {@link MMIOEvent} with the specified event ID and time-stamped
+     * with the current time.
+     *
+     * @param device
+     *            the source device.
+     * @param id
+     *            the event ID.
+     * @throws NullPointerException
+     *             if {@code device} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if {@code id} is negative.
+     */
+    public MMIOEvent(MMIODevice device, int id) {
+        this(device, id, System.currentTimeMillis(), 0);
+    }
+
+    /**
+     * Creates a new {@link MMIOEvent} with the specified event ID and timestamp, and
+     * with the captured content of the memory area or memory block designated upon registration.
+     *
+     * @param device
+     *            the source device.
+     * @param id
+     *            the event ID.
+     * @param capturedMemoryContent
+     *            the captured content of the memory area or memory block designated upon registration.
+     * @param timeStamp
+     *            the timestamp (in milliseconds).
+     * @param timeStampMicros
+     *            the additional microseconds to the timestamp.
+     * @throws NullPointerException
+     *             if {@code device} or {@code capturedMemoryContent} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if {@code id}, {@code timeStamp} or {@code timeStampMicros} is negative.
+     */
+    public MMIOEvent(MMIODevice device, int id, ByteBuffer capturedMemoryContent, long timeStamp, int timeStampMicros) {
+        this.device = device;
+        this.id = id;
+        this.capturedRegisterValue = null;
+        this.capturedMemoryContent = capturedMemoryContent;
+        this.timeStamp = timeStamp;
+        this.timeStampMicros = timeStampMicros;
+        this.count = 1;
+    }
+
+    /**
+     * Creates a new {@link MMIOEvent} with the specified event ID and timestamp.
+     *
+     * @param device
+     *            the source device.
+     * @param id
+     *            the event ID.
+     * @param timeStamp
+     *            the timestamp (in milliseconds).
+     * @param timeStampMicros
+     *            the additional microseconds to the timestamp.
+     * @throws NullPointerException
+     *             if {@code device} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if {@code id}, {@code timeStamp} or {@code timeStampMicros} is negative.
+     */
+    public MMIOEvent(MMIODevice device, int id, long timeStamp, int timeStampMicros) {
+        this.device = device;
+        this.id = id;
+        this.capturedRegisterValue = null;
+        this.capturedMemoryContent = null;
+        this.timeStamp = timeStamp;
+        this.timeStampMicros = timeStampMicros;
+        this.count = 1;
+    }
+
+    /**
+     * Creates a new {@link MMIOEvent} with the specified event ID and timestamp, and
+     * the captured value of the register designated upon registration.
+     *
+     * @param <T> the type of the captured value.
+     *
+     * @param device
+     *            the source device.
+     * @param id
+     *            the event ID.
+     * @param capturedRegisterValue
+     *            the captured value of the register designated upon registration.
+     * @param timeStamp
+     *            the timestamp (in milliseconds).
+     * @param timeStampMicros
+     *            the additional microseconds to the timestamp.
+     * @throws NullPointerException
+     *             if {@code device} or {@code capturedRegisterValue} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if {@code id}, {@code timeStamp} or {@code timeStampMicros} is negative.
+     */
+    public <T extends Number> MMIOEvent(MMIODevice device, int id, T capturedRegisterValue, long timeStamp,
+            int timeStampMicros) {
+        this.device = device;
+        this.id = id;
+        this.capturedRegisterValue = capturedRegisterValue;
+        this.capturedMemoryContent = null;
+        this.timeStamp = timeStamp;
+        this.timeStampMicros = timeStampMicros;
+        this.count = 1;
+    }
+
+    /**
+     * Coalesces events. Must only be called if the event has not yet been dispatched.
+     *
+     * @param <T> the type of the captured value.
+     *
+     * @param registerValue
+     *            the captured value of the register designated upon registration.
+     * @param memoryContent
+     *            the captured content of the memory area or memory block designated upon registration.
+     * @param timeStamp
+     *            the timestamp (in milliseconds).
+     * @param timeStampMicro
+     *            the additional microseconds to the timestamp.
+     */
+    <T extends Number> void addOccurence(T registerValue, ByteBuffer memoryContent, long timeStamp) {
+        this.count++;
+        this.capturedRegisterValue = registerValue;
+        this.capturedMemoryContent = memoryContent;
+        this.lastTimeStamp = timeStamp;
+        this.lastTimeStampMicros = timeStampMicros;
+    }
+
+    /**
+     * Gets the captured content of the memory area or memory block designated upon registration.
+     *
+     * @return the captured content of the memory area or block; or {@code null} if no memory area or block content was
+     *         captured. If the listener was registered using the MMIODevice#setMMIOEventListener(int, int, ByteBuffer, jdk.dio.mmio.MMIOEventListener) method
+     *         the {@code ByteBuffer} returned is the {@code ByteBuffer} that was passed as the {@code captureBuffer} parameter.
+     *
+     * @see MMIODevice#setMMIOEventListener(int, java.lang.String, jdk.dio.mmio.MMIOEventListener)
+     * @see MMIODevice#setMMIOEventListener(int, int, ByteBuffer, jdk.dio.mmio.MMIOEventListener)
+     */
+    public ByteBuffer getCapturedMemoryContent() {
+        return capturedMemoryContent;
+    }
+
+    /**
+     * Gets the captured value of the register designated upon registration.
+     *
+     * @param <T>
+     *            the type of the value held by the register.
+     * @return the captured value of the register designated upon registration or {@code null} if no register value was captured.
+     *
+     * @see MMIODevice#setMMIOEventListener(int, java.lang.String, jdk.dio.mmio.MMIOEventListener)
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends Number> T getCapturedRegisterValue() {
+        return (T) capturedRegisterValue;
+    }
+
+    /**
+     * Returns this event ID.
+     *
+     * @return this event ID.
+     */
+    public int getID() {
+        return id;
+    }
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/MMIOEventListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.DeviceEventListener;
+
+/**
+ * The {@code MMIOEventListener} interface defines methods for getting notified of events fired by devices mapped to
+ * memory. <br />
+ * A {@code MMIOEventListener} can be registered using one of the
+ * {@link MMIODevice#setMMIOEventListener(int, MMIOEventListener) setMMIOEventListener} methods.
+ *
+ * @see MMIODevice#setMMIOEventListener MMIODevice.setMMIOEventListener
+ * @see MMIOEvent
+ * @since 1.0
+ */
+public interface MMIOEventListener extends DeviceEventListener {
+
+    /**
+     * Invoked when an event is fired by a memory-mapped device.
+     *
+     * @param event
+     *            the event that occurred.
+     */
+    void eventDispatched(MMIOEvent event);
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/MMIOPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.DeviceManager;
+import jdk.dio.DevicePermission;
+import java.security.Permission;
+import java.security.PermissionCollection;
+
+/**
+ * The {@code MMIOPermission} class defines permissions for MMIO device access.
+ * <p />
+ * A {@code MMIOPermission} permission has a target name and a list of actions.
+ * <p />
+ * The target name contains hardware addressing information. The format is the one defined for the base {@link DevicePermission} class
+ * with the following addition:
+ * <dl>
+ * <dt><code>{channel-desc}</code></dt>
+ * <dd>
+ * The <code>{channel-desc}</code> string (described in {@link DevicePermission}) is
+ * a memory-address (in hexadecimal format) as may be returned by a call to {@link MMIODeviceConfig#getAddress MMIODeviceConfig.getAddress}.
+ * The characters in the string must all be hexadecimal digits.
+ * </dd>
+ * </dl>
+ * The supported actions are {@code open} and {@code powermanage}. Their meaning is defined as follows:
+ * <dl>
+ * <dt>{@code open}</dt>
+ * <dd>open and access an MMIO device functions (see {@link DeviceManager#open DeviceManager.open})</dd>
+ * <dt>{@code powermanage}</dt>
+ * <dd>manage the power saving mode of a device (see {@link jdk.dio.power.PowerManaged})</dd>
+ * </dl>
+ *
+ * @see DeviceManager#open DeviceManager.open
+ * @see jdk.dio.power.PowerManaged
+ * @since 1.0
+ */
+public class MMIOPermission extends DevicePermission {
+
+    /**
+     * Constructs a new {@code MMIOPermission} with the specified target name and the implicit {@code open} action.
+     *
+     * @param name
+     *            the target name (as defined above).
+     * @throws NullPointerException
+     *             if {@code name} is {@code null}.
+     *
+     * @see #getName getName
+     */
+    public MMIOPermission(String name) {
+        super(name);
+    }
+
+    /**
+     * Constructs a new {@code MMIOPermission} instance with the specified target name and action list.
+     *
+     * @param name
+     *            the target name (as defined above).
+     * @param actions
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}.
+     * @throws NullPointerException
+     *             if {@code name} is {@code null}.
+     * @throws IllegalArgumentException
+     *             if actions is {@code null}, empty or contains an action other than the
+     *             specified possible actions.
+     *
+     * @see #getName getName
+     */
+    public MMIOPermission(String name, String actions) {
+        super(name);
+    }
+
+    /**
+     * Checks two {@code MMIOPermission} objects for equality.
+     *
+     * @param obj
+     *            the object to test for equality with this object.
+     *
+     * @return {@code true} if {@code obj} is a {@code MMIOPermission} and has the same target name and actions as
+     *         this {@code MMIOPermission} object.
+     */
+    @Override
+    public boolean equals(Object obj) {
+        return false;
+    }
+
+    /**
+     * Returns the list of possible actions in the following order: {@code open} or {@code powermanage}. </em>
+     *
+     * @return comma-separated list of possible actions.
+     */
+    @Override
+    public String getActions() {
+        return null;
+    }
+
+    /**
+     * Returns the hash code value for this object.
+     *
+     * @return a hash code value for this object.
+     */
+    @Override
+    public int hashCode() {
+        return 0;
+    }
+
+    /**
+     * Checks if this {@code MMIOPermission} object "implies" the specified permission.
+     * <p />
+     * More specifically, this method returns {@code true} if:
+     * <ul>
+     * <li>{@code permission} is an instance of {@code MMIOPermission}, and
+     * <li>{@code permission}'s actions are a proper subset of this object's action list, and</i>
+     * <li>{@code permission}'s hardware addressing information or range thereof
+     * is included in this {@code MMIOPermission}'s hardware addressing information range.
+     * </ul>
+     *
+     * @param permission
+     *            the permission to check against.
+     *
+     * @return {@code true} if the specified permission is not {@code null} and is implied by this object, {@code false}
+     *         otherwise.
+     */
+    @Override
+    public boolean implies(Permission permission) {
+        return false;
+    }
+
+    /**
+     * Returns a new {@code PermissionCollection} for storing {@code MMIOPermission} objects.
+     * <p>
+     * {@code MMIOPermission} objects must be stored in a manner that allows them to be inserted into the collection in
+     * any order, but that also enables the {@code PermissionCollection} implies method to be implemented in an
+     * efficient (and consistent) manner.
+     *
+     * <p>
+     * If {@code null} is returned, then the caller of this method is free to store permissions of this type in any
+     * PermissionCollection they choose (one that uses a {@code Hashtable}, one that uses a {@code Vector}, etc).
+     *
+     * @return a new {@code PermissionCollection} suitable for storing {@code MMIOPermission} objects, or {@code null}
+     *         if one is not defined.
+     */
+    @Override
+    public PermissionCollection newPermissionCollection() {
+        return null;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/RawBlock.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.ClosedDeviceException;
+import jdk.dio.UnavailableDeviceException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * The {@code RawBlock} interface provides methods to access a continuous range of physical memory (raw memory) as a
+ * {@link ByteBuffer}. A {@code RawBlock} instance can be obtained from a {@link MMIODevice} instance.
+ * <p />
+ * The {@code index} parameter of {@code ByteBuffer} <i>absolute</i> operations map to physical memory addresses. The
+ * {@code index} values are relative to the base address of the raw memory area. The {@code index} value {@code 0}
+ * corresponds to the base address of the raw memory area.
+ * @since 1.0
+ */
+public interface RawBlock extends RawMemory {
+    /**
+     * Gets the complete memory area this {@code RawBlock} is mapped to as a <em>direct</em> {@link ByteBuffer}. The
+     * byte order of the retrieved buffer will be that of this device unless the byte ordering is not standard (as
+     * indicated by the value {@link MMIODevice#MIXED_ENDIAN}; in which case the buffer's byte order will be set to
+     * {@link ByteOrder#BIG_ENDIAN}.
+     * <p />
+     * When the returned {@code ByteBuffer} instance is invalidated because the device is either closed or in
+     * exclusive use by some other application then an attempt to access the {@code ByteBuffer} instance will not change
+     * the buffer's content and will cause a {@code ClosedDeviceException} or some other unspecified exception to be
+     * thrown either at the time of the access or at some later time.
+     *
+     * @return the <em>direct</em> {@link ByteBuffer} for the complete raw memory area associated with this
+     *         {@code RawBlock}.
+     * @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.
+     */
+    ByteBuffer asDirectBuffer() throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Returns the name assigned to this {@code RawBlock} instance.
+     *
+     * @return this {@code RawBlock} instance's name or {@code null} if this {@code RawBlock} instance was obtained by a
+     *         call to {@link MMIODevice#getAsRawBlock MMIODevice.getAsRawBlock}.
+     */
+    @Override
+    String getName();
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/RawMemory.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+/**
+ * The {@code RawMemory} interface provides generic methods for the different types of raw memory area a device
+ * device's registers may be mapped to.
+ * @since 1.0
+ */
+public interface RawMemory {
+
+    /**
+     * Returns the name assigned to this {@code RawMemory} instance.
+     *
+     * @return this {@code RawMemory} instance's name.
+     */
+    String getName();
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/RawRegister.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+package jdk.dio.mmio;
+
+import jdk.dio.ClosedDeviceException;
+import jdk.dio.UnavailableDeviceException;
+import java.io.IOException;
+
+/**
+ * The {@code RawRegister} interface provides methods for setting and getting the value of a register or memory area
+ * holding a value of type {@code byte}, {@code short}, {@code int} or {@code long}. A {@code RawRegister} instance can
+ * be obtained from a {@link MMIODevice} instance.
+ * <p />
+ * Developers should be aware when using this API of the potential performance and memory allocation penalty induced by
+ * primitive auto-boxing. For intensive reading and writing of registers such as data input and data output registers,
+ * the use of the {@link RawBlock} returned by {@link MMIODevice#getAsRawBlock() } should be preferred.
+ *
+ * @param <T>
+ *            the type of the value held by the register.
+ * @since 1.0
+ */
+public interface RawRegister<T extends Number> extends RawMemory {
+
+    /**
+     * Sets the value at the memory area associated with this object to the result of performing a logical AND of the
+     * value at the memory area with the argument value.
+     *
+     * @param value
+     *            the value to perform a logical AND with.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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.
+     */
+    void and(T value) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Clears (sets to {@code 0}) the designated bit value at the memory area associated with this object.
+     *
+     * @param index
+     *            the index of the bit.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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 IllegalArgumentException
+     *             if {@code index} is less than {@code 0} or greater or equal to the size in bits of the value at the
+     *             memory area associated with this object.
+     */
+    void clearBit(int index) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Clears (sets to {@code 0}) the specified bits at the memory area associated with this object.
+     *
+     * @param mask
+     *            the bit mask.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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.
+     */
+    void clearBits(T mask) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Gets the value at the memory area associated with this object.
+     *
+     * @return the value.
+     * @throws IOException
+     *             if the associated memory area is not readable.
+     * @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.
+     */
+    T get() throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Returns the type of the value this {@code RawRegister} instance can hold.
+     *
+     * @return this {@code RawRegister} instance's value type.
+     */
+    Class<T> getType();
+
+    /**
+     * Checks whether the designated bit value at the memory area associated with this object is set (equal to {@code 1}
+     * )
+     *
+     * @param index
+     *            the index of the bit.
+     * @return the bit value.
+     * @throws IOException
+     *             if the associated memory area is not readable.
+     * @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 IllegalArgumentException
+     *             if {@code index} is less than {@code 0} or greater or equal to the size in bits of the value at the
+     *             memory area associated with this object.
+     */
+    boolean isBitSet(int index) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Sets the value at the memory area associated with this object to the result of performing a logical OR of the
+     * value at the memory area with the argument value.
+     *
+     * @param value
+     *            the value to perform a logical OR with.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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.
+     */
+    void or(T value) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Sets the value at the memory area associated with this object.
+     *
+     * @param value
+     *            the value to set.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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.
+     */
+    void set(T value) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Sets (to {@code 1}) the designated bit value at the memory area associated with this object.
+     *
+     * @param index
+     *            the index of the bit.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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 IllegalArgumentException
+     *             if {@code index} is less than {@code 0} or greater or equal to the size in bits of the value at the
+     *             memory area associated with this object.
+     */
+    void setBit(int index) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Sets (to {@code 1}) the specified bits at the memory area associated with this object.
+     *
+     * @param mask
+     *            the bit mask.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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.
+     */
+    void setBits(T mask) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+
+    /**
+     * Sets the value at the memory area associated with this object to the result of performing a logical XOR of the
+     * value at the memory area with the argument value.
+     *
+     * @param value
+     *            the value to perform a logical XOR with.
+     * @throws IOException
+     *             if the associated memory area is not writable.
+     * @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.
+     */
+    void xor(T value) throws IOException, UnavailableDeviceException, ClosedDeviceException;
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/se/classes/jdk/dio/mmio/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+/**
+ * Interfaces and classes for performing memory-mapped I/O.
+ * <p />
+ * Memory mapped I/O is typically used for controlling hardware devices by reading from and writing to registers or
+ * memory blocks of the hardware mapped to the system memory. The MMIO APIs allows for low level control over the
+ * device.
+ * <p />
+ * In order to access a specific memory block a device has been mapped to, an application should first open and obtain
+ * an {@link jdk.dio.mmio.MMIODevice} instance for the memory-mapped I/O device the application wants to
+ * control and access, using its numeric ID, name, type (interface) and/or properties:
+ * <dl>
+ * <dt>Using its ID</dt>
+ * <dd>
+ * <blockquote>
+ *
+ * <pre>
+ * MMIODevice device = (MMIODevice) DeviceManager.open(7);
+ * </pre>
+ *
+ * </blockquote></dd>
+ * <dt>Using its name and interface</dt>
+ * <dd>
+ * <blockquote>
+ *
+ * <pre>
+ * MMIODevice device = DeviceManager.open(&quot;RTC&quot;, MMIODevice.class, null);
+ * </pre>
+ *
+ * </blockquote></dd>
+ * </dl>
+ * Once the device opened, the application can retrieve registers using methods of the
+ * {@link jdk.dio.mmio.MMIODevice MMIODevice} interface such as the
+ * {@link jdk.dio.mmio.MMIODevice#getRegister MMIODevice.getRegister} method. <blockquote>
+ *
+ * <pre>
+ * device.getRegister(&quot;Seconds&quot;, Byte.class);
+ * </pre>
+ *
+ * </blockquote> When done, the application should call the {@link jdk.dio.mmio.MMIODevice#close MMIODevice.close}
+ * method to close the MMIO device. <blockquote>
+ *
+ * <pre>
+ * device.close();
+ * </pre>
+ *
+ * </blockquote> The following sample codes give examples of using the MMIO API to communicate Real Time Clock device:
+ * <blockquote>
+ *
+ * <pre>
+ * static final int INTERRUPT = 0;
+ *
+ * try (MMIODevice rtc = DeviceManager.open("RTC", MMIODevice.class, null)) {
+ *     //The RTC device has 14 bytes of clock and control registers and 50 bytes
+ *     // of general purpose RAM (see the data sheet of the 146818 Real Time Clock such as HITACHI HD146818).
+ *     RawRegister<Byte> seconds = rtc.getRegister("Seconds", Byte.class);
+ *     RawRegister<Byte> secAlarm = rtc.getRegister("SecAlarm", Byte.class);
+ *     RawRegister<Byte> minutes = rtc.getRegister("Minutes", Byte.class);
+ *     RawRegister<Byte> minAlarm = rtc.getRegister("MinAlarm", Byte.class);
+ *     RawRegister<Byte> hours = rtc.getRegister("Hours", Byte.class);
+ *     RawRegister<Byte> hrAlarm = rtc.getRegister("HrAlarm", Byte.class);
+ *     ... // More registers
+ *     RawRegister<Byte> registerA = rtc.getRegister("RegisterA", Byte.class);
+ *     RawRegister<Byte> registerB = rtc.getRegister("RegisterB", Byte.class);
+ *     RawRegister<Byte> registerC = rtc.getRegister("RegisterC", Byte.class);
+ *     RawRegister<Byte> registerD = rtc.getRegister("RegisterD", Byte.class);
+ *     RawBlock userRAM = rtc.getBlock("UserRam");
+ *     ...
+ * } catch (IOException ioe) {
+ *     // handle exception
+ * }
+ * </pre>
+ *
+ * </blockquote> The preceding example is using a <em>try-with-resources</em> statement; the
+ * {@link jdk.dio.mmio.MMIODevice#close MMI0Device.close} method is automatically invoked by the
+ * platform at the end of the statement. <blockquote>
+ *
+ * <pre>
+ * // Sets the daily alarm for after some delay
+ * public void setAlarm(MMIODevice rtc, byte delaySeconds, byte delayMinutes, byte delayHours) throws IOException,
+ *         DeviceException {
+ *     Register&lt;Byte&gt; seconds = rtc.getByteRegister(&quot;Seconds&quot;, Byte.class);
+ *     Register&lt;Byte&gt; secAlarm = rtc.getByteRegister(&quot;SecAlarm&quot;, Byte.class);
+ *     Register&lt;Byte&gt; minutes = rtc.getByteRegister(&quot;Minutes&quot;, Byte.class);
+ *     Register&lt;Byte&gt; minAlarm = rtc.getByteRegister(&quot;MinAlarm&quot;, Byte.class);
+ *     Register&lt;Byte&gt; hours = rtc.getByteRegister(&quot;Hours&quot;, Byte.class);
+ *     Register&lt;Byte&gt; hrAlarm = rtc.getByteRegister(&quot;HrAlarm&quot;, Byte.class);
+ *     Register&lt;Byte&gt; registerB = rtc.getByteRegister(&quot;RegisterB&quot;, Byte.class);
+ *     RawBlock userRAM = rtc.getBlock(&quot;UserRam&quot;, Byte.class);
+ *
+ *     // Directly read from/write to the registers using RawByte instances.
+ *     byte currentSeconds = seconds.get();
+ *     byte currentMinutes = minutes.get();
+ *     byte currentHours = hours.get();
+ *     int i = (currentSeconds + delaySeconds) % 60;
+ *     int j = (currentSeconds + delaySeconds) / 60;
+ *     secAlarm.set((byte) i);
+ *     i = (currentMinutes + delayMinutes + j) % 60;
+ *     j = (currentMinutes + delayMinutes + j) / 60;
+ *     minAlarm.set((byte) i);
+ *     i = (currentHours + delayHours + j) % 24;
+ *     hrAlarm.set((byte) i);
+ *     rtc.setMMIOEventListener(INTERRUPT, new MMIOEventListener() {
+ *
+ *         public void eventDispatched(MMIOEvent event) {
+ *             try {
+ *                 MMIODevice rtc = event.getDevice();
+ *                 Register&lt;Byte&gt; registerC = rtc.getByteRegister(&quot;RegisterC&quot;, Byte.class);
+ *                 // Check the Alarm Interrupt Flag (AF)
+ *                 if ((registerC.get() &amp; 0X20) != 0) {
+ *                     // Notify application of alarm
+ *                 }
+ *             } catch (IOException ioe) {
+ *                 // handle exception
+ *             }
+ *         }
+ *     });
+ *     // Set the Alarm Interrupt Enabled (AIE) flag
+ *     registerB.set((byte) (registerB.get() | 0X20));
+ * }
+ * </pre>
+ *
+ * </blockquote> Alternatively, in this example, the value of {@code RegisterC} could be automatically captured upon
+ * occurrence of an interrupt request from the Real Time Clock device as follows: <blockquote>
+ *
+ * <pre>
+ * rtc.setMMIOEventListener(INTERRUPT, &quot;RegisterC&quot;, new MMIOEventListener() {
+ *
+ *     public void eventDispatched(MMIOEvent event) {
+ *         Byte v = event.getCapturedRegisterValue();
+ *         // Check the Alarm Interrupt Flag (AF)
+ *         if ((v.byteValue() &amp; 0X20) != 0) {
+ *             // Notify application of alarm
+ *         }
+ *     }
+ * });
+ * </pre>
+ *
+ * </blockquote>
+ * <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.
+ *
+ * @since 1.0
+ */
+package jdk.dio.mmio;
+
--- a/src/share/classes/jdk/dio/AsyncErrorHandler.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/AsyncErrorHandler.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  *
  * @param <P>
  *            the device type that generates the error.
+ * @since 1.0
  */
 public interface AsyncErrorHandler<P extends Device<? super P>> {
 
--- a/src/share/classes/jdk/dio/BufferAccess.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/BufferAccess.java	Thu Sep 11 13:40:27 2014 -0400
@@ -34,6 +34,7 @@
  *
  * @param <B>
  *            the I/O buffer type.
+ * @since 1.0
  */
 public interface BufferAccess<B extends Buffer> {
 
@@ -41,7 +42,7 @@
      * Gets the <em>direct</em> input buffer of this device <i>(optional operation)</i>.
      * <p />
      * The input buffer will get allocated on a per-application basis to avoid conflicts;
-     * but that only one such buffer will be allocated per application. The capacity of the buffer
+     * but only one such buffer will be allocated per application. The capacity of the buffer
      * will be determined based on the property of the underlying device.
      * <p />
      * When the returned {@code Buffer} instance is invalidated because the device is either
@@ -65,7 +66,7 @@
      * Gets the <em>direct</em> output buffer of this device <i>(optional operation)</i>.
      * <p />
      * The output buffer will get allocated on a per-application basis to avoid conflicts;
-     * but that only one such buffer will be allocated per application. The capacity of the buffer
+     * but only one such buffer will be allocated per application. The capacity of the buffer
      * will be determined based on the property of the underlying device.
      * <p />
      * When the returned {@code Buffer} instance is invalidated because the device is either
--- a/src/share/classes/jdk/dio/ClosedDeviceException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/ClosedDeviceException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -30,6 +30,8 @@
 /**
  * Thrown by an instance of {@link Device} to indicate that an operation is attempted on a
  * device which is closed.
+ *
+ * @since 1.0
  */
 public class ClosedDeviceException extends ClosedChannelException {
 
--- a/src/share/classes/jdk/dio/Device.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/Device.java	Thu Sep 11 13:40:27 2014 -0400
@@ -41,6 +41,7 @@
  *
  * @param <P>
  *            the device type the descriptor is defined for.
+ * @since 1.0
  */
 public interface Device<P extends Device<? super P>> extends Channel {
 
@@ -53,7 +54,7 @@
      */
     int LITTLE_ENDIAN = 0;
     /**
-     * Mixed-endian (nonstandard) byte ordering.
+     * Mixed-endian (non-standard) byte ordering.
      */
     int MIXED_ENDIAN = 2;
 
@@ -82,7 +83,7 @@
     /**
      * Closes this device, relinquishing the underlying device resource and
      * making it available to other applications. Upon closing the underlying device
-     * resource MUST be set to the state (power state and configuration) it was in before opening
+     * resource MUST be set to the state (power state and configuration) it was in prior to opening
      * it.
      * <p />
      * Once closed, subsequent operations on that very same {@code Device} instance will result
--- a/src/share/classes/jdk/dio/DeviceAlreadyExistsException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceAlreadyExistsException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by the {@link DeviceManager} to indicate that a device is already
  * registered for the specified ID.
+ *
+ * @since 1.0
  */
 public class DeviceAlreadyExistsException extends DeviceException {
 
--- a/src/share/classes/jdk/dio/DeviceConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -64,17 +64,20 @@
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
  * @see InvalidDeviceConfigException
+ * @since 1.0
  */
 public interface DeviceConfig<P extends Device<? super P>> {
 
     /**
-     * Used to indicate that the default value of a configuration parameter use.
+     * Used to indicate that the default value of a configuration parameter should be used.
      */
     int DEFAULT = -1;
 
     /**
      * The {@code HardwareAddressing} interface defines an abstraction of an hardware addressing
      * information common on different platforms.
+     *
+     * @since 1.0
      */
     public interface HardwareAddressing {
 
--- a/src/share/classes/jdk/dio/DeviceDescriptor.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceDescriptor.java	Thu Sep 11 13:40:27 2014 -0400
@@ -32,6 +32,7 @@
  *
  * @param <P>
  *            the device type the descriptor is defined for.
+ * @since 1.0
  */
 public interface DeviceDescriptor<P extends Device<? super P>> {
 
--- a/src/share/classes/jdk/dio/DeviceEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -34,6 +34,7 @@
  *
  * @param <P>
  *            the device type the event is defined for.
+ * @since 1.0
  */
 public abstract class DeviceEvent<P extends Device<? super P>> {
 
--- a/src/share/classes/jdk/dio/DeviceEventListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceEventListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -38,6 +38,8 @@
  * </ul>
  * A compliant implementation of this specification MUST catch unchecked exceptions that may be
  * thrown by a listener.
+ *
+ * @since 1.0
  */
 public interface DeviceEventListener {
 }
--- a/src/share/classes/jdk/dio/DeviceException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -29,6 +29,8 @@
 
 /**
  * Thrown to indicate that a general exception occurred on a device operation.
+ *
+ * @since 1.0
  */
 public class DeviceException extends IOException {
 
--- a/src/share/classes/jdk/dio/DeviceManager.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceManager.java	Thu Sep 11 13:40:27 2014 -0400
@@ -100,6 +100,7 @@
  * @see Device
  * @see jdk.dio.spi.DeviceProvider
  * @see DeviceConfig
+ * @since 1.0
  */
 public class DeviceManager {
     /**
@@ -610,8 +611,8 @@
     }
 
     /**
-     * Looks up and opens a {@code Device} instance for the specified name, type or
-     * properties, or both. An instance of the first <em>available</em> matching {@code Device} is
+     * Looks up and opens a {@code Device} instance for the specified name, type and/or
+     * properties. An instance of the first <em>available</em> matching {@code Device} 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 />
@@ -736,8 +737,8 @@
     }
 
     /**
-     * Looks up and opens a {@code Device} instance for the specified name, type or
-     * properties, or both. An instance of the first <em>available</em> matching {@code Device} is
+     * Looks up and opens a {@code Device} instance for the specified name, type and/or
+     * properties. An instance of the first <em>available</em> 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 />
--- a/src/share/classes/jdk/dio/DeviceMgmtPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceMgmtPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -71,7 +71,7 @@
  * The target name {@code "*:*"} matches all device names and all device IDs as is the target name {@code "*"}.
  * </dd>
  * </dt>
- * The actions to be granted are passed to the constructor in a string containing a list of one or more comma-delimited
+ * 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:
  * <dl>
@@ -87,6 +87,7 @@
  * @see DeviceManager#open DeviceManager.open
  * @see DeviceManager#register DeviceManager.register
  * @see DeviceManager#unregister DeviceManager.unregister
+ * @since 1.0
  */
 public class DeviceMgmtPermission  extends Permission {
 
@@ -114,7 +115,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device management operations: {@code register}
+     *            comma-separated list of device management operations: {@code register}
      *            {@code unregister} or {@code open}.
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
@@ -150,7 +151,7 @@
      * Returns the list of possible actions in the following order: {@code register},
      * {@code unregister} or {@code open}.
      *
-     * @return comma-delimited list of possible actions.
+     * @return comma-separated list of possible actions.
      */
     @Override
     public String getActions() {
--- a/src/share/classes/jdk/dio/DeviceNotFoundException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DeviceNotFoundException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -27,6 +27,8 @@
 
 /**
  * Thrown to indicate that there is no device matching the provided device numeric ID, name or properties.
+ *
+ * @since 1.0
  */
 public class DeviceNotFoundException extends DeviceException {
 
--- a/src/share/classes/jdk/dio/DevicePermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/DevicePermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -79,7 +79,7 @@
  * designate devices using their specific hardware addressing information.
  * <p />
  * The actions to be granted are passed to the constructor in a string containing a list of one or
- * more comma-delimited keywords. The supported common actions are {@code open} and
+ * more comma-separated keywords. The supported common actions are {@code open} and
  * {@code powermanage}. Their meaning is defined as follows:
  * <dl>
  * <dt>{@code open}</dt>
@@ -93,6 +93,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public abstract class DevicePermission extends Permission {
     /**
@@ -106,7 +107,7 @@
     public static final String POWER_MANAGE = "powermanage";
 
     /**
-     * Coma-separated action list
+     * Comam-separated action list
      *
      */
     private String myActions;
@@ -143,7 +144,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}
      *            (additional actions may be defined by subclasses).
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/InputRoundListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/InputRoundListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -40,6 +40,7 @@
  *            the device type that generates the event to listener for.
  * @param <B>
  *            the input buffer type.
+ * @since 1.0
  */
 public interface InputRoundListener<P extends Device<? super P>, B extends Buffer> extends DeviceEventListener,
         AsyncErrorHandler<P> {
--- a/src/share/classes/jdk/dio/InvalidDeviceConfigException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/InvalidDeviceConfigException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -27,6 +27,8 @@
 
 /**
  * Thrown to indicate that the provided device configuration is invalid/is not supported.
+ *
+ * @since 1.0
  */
 public class InvalidDeviceConfigException extends DeviceException {
 
--- a/src/share/classes/jdk/dio/OutputRoundListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/OutputRoundListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -40,6 +40,7 @@
  *            the device type that generates the event to listener for.
  * @param <B>
  *            the output buffer type.
+ * @since 1.0
  */
 public interface OutputRoundListener<P extends Device<? super P>, B extends Buffer> extends
         DeviceEventListener, AsyncErrorHandler<P> {
--- a/src/share/classes/jdk/dio/RegistrationEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/RegistrationEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  *            the device type the event is defined for.
  * @see DeviceManager
  * @see RegistrationListener
+ * @since 1.0
  */
 public class RegistrationEvent<P extends Device<? super P>> extends EventObject {
     /**
--- a/src/share/classes/jdk/dio/RegistrationListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/RegistrationListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -37,6 +37,7 @@
  * @param <P>
  *            the device type the event is defined for.
  * @see DeviceManager
+ * @since 1.0
  */
 public interface RegistrationListener<P extends Device<? super P>> extends EventListener {
 
--- a/src/share/classes/jdk/dio/RoundCompletionEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/RoundCompletionEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -38,6 +38,7 @@
  *            the I/O buffer type.
  * @see InputRoundListener
  * @see OutputRoundListener
+ * @since 1.0
  */
 public class RoundCompletionEvent<P extends Device<? super P>, B extends Buffer> extends DeviceEvent<P> {
     /**
@@ -93,15 +94,15 @@
      * @throws IllegalArgumentException
      *             if {@code timeStamp}, {@code timeStampMicros} or {@code number} is negative.
      */
-    public RoundCompletionEvent(P peripheral, B buffer, int number, long timeStamp, int timeStampMicros) {
-        if (null == peripheral || buffer == null) {
+    public RoundCompletionEvent(P device, B buffer, int number, long timeStamp, int timeStampMicros) {
+        if (null == device || buffer == null) {
             throw new NullPointerException();
         }
 
         if (number < 0 || number > buffer.limit() || timeStamp < 0 || timeStampMicros < 0) {
             throw new IllegalArgumentException();
         }
-        this.device = peripheral;
+        this.device = device;
         this.buffer = buffer;
         this.number = number;
         this.timeStamp = timeStamp;
--- a/src/share/classes/jdk/dio/Transactional.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/Transactional.java	Thu Sep 11 13:40:27 2014 -0400
@@ -50,6 +50,8 @@
  * }
  * </pre>
  * </blockquote>
+ *
+ * @since 1.0
  */
 public interface Transactional {
 
--- a/src/share/classes/jdk/dio/UnavailableDeviceException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/UnavailableDeviceException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by the {@link DeviceManager} to indicate that a device cannot be open because it
  * is already open or that a device cannot be acquired for exclusive access.
+ *
+ * @since 1.0
  */
 public class UnavailableDeviceException extends DeviceException {
 
--- a/src/share/classes/jdk/dio/UnsupportedAccessModeException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/UnsupportedAccessModeException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by the {@link DeviceManager} to indicate that the looked-up device cannot be
  * opened in the requested access mode.
+ *
+ * @since 1.0
  */
 public class UnsupportedAccessModeException extends DeviceException {
 
--- a/src/share/classes/jdk/dio/UnsupportedDeviceTypeException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/UnsupportedDeviceTypeException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by the {@link DeviceManager} to indicate permanent unavailability of the looked up
  * device. The corresponding device type is not supported on the system.
+ *
+ * @since 1.0
  */
 public class UnsupportedDeviceTypeException extends DeviceException {
 
--- a/src/share/classes/jdk/dio/adc/ADCChannel.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/ADCChannel.java	Thu Sep 11 13:40:27 2014 -0400
@@ -54,7 +54,7 @@
  * DeviceManager.open(config,...)} it is not assigned any ID nor name.
  * <p />
  * Once opened, an application can read the current sampled input value of an ADC channel by calling
- * the {@link #acquire() acquire} method or can acquire the input values sampled over a period by
+ * the {@link #acquire() acquire} method or can acquire the input values sampled over a period of time by
  * calling the {@link #acquire(IntBuffer)} method.
  * <p />
  * An application can also asynchronously acquire the input values sampled at a certain rate by
@@ -69,8 +69,8 @@
  * notified when the input value gets out of or back in the defined range. The monitoring can be
  * stopped by calling the {@link #stopMonitoring() stopMonitoring} method.
  * <p />
- * At most one acquisition (synchronous or asynchronous), or (depending on the platform) at most
- * one monitoring, or both can be going on at any time. If an acquisition and a monitoring can be performed
+ * At most one acquisition (synchronous or asynchronous) and/or (depending on the platform) at most
+ * one monitoring can be going on at any time. If an acquisition and a monitoring can be performed
  * concurrently, they will be performed at the same sampling rate (see
  * {@link #getSamplingInterval() getSamplingInterval}). They therefore respectively acquire and
  * monitor the same sampled input values.
@@ -86,6 +86,7 @@
  * @see AcquisitionRoundListener
  * @see MonitoringListener
  * @see ADCPermission
+ * @since 1.0
  */
 public interface ADCChannel extends Device<ADCChannel>, BufferAccess<IntBuffer> {
 
@@ -304,7 +305,7 @@
      * listener.
      * <p />
      * 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
+     * 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.
@@ -315,7 +316,9 @@
      * 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.
+     * 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.
      *
      * @param dst
      *            The buffer into which integer raw sampled input values are to be transferred.
@@ -353,12 +356,14 @@
      * of continuous sampling in subsequent sampled input values to be lost).
      * <p />
      * 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
+     * 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 />
-     * Only one acquisition (synchronous or asynchronous) can be going on at any time.
+     * 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.
      *
      * @param dst1
      *            The first buffer into which integer raw sampled input values are to be
--- a/src/share/classes/jdk/dio/adc/ADCChannelConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/ADCChannelConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -49,6 +49,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class ADCChannelConfig implements DeviceConfig<ADCChannel>, DeviceConfig.HardwareAddressing {
--- a/src/share/classes/jdk/dio/adc/ADCPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/ADCPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -57,6 +57,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class ADCPermission extends DevicePermission {
 
@@ -81,7 +82,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}
      *            .
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/adc/AcquisitionRoundListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/AcquisitionRoundListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -39,6 +39,7 @@
  * AsyncErrorHandler} interface for getting notified of asynchronous I/O errors.
  *
  * @see ADCChannel#startAcquisition ADCChannel.startAcquisition
+ * @since 1.0
  */
 public interface AcquisitionRoundListener extends InputRoundListener<ADCChannel, IntBuffer> {
 
--- a/src/share/classes/jdk/dio/adc/InvalidInputSamplingRateException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/InvalidInputSamplingRateException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by an instance of {@link ADCChannel} in case the requested sampling rate is higher than
  * the maximum sampling rate the ADC device can support.
+ *
+ * @since 1.0
  */
 public class InvalidInputSamplingRateException extends RuntimeException {
 
--- a/src/share/classes/jdk/dio/adc/MonitoringEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/MonitoringEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  *
  * @see ADCChannel
  * @see MonitoringListener
+ * @since 1.0
  */
 public class MonitoringEvent extends DeviceEvent<ADCChannel> {
     /**
--- a/src/share/classes/jdk/dio/adc/MonitoringListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/MonitoringListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  * {@link ADCChannel#startMonitoring ADCChannel.startMonitoring} method.
  *
  * @see ADCChannel
+ * @since 1.0
  */
 public interface MonitoringListener extends DeviceEventListener, AsyncErrorHandler<ADCChannel> {
 
--- a/src/share/classes/jdk/dio/adc/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/adc/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -140,5 +140,7 @@
  * <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.
+ *
+ * @since 1.0
  */
 package jdk.dio.adc;
--- a/src/share/classes/jdk/dio/atcmd/ATDevice.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/ATDevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -42,25 +42,25 @@
  * call to one of the
  * {@link DeviceManager#open(java.lang.String, java.lang.Class, java.lang.String[])
  * DeviceManager.open(name,...)} methods using its name and capabilities. <br />
- * The defined property keywords include {@code javax.deviceaccess.atcmd.config},
- * {@code javax.deviceaccess.atcmd.csd}, {@code javax.deviceaccess.atcmd.psd},
- * {@code javax.deviceaccess.atcmd.voice}, {@code javax.deviceaccess.atcmd.sms},
- * {@code javax.deviceaccess.atcmd.sim}, {@code javax.deviceaccess.atcmd.phonebook}. Their meaning
+ * The defined property keywords include {@code jdk.dio.atcmd.config},
+ * {@code jdk.dio.atcmd.csd}, {@code jdk.dio.atcmd.psd},
+ * {@code jdk.dio.atcmd.voice}, {@code jdk.dio.atcmd.sms},
+ * {@code jdk.dio.atcmd.sim}, {@code jdk.dio.atcmd.phonebook}. Their meaning
  * is defined as follows:
  * <dl>
- * <dt>{@code javax.deviceaccess.atcmd.config}</dt>
+ * <dt>{@code jdk.dio.atcmd.config}</dt>
  * <dd>Supports access to configuration, control and identification commands.</dd>
- * <dt>{@code javax.deviceaccess.atcmd.csd}</dt>
+ * <dt>{@code jdk.dio.atcmd.csd}</dt>
  * <dd>Supports access to circuit switched data (CSD) related AT commands.</dd>
- * <dt>{@code javax.deviceaccess.atcmd.psd}</dt>
+ * <dt>{@code jdk.dio.atcmd.psd}</dt>
  * <dd>Supports access to packet switched data, such as GPRS or EDGE, related AT commands.</dd>
- * <dt>{@code javax.deviceaccess.atcmd.voice}</dt>
+ * <dt>{@code jdk.dio.atcmd.voice}</dt>
  * <dd>Supports access to voice call related AT commands.</dd>
- * <dt>{@code javax.deviceaccess.atcmd.sms}</dt>
+ * <dt>{@code jdk.dio.atcmd.sms}</dt>
  * <dd>Supports access to SMS related AT commands.</dd>
- * <dt>{@code javax.deviceaccess.atcmd.sim}</dt>
+ * <dt>{@code jdk.dio.atcmd.sim}</dt>
  * <dd>Supports access to SIM related AT commands.</dd>
- * <dt>{@code javax.deviceaccess.atcmd.phonebook}</dt>
+ * <dt>{@code jdk.dio.atcmd.phonebook}</dt>
  * <dd>Supports access to phonebook related AT commands.
  * </dl>
  * This list may be extended to designate other (possibly proprietary) capabilities (properties).
@@ -68,7 +68,7 @@
  * As per the convention, when one of this capabilities is supported by an AT device it must be
  * assigned as a positively asserted boolean capability: <blockquote>
  * <em>&lt;keyword&gt;</em>{@code =true} </blockquote>
- * For example: {@code javax.deviceaccess.atcmd.phonebook=true}. <br />
+ * For example: {@code jdk.dio.atcmd.phonebook=true}. <br />
  * When a capability is not supported by an AT device negatively asserting the boolean capability is
  * optional.
  * <p />
@@ -121,6 +121,7 @@
  * @see CommandResponseHandler
  * @see UnsolicitedResponseHandler
  * @see DataConnection
+ * @since 1.0
  */
 public interface ATDevice extends Device<ATDevice> {
 
@@ -242,7 +243,7 @@
      * Sends an AT command and wait for the response. If the command line includes payload text, it
      * must be properly terminated with e.g. {@code Ctrl-Z} otherwise the operation may block. In
      * which case it may be canceled by a call to {@link #abortCommand abortCommand}. <br />
-     * The return response string may include the command echo unless command echo has
+     * The returned response string may include the command echo unless command echo has
      * been disabled (such as with an {@code ATE0} command).
      *
      * @param cmd
--- a/src/share/classes/jdk/dio/atcmd/ATDeviceConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/ATDeviceConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -49,6 +49,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public class ATDeviceConfig implements DeviceConfig<ATDevice>, DeviceConfig.HardwareAddressing {
--- a/src/share/classes/jdk/dio/atcmd/ATModem.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/ATModem.java	Thu Sep 11 13:40:27 2014 -0400
@@ -30,6 +30,7 @@
 /**
  * The {@code ATModem} provides methods for controlling a Data Communication Equipment such as a modem or a cellular
  * module using AT commands and modem control signals.
+ * @since 1.0
  */
 public interface ATModem extends ATDevice, ModemSignalsControl<ATModem> {
 }
--- a/src/share/classes/jdk/dio/atcmd/ATPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/ATPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -45,7 +45,7 @@
  * {@link ATDeviceConfig#getChannelNumber ATDeviceConfig.getChannelNumber}. The characters in the string must all be decimal digits.
  * </dd>
  * </dl>
- * The actions to be granted are passed to the constructor in a string containing a list of one or more comma-delimited
+ * The actions to be granted are passed to the constructor in a string containing a list of one or more comma-separated
  * keywords. The supported keywords are {@code open}, {@code data} and {@code powermanage}. Their meaning is defined as follows:
  * <dl>
  * <dt>{@code open}</dt>
@@ -59,6 +59,7 @@
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
  * @see ATDevice#openDataConnection ATDevice.openDataConnection
+ * @since 1.0
  */
 public class ATPermission extends DevicePermission {
 
@@ -88,7 +89,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of AT device operations: {@code open}, {@code data} or {@code powermanage}.
+     *            comma-separated list of AT device operations: {@code open}, {@code data} or {@code powermanage}.
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
      * @throws IllegalArgumentException
--- a/src/share/classes/jdk/dio/atcmd/CommandResponseHandler.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/CommandResponseHandler.java	Thu Sep 11 13:40:27 2014 -0400
@@ -41,6 +41,7 @@
  * specification MUST catch unchecked exceptions that may be thrown by a {@code CommandResponseHandler}.
  *
  * @see ATDevice
+ * @since 1.0
  */
 public interface CommandResponseHandler {
 
--- a/src/share/classes/jdk/dio/atcmd/DataConnection.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/DataConnection.java	Thu Sep 11 13:40:27 2014 -0400
@@ -30,6 +30,7 @@
 /**
  * The {@code DataConnection} interface provides methods for reading and writing to a data
  * connection opened by issuing an AT command (e.g. {@code ATD}).
+ * @since 1.0
  */
 public interface DataConnection extends ByteChannel {
 
@@ -37,9 +38,9 @@
      * Returns the {@code ATDevice} this data connection has been opened with.
      * <p />
      * The returned object may be an instance of {@link ATModem ATModem},
-     * allowing for controlling the modem signals. Not also that in case of a virtual
-     * channel open over a multiplexing protocol, the {@code ATModem} instance may
-     * be specific to that channel and that it may allow
+     * allowing for controlling the modem signals; in case of a virtual
+     * channel open over a multiplexing protocol, this {@code ATModem} instance may
+     * be specific to that channel and may allow
      * for controlling the virtual modem signals associated to that virtual channel.
      *
      * @return the {@code ATDevice} this data connection has been opened with.
--- a/src/share/classes/jdk/dio/atcmd/DataConnectionHandler.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/DataConnectionHandler.java	Thu Sep 11 13:40:27 2014 -0400
@@ -32,6 +32,7 @@
  * A {@code DataConnectionHandler} should not throw any unchecked exception. A compliant
  * implementation of this specification MUST catch unchecked exceptions that may be thrown by a
  * {@code DataConnectionHandler}.
+ * @since 1.0
  */
 public interface DataConnectionHandler {
 
--- a/src/share/classes/jdk/dio/atcmd/UnsolicitedResponseHandler.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/UnsolicitedResponseHandler.java	Thu Sep 11 13:40:27 2014 -0400
@@ -39,6 +39,7 @@
  * {@code UnsolicitedResponseHandler}.
  *
  * @see ATDevice
+ * @since 1.0
  */
 public interface UnsolicitedResponseHandler {
     /**
--- a/src/share/classes/jdk/dio/atcmd/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/atcmd/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -37,8 +37,8 @@
  * <p />
  * To control a specific AT device, an application should first open and obtain an
  * {@link jdk.dio.atcmd.ATDevice} or {@link jdk.dio.atcmd.ATModem}
- * instance for the device the application wants to control, using its numeric ID, or name, or type
- * (interface), or combination of properties:
+ * instance for the device the application wants to control, using its numeric ID, name, type
+ * (interface) and/or properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd><blockquote>
@@ -51,14 +51,14 @@
  * <dd><blockquote>
  *
  * <pre>
- * ATDevice device = DeviceManager.open(&quot;MODEM&quot;, ATDevice.class, &quot;javax.deviceaccess.atcmd.psd=true&quot;,
- *         &quot;javax.deviceaccess.atcmd.sms=true&quot;);
+ * ATDevice device = DeviceManager.open(&quot;MODEM&quot;, ATDevice.class, &quot;jdk.dio.atcmd.psd=true&quot;,
+ *         &quot;jdk.dio.atcmd.sms=true&quot;);
  * </pre>
  * </blockquote> Or (with modem signals control properties), <blockquote>
  *
  * <pre>
- * ATModem device = DeviceManager.open(&quot;MODEM&quot;, ATModem.class, &quot;javax.deviceaccess.atcmd.psd=true&quot;,
- *         &quot;javax.deviceaccess.atcmd.sms=true&quot;);
+ * ATModem device = DeviceManager.open(&quot;MODEM&quot;, ATModem.class, &quot;jdk.dio.atcmd.psd=true&quot;,
+ *         &quot;jdk.dio.atcmd.sms=true&quot;);
  * </pre>
  * </blockquote></dd>
  * </dl>
@@ -112,7 +112,7 @@
  *     // Acquire a modem with &quot;sms&quot; properties
  *     try {
  *         if (modem == null) {
- *             modem = DeviceManager.open(null, ATDevice.class, &quot;javax.deviceaccess.atcmd.sms=true&quot;);
+ *             modem = DeviceManager.open(null, ATDevice.class, &quot;jdk.dio.atcmd.sms=true&quot;);
  *         }
  *         // Send SMS command
  *         SMSHandler sh = new SMSHandler(text);
@@ -145,6 +145,8 @@
  * NullPointerException} to be thrown.
  * <p />
  * This package requires the {@link jdk.dio.modem} package.
+ *
+ * @since 1.0
  */
 package jdk.dio.atcmd;
 
--- a/src/share/classes/jdk/dio/counter/CounterPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/counter/CounterPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -57,6 +57,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class CounterPermission extends DevicePermission {
 
@@ -81,7 +82,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}
      *            .
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/counter/CountingEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/counter/CountingEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  *
  * @see PulseCounter
  * @see CountingListener
+ * @since 1.0
  */
 public class CountingEvent extends DeviceEvent<PulseCounter> {
     /**
--- a/src/share/classes/jdk/dio/counter/CountingListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/counter/CountingListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -36,6 +36,7 @@
  * method.
  *
  * @see PulseCounter
+ * @since 1.0
  */
 public interface CountingListener extends DeviceEventListener, AsyncErrorHandler<PulseCounter> {
 
--- a/src/share/classes/jdk/dio/counter/PulseCounter.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/counter/PulseCounter.java	Thu Sep 11 13:40:27 2014 -0400
@@ -75,6 +75,7 @@
  *
  * @see CountingListener
  * @see CounterPermission
+ * @since 1.0
  */
 public interface PulseCounter extends Device<PulseCounter> {
 
@@ -132,7 +133,7 @@
      * If the counter overflows it restarts from {@code 0} without any further notification. To be
      * notified of such conditions the
      * {@link #startCounting(int, long, jdk.dio.counter.CountingListener) } method
-     * is necessary instead.
+     * should be used instead.
      *
      * @throws IOException
      *             if some other I/O error occurs.
@@ -159,7 +160,7 @@
      * 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 <em>rounded up</em> to accommodate the supported timer
+     * resolution then {@code interval} will be <em>rounded up</em> to accommodate the supported timer
      * resolution.
      * <p/>
      * Pulse counting and notification will immediately start and will repeat until it is stopped by
--- a/src/share/classes/jdk/dio/counter/PulseCounterConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/counter/PulseCounterConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -55,6 +55,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public class PulseCounterConfig implements DeviceConfig<PulseCounter>, DeviceConfig.HardwareAddressing {
@@ -268,7 +269,7 @@
     /**
      * Gets the input source on which the pulses are to be counted/measured.
      * <p />
-     * A concurrent run-time change of the
+     * A concurrent runtime change of the
      * dynamic configuration parameters of the source (such as of its direction) may result in
      * {@code IOException} being thrown by counting operations.
      *
--- a/src/share/classes/jdk/dio/counter/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/counter/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,7 +28,7 @@
  * <p />
  * In order to access and control a specific pulse counter, an application should first open and
  * obtain an {@link jdk.dio.counter.PulseCounter} instance for the pulse counter the
- * application wants to access and control, using its numeric ID, name, type (interface) or
+ * application wants to access and control, using its numeric ID, name, type (interface) and/or
  * properties:
  * <dl>
  * <dt>Using its ID</dt>
@@ -101,5 +101,7 @@
  * 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.
+ *
+ * @since 1.0
  */
 package jdk.dio.counter;
\ No newline at end of file
--- a/src/share/classes/jdk/dio/dac/DACChannel.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/dac/DACChannel.java	Thu Sep 11 13:40:27 2014 -0400
@@ -56,7 +56,7 @@
  * <p />
  * Once opened, an application can write an output value to a DAC channel by calling the
  * {@link #generate(int) generate(int)} method or can write a series of output values to be
- * converted over a period by calling the {@link #generate(IntBuffer) generate(IntBuffer)}
+ * converted over a period of time by calling the {@link #generate(IntBuffer) generate(IntBuffer)}
  * method.
  * <p />
  * An application can also asynchronously write a series of output values (samples) to be converted
@@ -76,6 +76,7 @@
  * deterministic/timely manner.
  *
  * @see GenerationRoundListener
+ * @since 1.0
  */
 public interface DACChannel extends Device<DACChannel>, BufferAccess<IntBuffer> {
 
@@ -216,7 +217,7 @@
      * @throws IOException
      *             if some other I/O error occurs.
      * @throws IllegalArgumentException
-     *             if the provided raw value is not between the range defined by
+     *             if the provided raw value is not within the range defined by
      *             {@link #getMinValue getMinValue} and {@link #getMaxValue getMaxValue}.
      * @throws UnavailableDeviceException
      *             if this device is not currently available - such as it is locked by another
@@ -255,7 +256,7 @@
      * Only one output generation (synchronous or asynchronous) can be going on at any time.
      * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the
-     * designated raw values is not between the range defined by {@link #getMinValue getMinValue}
+     * designated raw values is not within the range defined by {@link #getMinValue getMinValue}
      * and {@link #getMaxValue getMaxValue}. If a value is not within range the actual analog value
      * output by the DAC device is hardware- or driver-specific: the output value may for example be
      * equal to the maximum output value or it may correspond to the raw value where the most
@@ -303,7 +304,7 @@
      * interval as returned by {@link #getSamplingInterval getSamplingInterval}.
      * <p />
      * 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
+     * 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.
@@ -313,8 +314,11 @@
      * <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.
+     * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the
-     * designated raw values is not between the range defined by {@link #getMinValue getMinValue}
+     * designated raw values is not within the range defined by {@link #getMinValue getMinValue}
      * and {@link #getMaxValue getMaxValue}. If a value is not within range the actual analog value
      * output by the DAC device is hardware- or driver-specific: the output value may for example be
      * equal to the maximum output value or it may correspond to the raw value where the most
@@ -352,15 +356,18 @@
      * will only be suspended if the previous event has not yet been handled.
      * <p />
      * 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
+     * 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 />
      * 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.
+     * <p />
      * This method does not throw an {@link IllegalArgumentException} if any of the
-     * designated raw values is not between the range defined by {@link #getMinValue getMinValue}
+     * designated raw values is not within the range defined by {@link #getMinValue getMinValue}
      * and {@link #getMaxValue getMaxValue}. If a value is not within range the actual analog value
      * output by the DAC device is hardware- or driver-specific: the output value may for example be
      * equal to the maximum output value or it may correspond to the raw value where the most
--- a/src/share/classes/jdk/dio/dac/DACChannelConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/dac/DACChannelConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -49,6 +49,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class DACChannelConfig implements DeviceConfig<DACChannel>, DeviceConfig.HardwareAddressing  {
--- a/src/share/classes/jdk/dio/dac/DACPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/dac/DACPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -55,6 +55,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class DACPermission extends DevicePermission {
 
@@ -79,7 +80,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}
      *            .
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/dac/GenerationRoundListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/dac/GenerationRoundListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -41,6 +41,7 @@
  * method.
  *
  * @see DACChannel#startGeneration DACChannel.startGeneration
+ * @since 1.0
  */
 public interface GenerationRoundListener extends OutputRoundListener<DACChannel, IntBuffer> {
 
--- a/src/share/classes/jdk/dio/dac/InvalidOutputSamplingRateException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/dac/InvalidOutputSamplingRateException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by an instance of {@link DACChannel} in case the requested sampling rate is higher than
  * the maximum sampling rate the DAC device can support.
+ *
+ * @since 1.0
  */
 public class InvalidOutputSamplingRateException extends RuntimeException {
 
--- a/src/share/classes/jdk/dio/dac/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/dac/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -30,7 +30,7 @@
  * <p />
  * In order to access and control a specific DAC channel, an application should first open and obtain an
  * {@link jdk.dio.dac.DACChannel DACChannel} instance for the DAC channel the application wants to
- * access and control, using its numeric ID, name, type (interface) or properties, or both:
+ * access and control, using its numeric ID, name, type (interface) and/or properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd>
@@ -124,5 +124,7 @@
  * <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.
+ *
+ * @since 1.0
  */
 package jdk.dio.dac;
--- a/src/share/classes/jdk/dio/generic/GenericBufferIODevice.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericBufferIODevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -40,6 +40,7 @@
  * for which there exist no other more specific API such as
  * {@link jdk.dio.spibus.SPIDevice} or
  * {@link jdk.dio.i2cbus.I2CDevice}.
+ * @since 1.0
  */
 public interface GenericBufferIODevice extends GenericDevice, ByteChannel, BufferAccess<ByteBuffer> {
 
@@ -47,11 +48,13 @@
      * Reads a sequence of bytes from this device into the given buffer.
      * <p />
      * The availability of new input data may be notified through an {@link GenericEvent}
-     * with ID {@link GenericEvent#INPUT_DATA_AVAILABLE}. {@inheritDoc }
+     * with ID {@link GenericEvent#INPUT_DATA_AVAILABLE}.
+     * <p />
+     * {@inheritDoc }
      *
      * @param dst
      *            The buffer into which bytes are to be transferred.
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached
      *         end-of-stream
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -78,7 +81,7 @@
      *            {@code dst} buffer.
      * @param dst
      *            The buffer into which bytes are to be transferred.
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached
      *         end-of-stream
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -98,11 +101,13 @@
      * Writes a sequence of bytes to this device from the given buffer.
      * <p />
      * An empty output buffer condition may be notified through an {@link GenericEvent}
-     * with ID {@link GenericEvent#OUTPUT_BUFFER_EMPTY}. {@inheritDoc}
+     * with ID {@link GenericEvent#OUTPUT_BUFFER_EMPTY}.
+     * <p />
+     * {@inheritDoc}
      *
      * @param src
      *            The buffer from which bytes are to be retrieved.
-     * @return The number of bytes written, possibly zero.
+     * @return The number of bytes written from {@code src}, possibly zero.
      * @throws NullPointerException
      *             If {@code src} is {@code null}.
      * @throws UnavailableDeviceException
--- a/src/share/classes/jdk/dio/generic/GenericDevice.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericDevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -45,8 +45,8 @@
  * An application can set and get configuration and access (I/O) controls. A control is identified
  * by a {@link GenericDeviceControl} instance and can be set or gotten using the
  * {@link #setControl setControl} and
- * {@link #getControl getControl} methods. Controls are intended for
- * configuring a device as well as performing basic I/O operations. The
+ * {@link #getControl getControl} methods. Controls can
+ * be used to configured a device a well as performing basic input/output operations. The
  * list of controls supported by a device is device-specific.
  * <p />
  * An application can also register an {@link GenericEventListener} instance to monitor native
@@ -65,6 +65,7 @@
  * @see GenericEventListener
  * @see GenericDeviceControl
  * @see GenericPermission
+ * @since 1.0
  */
 public interface GenericDevice extends Device<GenericDevice> {
 
--- a/src/share/classes/jdk/dio/generic/GenericDeviceConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericDeviceConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -36,8 +36,8 @@
 /**
  * The {@code GenericDeviceConfig} class encapsulates the hardware addressing information of generic
  * device.
- * <p />
- * It does not encapsulates static or dynamic configuration parameters; and that
+ * <br />
+ * It does not encapsulates static or dynamic configuration parameters;
  * configuration parameters should be set using the {@link GenericDevice#setControl
  * GenericDevice.setControl} method.
  * <p />
@@ -49,6 +49,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class GenericDeviceConfig implements DeviceConfig<GenericDevice>, DeviceConfig.HardwareAddressing {
--- a/src/share/classes/jdk/dio/generic/GenericDeviceControl.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericDeviceControl.java	Thu Sep 11 13:40:27 2014 -0400
@@ -29,14 +29,15 @@
  * 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 are intended for configuring a generic device
- * as well as performing basic I/O operations. The list of controls supported by a
+ * GenericDevice.getControl} methods. Controls can be used to configure a generic device
+ * a well as performing basic input/output operations. The list of controls supported by a
  * device is device-specific.
  *
  * @param <T>
  *            the type of the control's value.
  * @see GenericDevice#getControl GenericDevice.getControl
  * @see GenericDevice#setControl GenericDevice.setControl
+ * @since 1.0
  */
 public class GenericDeviceControl<T> {
     private int id = -1;
--- a/src/share/classes/jdk/dio/generic/GenericEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -33,6 +33,7 @@
  *
  * @see GenericDevice
  * @see GenericEventListener
+ * @since 1.0
  */
 public class GenericEvent extends DeviceEvent<GenericDevice> {
 
--- a/src/share/classes/jdk/dio/generic/GenericEventListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericEventListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  *
  * @see GenericDevice
  * @see GenericEvent
+ * @since 1.0
  */
 public interface GenericEventListener extends DeviceEventListener {
 
--- a/src/share/classes/jdk/dio/generic/GenericPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/GenericPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -55,6 +55,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class GenericPermission extends DevicePermission {
 
@@ -79,7 +80,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}
      *            .
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/generic/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/generic/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -43,7 +43,7 @@
  * </dl>
  * In order to access a device using its generic interface, an application should first open and
  * obtain a {@link jdk.dio.generic.GenericDevice} instance for the device using its
- * numeric ID, name, type (interface) or properties, or both:
+ * numeric ID, name, type (interface) and/or properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd><blockquote>
@@ -114,8 +114,8 @@
  *     }
  * }
  * </pre>
- * </blockquote> The preceding example is using a <em>try-with-resources</em> statement
- * and that 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>
@@ -154,6 +154,8 @@
  * 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.
+ *
+ * @since 1.0
  */
 package jdk.dio.generic;
 
--- a/src/share/classes/jdk/dio/gpio/GPIOPin.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/GPIOPin.java	Thu Sep 11 13:40:27 2014 -0400
@@ -69,14 +69,15 @@
  * always initially set the GPIO pin's direction; or first query the GPIO pin's direction then set
  * it if necessary.
  * <p />
- * The configuration may allow for some GPIO pins to be set by the application for either
+ * The underlying platform configuration may allow for some GPIO pins to be set by an application for either
  * output or input while others may be used for input only or output only and their direction cannot
- * be changed by the application. Note also that asynchronous notification of pin value changes is
+ * be changed by the application. Asynchronous notification of pin value changes is
  * only loosely tied to hardware-level interrupt requests. The platform does not guarantee
  * notification in a deterministic/timely manner.
  *
  * @see PinListener
  * @see GPIOPinPermission
+ * @since 1.0
  */
 public interface GPIOPin extends Device<GPIOPin> {
 
--- a/src/share/classes/jdk/dio/gpio/GPIOPinConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/GPIOPinConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -48,6 +48,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class GPIOPinConfig implements  DeviceConfig<GPIOPin>, DeviceConfig.HardwareAddressing {
--- a/src/share/classes/jdk/dio/gpio/GPIOPinPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/GPIOPinPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -59,6 +59,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class GPIOPinPermission extends DevicePermission {
 
--- a/src/share/classes/jdk/dio/gpio/GPIOPort.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/GPIOPort.java	Thu Sep 11 13:40:27 2014 -0400
@@ -36,9 +36,9 @@
  * <p />
  * Each GPIO port is identified by a numeric ID and optionally by a name.
  * <p />
- * A GPIO port is a platform-defined grouping of GPIO pins that may be configured for output or
+ * A GPIO port is a platform-defined or an ad-hoc grouping of GPIO pins that may be configured for output or
  * input. Output ports are both writable and readable while input ports are only readable.
- * Whether GPIO pins that are part of a GPIO port can be retrieved and controlled individually as
+ * Whether GPIO pins that are part of a platform-defined GPIO port can be retrieved and controlled individually as
  * {@link GPIOPin} instances depends on the hardware and platform configuration (and especially
  * whether the GPIO pins can be shared through different abstractions).
  * <p />
@@ -78,14 +78,15 @@
  * always initially set the GPIO port's direction; or first query the GPIO port's direction then set
  * it if necessary.
  * <p />
- * The configuration may allow for some GPIO ports to be set by an application for either
+ * The underlying platform configuration may allow for some GPIO ports to be set by an application for either
  * output or input while others may be used for input only or output only and their direction cannot
- * be changed by an application. Note also that asynchronous notification of port value changes is
+ * be changed by an application. Asynchronous notification of port value changes is
  * only loosely tied to hardware-level interrupt requests. The platform does not guarantee
  * notification in a deterministic/timely manner.
  *
  * @see PortListener
  * @see GPIOPortPermission
+ * @since 1.0
  */
 public interface GPIOPort extends Device<GPIOPort> {
 
@@ -175,8 +176,8 @@
 
     /**
      * Registers a {@link PortListener} instance which will get asynchronously notified when this
-     * GPIO port's value changes. Notification will automatically begin after registration
-     * completes.
+     * GPIO port's value changes and according to its trigger mode.
+     * Notification will automatically begin after registration completes.
      * <p />
      * A listener can only be registered for a GPIO port currently configured for input.
      * <p />
--- a/src/share/classes/jdk/dio/gpio/GPIOPortConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/GPIOPortConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -46,11 +46,14 @@
  * with the specified configuration. A {@link InvalidDeviceConfigException} is thrown when
  * attempting to open a device with an invalid or unsupported configuration.
  * <p />
- * The interrupt trigger of a GPIO port is defined by the interrupt trigger(s) configured
- * for its pins (see {@link GPIOPinConfig#getTrigger GPIOPinConfig.getTrigger}).
+ * The value change notification trigger of a GPIO port is defined by the interrupt trigger(s) configured
+ * for its pins (see {@link GPIOPinConfig#getTrigger GPIOPinConfig.getTrigger}). Any of
+ * the {@code GPIOPin}s configured with an interrupt trigger (other than {@link GPIOPinConfig#TRIGGER_NONE})
+ * that compose a {@code GPIOPort} may trigger a notification for that {@code GPIOPort}.
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class GPIOPortConfig implements DeviceConfig<GPIOPort> {
@@ -185,12 +188,13 @@
     /**
      * Gets the pins composing the port (in the exact same order they compose the port).
      * <p />
-     * A concurrent run-time 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 {@code GPIOPort} instance.
+     * 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.
      */
     public GPIOPin[] getPins() {
         if (pins != null) {
--- a/src/share/classes/jdk/dio/gpio/GPIOPortPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/GPIOPortPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -57,6 +57,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class GPIOPortPermission extends DevicePermission {
 
@@ -86,7 +87,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open}, {@code powermanage}
+     *            comma-separated list of device operations: {@code open}, {@code powermanage}
      *            or {@code setdirection}.
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/gpio/PinEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/PinEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -33,6 +33,7 @@
  *
  * @see GPIOPin
  * @see PinListener
+ * @since 1.0
  */
 public class PinEvent extends DeviceEvent<GPIOPin> {
 
--- a/src/share/classes/jdk/dio/gpio/PinListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/PinListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -33,6 +33,7 @@
  * GPIOPin.setInputListener} method.
  *
  * @see GPIOPin
+ * @since 1.0
  */
 public interface PinListener extends DeviceEventListener {
 
--- a/src/share/classes/jdk/dio/gpio/PortEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/PortEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -33,6 +33,7 @@
  *
  * @see GPIOPort
  * @see PortListener
+ * @since 1.0
  */
 public class PortEvent extends DeviceEvent<GPIOPort> {
 
--- a/src/share/classes/jdk/dio/gpio/PortListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/PortListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -32,6 +32,7 @@
  * GPIOPort.setInputListener} method.
  *
  * @see GPIOPort
+ * @since 1.0
  */
 public interface PortListener {
 
--- a/src/share/classes/jdk/dio/gpio/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/gpio/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -27,14 +27,15 @@
  * Interfaces and classes for reading and writing from/to GPIO (General Purpose Input Output) pins
  * and ports of the device.
  * <p/>
- * A GPIO port is a platform-defined grouping of GPIO pins that may be configured for output or
- * input. GPIO pins that are part of a GPIO port cannot be retrieved nor controlled
- * individually as {@link jdk.dio.gpio.GPIOPin} instances.
+ * A GPIO port is a platform-defined or an ad-hoc grouping of GPIO pins that may be configured for output or
+ * input. Whether GPIO pins that are part of a platform-defined GPIO port can be retrieved and controlled individually as
+ * {@code GPIOPin} instances depends on the hardware and platform configuration (and especially
+ * whether the GPIO pins can be shared through different abstractions).
  * <p/>
  * In order to use a specific pin or port, an application should first open and obtain and obtain a
  * {@link jdk.dio.gpio.GPIOPin} instance or
  * {@link jdk.dio.gpio.GPIOPort} instance, respectively, for the pin or port it
- * wants to use using its numeric ID, name, type (interface) or properties, or both:
+ * wants to use using its numeric ID, name, type (interface) and/or properties:
  * <ul>
  * <li>Using its ID <blockquote>
  *
@@ -93,13 +94,13 @@
  *     // handle exception
  * }
  * </pre>
- * </blockquote> The preceding example is using a <em>try-with-resources</em> statement
- * and that 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
  * by an application for either output or input while others may be used for input only or output
- * only and that their direction cannot be changed by an application. Note also that asynchronous
+ * only and their direction can not be changed by an application. The asynchronous
  * notification of pin or port value changes is only loosely tied to hardware-level interrupt
  * requests. The platform does not guarantee notification in a deterministic/timely manner.
  * <p/>
@@ -109,6 +110,8 @@
  * 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.
+ *
+ * @since 1.0
  */
 package jdk.dio.gpio;
 
--- a/src/share/classes/jdk/dio/i2cbus/I2CCombinedMessage.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/i2cbus/I2CCombinedMessage.java	Thu Sep 11 13:40:27 2014 -0400
@@ -32,8 +32,8 @@
 
 /**
  * The {@code I2CCombinedMessage} interface provides methods for constructing a
- * combined message. A combined message may be constituted of at least two reads,
- * or writes to one or more I2C slaves, or both. A combined message starts with a
+ * combined message. A combined message may be constituted of at least two reads
+ * and/or writes to one or more I2C slaves. A combined message starts with a
  * START bit and ends with a STOP bit. But each of read and write messages
  * constituting the combined message following the very first of these messages
  * starts with a REPEATED START bit (one that is not preceded by a STOP bit).
@@ -55,7 +55,7 @@
  * }
  * </pre>
  * </blockquote> The preceding example is using a
- * <em>try-with-resources</em> statement and that the
+ * <em>try-with-resources</em> statement. The
  * {@link I2CDevice#close I2CDevice.close} method is automatically invoked by
  * the platform at the end of the statement.
  * <p />
@@ -65,7 +65,8 @@
  * {@link I2CDevice#write(ByteBuffer) I2CDevice.write}, {@link I2CDevice#read(int, int, ByteBuffer)
  * I2CDevice.read(subaddress,...)} {@link I2CDevice#write(int, int, ByteBuffer)
  * I2CDevice.write(subaddress,...)} methods for that purpose.
- * <p>
+ *
+ * @since 1.0
  */
 public interface I2CCombinedMessage {
 
@@ -73,6 +74,13 @@
      * Appends a read message/operation from the provided I2C slave device.
      * Reads up to {@code rwBuf.remaining()} bytes of data from this slave
      * device into the buffer {@code rxBuf}.
+     * <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 has completed - that
+     * is: until the {@link #transfer() transfer} method has been invoked and has returned.
+     * <p />
+     * The appended operation will have a behavior equivalent to that of the
+     * {@link I2CDevice#read(java.nio.ByteBuffer)} method.
      *
      * @param slave the I2C slave device to read from.
      * @param rxBuf the buffer into which the data is read.
@@ -92,6 +100,13 @@
      * Reads up to {@code rwBuf.remaining()} bytes of data from this slave
      * device into the buffer skipping {@code rxBuf} the first {@code rxSkip}
      * bytes read.
+     * <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 has completed - that
+     * is: until the {@link #transfer() transfer} method has been invoked and has returned.
+     * <p />
+     * The appended operation will have a behavior equivalent to that of the
+     * {@link I2CDevice#read(int, java.nio.ByteBuffer)} method.
      *
      * @param slave the I2C slave device to read from.
      * @param rxSkip the number of read bytes that must be ignored/skipped
@@ -113,6 +128,13 @@
      * Appends a write message/operation from the provided I2C slave device.
      * Writes to this slave device {@code txBuff.remaining()} bytes from the
      * buffer {@code txBuf}.
+     * <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 has completed - that
+     * is: until the {@link #transfer() transfer} method has been invoked and has returned.
+     * <p />
+     * The appended operation will have a behavior equivalent to that of the
+     * {@link I2CDevice#write(java.nio.ByteBuffer)} method.
      *
      * @param slave the I2C slave device to write to.
      * @param txBuf the buffer containing the bytes to write.
@@ -133,10 +155,17 @@
      * contained messages/operations to be sent/executed in the same order they
      * have been appended to this combined message.
      * <p />
-     * Once transfer no additional operation can be appended anymore to this
+     * 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. <br />
-     * This combined message can be transferred several times.
+     * {@link IllegalStateException} to be thrown.
+     * <p />
+     * This combined message can be transferred several times. The data transferred
+     * to or from each of the provided {@code ByteBuffer}s is determined by its current {@code position}
+     * and {@code remaining} attributes at the time this method is call.
+     * The caller is responsible for preparing the buffers between each transfer.
+     * <br />
+     * Buffers are not safe for use by multiple concurrent threads so care should
+     * be taken to not access the provided buffers until the transfer has completed.
      *
      * @return an array containing the number of bytes read for each of the read
      * operations of this combined message; the results of each read operations
--- a/src/share/classes/jdk/dio/i2cbus/I2CDevice.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/i2cbus/I2CDevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -59,7 +59,7 @@
  * The I2C master writes data to an I2C slave device. An application can write to an I2C slave
  * device using one of the {@link #write write} methods.</dd>
  * <dt><b>Combined Messages Messages</b></dt>
- * <dd>The I2C master issues at least two reads or writes, or both to one or more slaves.
+ * <dd>The I2C master issues at least two reads and/or writes to one or more slaves.
  * <dl>
  * <dt><b>To a single slave</b></dt>
  * <dd>An application can explicitly start a combined message using {@link #begin begin}, issues
@@ -90,8 +90,8 @@
  * }
  * </pre>
  * </blockquote></dd>
- * <dt><b>To several salves</b></dt>
- * <dd>An application can issue several reads or writes, or both to several slaves using a
+ * <dt><b>To several slaves</b></dt>
+ * <dd>An application can issue several reads and/or writes to several slaves using a
  * {@link I2CCombinedMessage} object.</dd>
  * </dl>
  * </dd>
@@ -106,12 +106,14 @@
  *
  * @see I2CPermission
  * @see ClosedDeviceException
+ * @since 1.0
  */
 public interface I2CDevice extends Device<I2CDevice>, ByteChannel, Transactional, BufferAccess<ByteBuffer> {
 
     /**
      * The {@code Bus} interface is a simplified abstraction of an I2C bus
      * providing methods for creating combined messages.
+     * @since 1.0
      */
     public interface Bus {
 
@@ -192,7 +194,7 @@
      *
      * @param dst
      *            The buffer into which bytes are to be transferred
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached
      *         end-of-stream
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -219,15 +221,17 @@
      *            {@code dst} buffer.
      * @param dst
      *            The buffer into which bytes are to be transferred
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached
      *         end-of-stream
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
+     * @throws IllegalArgumentException
+     *              If {@code skip} is negative.
      * @throws UnavailableDeviceException
-     *             if this device is not currently available - such as it is locked by another
+     *             If this device is not currently available - such as it is locked by another
      *             application.
      * @throws ClosedDeviceException
-     *             if the device has been closed.
+     *             If the device has been closed.
      * @throws IOException
      *             If some other I/O error occurs
      */
@@ -260,7 +264,7 @@
      *            the slave device's subaddress or register address size (1-4 bytes).
      * @param dst
      *            The buffer into which bytes are to be transferred
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached
      *         end-of-stream
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -308,7 +312,7 @@
      *            {@code dst} buffer.
      * @param dst
      *            The buffer into which bytes are to be transferred
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached
      *         end-of-stream
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -320,7 +324,7 @@
      * @throws IOException
      *             If some other I/O error occurs
      * @throws IllegalArgumentException
-     *             if {@code subaddress} is negative or {@code subaddressSize} is not between
+     *             if {@code skip} or {@code subaddress} is negative or {@code subaddressSize} is not between
      *             {@code 1} and {@code 4}.
      */
     int read(int subaddress, int subaddressSize, int skip, ByteBuffer dst) throws IOException,
@@ -333,7 +337,7 @@
      *
      * @param src
      *            The buffer from which bytes are to be retrieved
-     * @return The number of bytes written, possibly zero
+     * @return The number of bytes written from {@code src}, possibly zero
      * @throws NullPointerException
      *             If {@code src} is {@code null}.
      * @throws UnavailableDeviceException
@@ -390,7 +394,7 @@
      *            the slave device's subaddress or register address size (1-4 bytes).
      * @param src
      *            The buffer from which bytes are to be retrieved
-     * @return The number of bytes written, possibly zero
+     * @return The number of bytes written from {@code src}, possibly zero
      * @throws NullPointerException
      *             If {@code src} is {@code null}.
      * @throws UnavailableDeviceException
--- a/src/share/classes/jdk/dio/i2cbus/I2CDeviceConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/i2cbus/I2CDeviceConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -48,6 +48,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class I2CDeviceConfig implements DeviceConfig<I2CDevice>, DeviceConfig.HardwareAddressing {
--- a/src/share/classes/jdk/dio/i2cbus/I2CPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/i2cbus/I2CPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -57,6 +57,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 public class I2CPermission extends DevicePermission {
 
@@ -81,7 +82,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}
      *            .
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
--- a/src/share/classes/jdk/dio/i2cbus/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/i2cbus/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -30,8 +30,8 @@
  * <p />
  * In order to communicate with a specific slave device, an application should first open and obtain
  * an {@link jdk.dio.i2cbus.I2CDevice} instance for the I2C slave device the
- * application wants to exchange data with, using its numeric ID, name, type (interface) or
- * properties, or both:
+ * application wants to exchange data with, using its numeric ID, name, type (interface) and/or
+ * properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd><blockquote>
@@ -108,8 +108,8 @@
  *     }
  * }
  * </pre>
- * </blockquote> The preceding examples are using a <em>try-with-resources</em> statement
- * and that the {@link jdk.dio.i2cbus.I2CDevice#close I2CDevice.close} method is
+ * </blockquote> The preceding examples are using a <em>try-with-resources</em> statement;
+ * the {@link jdk.dio.i2cbus.I2CDevice#close I2CDevice.close} method is
  * automatically invoked by the platform at the end of the statement.
  * <p />
  * Information about the I2C-bus specification can be found at <a
@@ -119,6 +119,8 @@
  * 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.
+ *
+ * @since 1.0
  */
 package jdk.dio.i2cbus;
 
--- a/src/share/classes/jdk/dio/modem/ModemSignalEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/modem/ModemSignalEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -37,6 +37,7 @@
  *
  * @see ModemSignalListener
  * @see ModemSignalsControl
+ * @since 1.0
  */
 public class ModemSignalEvent<P extends Device<? super P>> extends DeviceEvent<P> {
     /**
--- a/src/share/classes/jdk/dio/modem/ModemSignalListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/modem/ModemSignalListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -38,6 +38,7 @@
  *
  * @param <P>
  *            the device type the listener is defined for.
+ * @since 1.0
  */
 public interface ModemSignalListener<P extends Device<? super P>> extends DeviceEventListener {
 
--- a/src/share/classes/jdk/dio/modem/ModemSignalsControl.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/modem/ModemSignalsControl.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  *
  * @param <P>
  *            the device type implementing this interface.
+ * @since 1.0
  */
 public interface ModemSignalsControl<P extends Device<? super P>> {
 
--- a/src/share/classes/jdk/dio/modem/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/modem/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
  * <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.
+ *
+ * @since 1.0
  */
 package jdk.dio.modem;
 
--- a/src/share/classes/jdk/dio/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -32,5 +32,7 @@
  * 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.
+ *
+ * @since 1.0
  */
 package jdk.dio;
\ No newline at end of file
--- a/src/share/classes/jdk/dio/power/PowerManaged.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/power/PowerManaged.java	Thu Sep 11 13:40:27 2014 -0400
@@ -42,11 +42,11 @@
  * A power state change may be dictated by the power management facility of the device or it may be requested by the
  * power management facility on behalf of the application itself or of another application (see
  * {@link #requestPowerStateChange requestPowerStateChange}). A power state change for a specific device may be requested
- * by another application if the device or some underlying device hardware resources are
+ * by another application if the device or some of the underlying device hardware resources are
  * shared. This is, for example, the case on a {@link GPIOPin} instance: another application may have opened a different
  * GPIO pin controlled by the same GPIO controller; the application will get notified of any power state changes
- * requested by the other application. Devices currently open by an application whose power management
- * is logically or physically dependent belong to the same power management group (see {@link Group}).
+ * requested by the other application. Devices currently open by an application whose power managements
+ * are logically or physically dependent belong to the same power management group (see {@link Group}).
  * <p />
  * An application may register to get notified of power state changes. When notified, the application may take the
  * following actions:
@@ -75,7 +75,7 @@
  * its state/configuration may result in unexpected behavior. Therefore an application should always either:
  * <ol>
  * <li>register for power state changes on the devices it uses</li>
- * <li>or, register for systemwide power state changes (if supported by the platform) and close the devices when
+ * <li>or, register for system-wide power state changes (if supported by the platform) and close the devices when
  * going to power saving modes that may not preserve the device state/context and then open again the devices
  * when returning from such power saving modes.</li>
  * </ol>
@@ -116,6 +116,7 @@
  * <p />
  *
  * @see PowerSavingHandler
+ * @since 1.0
  */
 public interface PowerManaged {
     /*
@@ -124,7 +125,7 @@
      */
 
     /*
-     * Note: the power sates below are freely adapted from the Device Power Sates defined by the Device power management
+     * Note: the power states below are freely adapted from the Device Power Sates defined by the Device power management
      * in the ACPI spec (http://www.acpi.info/DOWNLOADS/ACPIspec30a.pdf).
      */
 
@@ -332,9 +333,9 @@
 
     /**
      * The {@code Group} interface provides methods for registering for power state changes of devices belonging
-     * to the same power management group. Devices currently open by an application belong to the same power management group when their power management
-     * is logically or physically dependent. For example, different GPIO pins may be controlled by the same GPIO controller
-     * and their power management is physically dependent: when a power state change is requested on one pin it results in
+     * to the same power management group. Devices currently open by an application belong to the same power management group when their power managements
+     * are logically or physically dependent. For example, different GPIO pins may be controlled by the same GPIO controller
+     * and their power managements are physically dependent: when a power state change is requested on one pin it results in
      * applications that have open any of the other pins to be notified of that power state change request, including
      * the requesting application. Registering for power state change request notifications on a power management group
      * rather than on individual devices belonging to that group allows for being notified only once for each
@@ -349,6 +350,8 @@
      * power state changes are no longer notified on that {@code Group}.
      * <p />
      * A compliant implementation MUST guarantee the thread-safety of {@code Group} instances.
+     *
+     * @since 1.0
      */
     public interface Group {
 
--- a/src/share/classes/jdk/dio/power/PowerSavingHandler.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/power/PowerSavingHandler.java	Thu Sep 11 13:40:27 2014 -0400
@@ -45,6 +45,7 @@
  * or failing power saving handler invocations.
  *
  * @see PowerManaged
+ * @since 1.0
  */
 public interface PowerSavingHandler {
 
@@ -59,7 +60,7 @@
      * will use the designated device earlier than the specified duration.
      * <p />
      * Since a transition to the {@link PowerManaged#POWER_ON} state can never be vetoed such as to not deny device
-     * access to other applications this method is never invoked before a transition to the
+     * access to other applications this method is never invoked prior to a transition to the
      * {@link PowerManaged#POWER_ON} state.
      * <p />
      * Once this method has been called on all the {@code PowerSavingHandler}s registered for the device the
--- a/src/share/classes/jdk/dio/power/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/power/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -84,5 +84,7 @@
  * <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.
+ *
+ * @since 1.0
  */
 package jdk.dio.power;
\ No newline at end of file
--- a/src/share/classes/jdk/dio/pwm/GenerationEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/GenerationEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -34,6 +34,7 @@
  *
  * @see PWMChannel
  * @see GenerationListener
+ * @since 1.0
  */
 public class GenerationEvent extends DeviceEvent<PWMChannel> {
 
--- a/src/share/classes/jdk/dio/pwm/GenerationListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/GenerationListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -35,6 +35,7 @@
  * one of the {@link PWMChannel#startGeneration} methods.
  *
  * @see PWMChannel#startGeneration(int, int, GenerationListener)
+ * @since 1.0
  */
 public interface GenerationListener extends DeviceEventListener, AsyncErrorHandler<PWMChannel> {
 
@@ -43,7 +44,7 @@
      * <p />
      * The corresponding pulse generation operation being completed another <em>asynchronous</em> pulse generation
      * operation may be started from within this method (see {@link PWMChannel#startGeneration}. This may be used to
-     * generate a subsequent pulse train with different specifications: pulse period or width/duty cycle, or both.
+     * generate a subsequent pulse train with different specifications: pulse period and/or width/duty cycle.
      *
      * @param event
      *            the event that occurred.
--- a/src/share/classes/jdk/dio/pwm/GenerationRoundListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/GenerationRoundListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -39,6 +39,7 @@
  * {@link PWMChannel#startGeneration PWMChannel.startGeneration} methods.
  *
  * @see PWMChannel#startGeneration PWMChannel.startGeneration
+ * @since 1.0
  */
 public interface GenerationRoundListener extends OutputRoundListener<PWMChannel, IntBuffer> {
 
--- a/src/share/classes/jdk/dio/pwm/InvalidPulseRateException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/InvalidPulseRateException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by an instance of {@link PWMChannel} in case the requested pulse rate/frequency is higher than the maximum
  * rate/frequency the PWM device can support.
+ *
+ * @since 1.0
  */
 @SuppressWarnings("serial")
 public class InvalidPulseRateException extends RuntimeException {
--- a/src/share/classes/jdk/dio/pwm/PWMChannel.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/PWMChannel.java	Thu Sep 11 13:40:27 2014 -0400
@@ -64,11 +64,12 @@
  * 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} and that 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
  * @see PWMPermission
+ * @since 1.0
  */
 public interface PWMChannel extends Device<PWMChannel>, BufferAccess<IntBuffer> {
 
@@ -219,7 +220,7 @@
      * <p />
      * The pulses will be generated according to the current pulse period as returned by {@link #getPulsePeriod getPulsePeriod}.
      * <p/>
-     * Pulse generation will immediately start and proceed asynchronously. It may be stopped before completion by a
+     * Pulse generation will immediately start and proceed asynchronously. It may be stopped prior to completion by a
      * call to {@link #stopGeneration stopGeneration}.
      * <p />
      * Only one pulse generation session can be going on at any time.
@@ -249,7 +250,7 @@
      * <p />
      * The pulses will be generated according to the current pulse period as returned by {@link #getPulsePeriod getPulsePeriod}.
      * <p/>
-     * Pulse generation will immediately start and proceed asynchronously. It may be stopped before completion by a
+     * Pulse generation will immediately start and proceed asynchronously. It may be stopped prior to completion by a
      * call to {@link #stopGeneration stopGeneration}.
      * <p />
      * Only one pulse generation session can be going on at any time.
@@ -304,7 +305,7 @@
      * pulse period can be changed by the provided {@link GenerationRoundListener} instance upon notification of each
      * pulse train subsequence.
      * <p />
-     * A buffer with {@code 0} integers remaining to be written (that is a buffer already empty), at the moment this method is initially
+     * 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 />
@@ -313,6 +314,9 @@
      * <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.
+     * <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
@@ -345,12 +349,15 @@
      * 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.
      * <p />
-     * A working buffer with {@code 0} integers remaining to be written (that is a buffer already empty), at the moment this method is initially
+     * 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.
      * <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.
+     * <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
--- a/src/share/classes/jdk/dio/pwm/PWMChannelConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/PWMChannelConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -52,6 +52,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public class PWMChannelConfig implements DeviceConfig<PWMChannel>, DeviceConfig.HardwareAddressing {
@@ -307,7 +308,7 @@
     /**
      * Gets the output on which the pulses are to be generated.
      * <p />
-     * A concurrent run-time change of the
+     * A concurrent runtime change of the
      * dynamic configuration parameters of the output (such as of its direction) may result in
      * {@code IOException} being thrown by PWM operations.
      *
--- a/src/share/classes/jdk/dio/pwm/PWMPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/PWMPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -55,6 +55,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 @SuppressWarnings("serial")
 public class PWMPermission extends DevicePermission {
@@ -79,7 +80,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}.
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}.
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
      * @throws IllegalArgumentException
--- a/src/share/classes/jdk/dio/pwm/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/pwm/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,7 +28,7 @@
  * <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
- * access and control, using its numeric ID, name, type (interface), or properties:
+ * access and control, using its numeric ID, name, type (interface) and/or properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd>
@@ -113,5 +113,7 @@
  * <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.
+ *
+ * @since 1.0
  */
 package jdk.dio.pwm;
\ No newline at end of file
--- a/src/share/classes/jdk/dio/spi/AbstractDevice.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spi/AbstractDevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -40,6 +40,7 @@
  * allow for retrieving the {@link DeviceDescriptor} of {@code Device} instances.
  *
  * @param <P> the device type the descriptor is defined for.
+ * @since 1.0
  */
 public abstract class AbstractDevice<P extends Device<? super P>> implements Device<P> {
 
--- a/src/share/classes/jdk/dio/spi/DeviceProvider.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spi/DeviceProvider.java	Thu Sep 11 13:40:27 2014 -0400
@@ -51,8 +51,8 @@
  * <dd>
  * <ol>
  * <li>check that the {@code DeviceProvider} is of the proper <i>type</i> by first invoking its {@link #getType()
- * getType} method, or is supporting the proper <i>configuration type</i> by invoking its {@link #getConfigType()
- * getConfigType} method, or both</li>
+ * getType} method and/or is supporting the proper <i>configuration type</i> by invoking its {@link #getConfigType()
+ * getConfigType} method</li>
  * <li>check if the {@code DeviceProvider} can open a {@link Device} instance with the specified
  * <i>properties</i> by invoking the {@link #matches(java.lang.String[]) matches}
  * method,</li>
@@ -86,6 +86,7 @@
  * @see jdk.dio.DeviceManager#open(java.lang.Class, jdk.dio.DeviceConfig)
  * @see jdk.dio.DeviceManager#open(java.lang.Class, jdk.dio.DeviceConfig, int)
  * @see jdk.dio.DeviceManager#register DeviceManager.register
+ * @since 1.0
  */
 public interface DeviceProvider<P extends Device<? super P>> {
 
--- a/src/share/classes/jdk/dio/spi/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spi/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -30,5 +30,7 @@
  * <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.
+ *
+ * @since 1.0
  */
 package jdk.dio.spi;
\ No newline at end of file
--- a/src/share/classes/jdk/dio/spibus/InvalidWordLengthException.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spibus/InvalidWordLengthException.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,6 +28,8 @@
 /**
  * Thrown by an instance of {@link SPIDevice} in case of mismatch between the length of data to be exchanged and the
  * slave's word length as indicated by {@link SPIDevice#getWordLength SPIDevice.getWordLength}.
+ *
+ * @since 1.0
  */
 @SuppressWarnings("serial")
 public class InvalidWordLengthException extends RuntimeException {
--- a/src/share/classes/jdk/dio/spibus/SPIDevice.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spibus/SPIDevice.java	Thu Sep 11 13:40:27 2014 -0400
@@ -70,7 +70,7 @@
  * buffer must be such that: <br />
  * <em>((l % (((w - 1) / 8) + 1)) == 0)</em>
  * <p />
- * Since the SPI master device controls the serial transmission clock read and write operations are nonblocking
+ * Since the SPI master device controls the serial transmission clock read and write operations are non-blocking
  * (unless another read or write operation is already on-going in a different thread on the same {@code SPIDevice} instance).
  * It is the responsibility of the application to appropriately control the timing between a call to the {@link #begin begin} method which
  * may assert the Chip Select (depending on the configuration, see {@link SPIDeviceConfig#CS_NOT_CONTROLLED}) and
@@ -83,6 +83,7 @@
  * @see SPIPermission
  * @see InvalidWordLengthException
  * @see ClosedDeviceException
+ * @since 1.0
  */
 public interface SPIDevice extends Device<SPIDevice>, ByteChannel, Transactional, BufferAccess<ByteBuffer> {
 
@@ -159,7 +160,7 @@
      * @param dst
      *            The buffer into which bytes are to be transferred
      *
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached end-of-stream
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached end-of-stream.
      *
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -188,10 +189,12 @@
      * @param dst
      *            The buffer into which bytes are to be transferred
      *
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached end-of-stream
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached end-of-stream.
      *
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
+     * @throws IllegalArgumentException
+     *              If {@code skip} is negative.
      * @throws InvalidWordLengthException
      *             if the total number of bytes to receive belies word length.
      * @throws UnavailableDeviceException
@@ -210,7 +213,7 @@
      *
      * @param src
      *            The buffer from which bytes are to be retrieved
-     * @return The number of bytes written, possibly zero
+     * @return The number of bytes written from {@code src}, possibly zero
      * @throws NullPointerException
      *             If {@code src} is {@code null}.
      * @throws UnavailableDeviceException
@@ -254,7 +257,7 @@
      *            The buffer from which bytes are to be retrieved
      * @param dst
      *            The buffer into which bytes are to be transferred
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached end-of-stream
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached end-of-stream.
      * @throws NullPointerException
      *             If {@code src} or {@code dst} is {@code null}.
      * @throws InvalidWordLengthException
@@ -284,9 +287,11 @@
      *            the number of received bytes that must be ignored/skipped before filling in the {@code dst} buffer.
      * @param dst
      *            The buffer into which bytes are to be transferred
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached end-of-stream
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached end-of-stream.
      * @throws NullPointerException
      *             If {@code src} or {@code dst} is {@code null}.
+     * @throws IllegalArgumentException
+     *              If {@code skip} is negative.
      * @throws InvalidWordLengthException
      *             if the total number of bytes to receive or send belies word length.
      * @throws UnavailableDeviceException
--- a/src/share/classes/jdk/dio/spibus/SPIDeviceConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spibus/SPIDeviceConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -77,6 +77,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class SPIDeviceConfig implements DeviceConfig<SPIDevice>, DeviceConfig.HardwareAddressing {
@@ -112,7 +113,7 @@
 
     /**
      * Creates a new {@code SPIDeviceConfig} with the specified hardware addressing information and configuration
-     * parameters. The Chip Select active level is platform, or driver-dependent (i.e. {@link #DEFAULT}, or both).
+     * parameters. The Chip Select active level is platform and/or driver-dependent (i.e. {@link #DEFAULT}).
      *
      * @param controllerNumber
      *            the number of the bus the slave device is connected to (a positive or zero integer) or
@@ -192,7 +193,7 @@
 
     /**
      * Creates a new {@code SPIDeviceConfig} with the specified hardware addressing information and configuration
-     * parameters. The Chip Select active level is platform, or driver-dependent (i.e. {@link #DEFAULT}, or both).
+     * parameters. The Chip Select active level is platform and/or driver-dependent (i.e. {@link #DEFAULT}).
      *
      * @param controllerName
      *            the controller name (such as its <em>device file</em> name on UNIX systems).
--- a/src/share/classes/jdk/dio/spibus/SPIPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/spibus/SPIPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -55,6 +55,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 @SuppressWarnings("serial")
 public class SPIPermission extends DevicePermission {
@@ -79,7 +80,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}.
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}.
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
      * @throws IllegalArgumentException
--- a/src/share/classes/jdk/dio/uart/ModemUART.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/ModemUART.java	Thu Sep 11 13:40:27 2014 -0400
@@ -37,6 +37,8 @@
  * always be supported. Additionally, when supported and because of latency, CTS signal state change notification may
  * only be indicative: CTS flow control may be handled directly by the hardware or by the native driver.
  *
+ *
+ * @since 1.0
  */
 public interface ModemUART extends UART, ModemSignalsControl<ModemUART> {
 }
--- a/src/share/classes/jdk/dio/uart/UART.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/UART.java	Thu Sep 11 13:40:27 2014 -0400
@@ -54,7 +54,7 @@
  * UART using methods of the {@link ByteChannel} interface.
  * <p/>
  * An application can register a {@link UARTEventListener} instance which will get asynchronously notified of input data
- * availability, input buffer overrun or empty output buffer, or both conditions. The input and output buffers for
+ * availability, input buffer overrun and/or empty output buffer conditions. The input and output buffers for
  * which these events may be notified may not necessarily correspond to the transmit and receive FIFO buffers of the
  * UART hardware but may be buffers allocated by the underlying native driver. To register a {@link UARTEventListener}
  * instance, the application must call the {@link #setEventListener setEventListener} method. The registered
@@ -65,6 +65,7 @@
  *
  * @see UARTPermission
  * @see ClosedDeviceException
+ * @since 1.0
  */
 public interface UART extends Device<UART>, ByteChannel, BufferAccess<ByteBuffer> {
 
@@ -161,8 +162,8 @@
     void setDataBits(int dataBits) throws IOException, UnavailableDeviceException, ClosedDeviceException;
 
     /**
-     * Registers a {@link UARTEventListener} instance to monitor input data availability, input buffer overrun or
-     * empty output buffer, or both conditions. While the listener can be triggered by hardware interrupts, there are no
+     * Registers a {@link UARTEventListener} instance to monitor input data availability, input buffer overrun and/or
+     * empty output buffer conditions. While the listener can be triggered by hardware interrupts, there are no
      * real-time guarantees of when the listener will be called.
      * <p />
      * A list of event type IDs is defined in {@link UARTEvent}.
@@ -192,7 +193,7 @@
      *             if the device has been closed.
      * @throws UnsupportedOperationException
      *             if this UART does not support asynchronous event notification of the requested conditions (eg. input data availability, input
-     *             buffer overrun, empty output buffer or error, or both conditions).
+     *             buffer overrun, empty output buffer and/or error conditions).
      * @throws IOException
      *             if some other I/O error occurs.
      */
@@ -267,7 +268,7 @@
      * baud rate and other configuration parameters can be changed by the provided {@link OutputRoundListener} instance
      * upon notification of each round.
      * <p />
-     * A buffer with {@code 0} bytes remaining to be written (that is a buffer already empty), at the moment this method is initially
+     * 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 />
@@ -281,6 +282,10 @@
      * independently to 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 provided buffer until the operation (or a round thereof) has completed.
+     *
      * @param src
      *            the buffer for the data to be written.
      * @param listener
@@ -307,7 +312,7 @@
      * 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.
      * <p />
-     * A working buffer with {@code 0} bytes remaining to be written (that is a buffer already empty), at the moment this method is initially
+     * 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.
      * <p />
@@ -318,6 +323,10 @@
      * 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.
+     *
      * @param src1
      *            the first buffer for the data to be written.
      * @param src2
@@ -382,7 +391,7 @@
      * baud rate and other configuration parameters can be changed by the provided {@link InputRoundListener} instance
      * upon notification of each round.
       * <p />
-     * A buffer with {@code 0} bytes remaining to be read (that is a buffer already full), at the moment this method is initially
+     * 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 />
@@ -396,6 +405,10 @@
      * 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 provided buffer until the operation (or a round thereof) has completed.
+     *
      * @param dst
      *            the buffer for the data to be read.
      * @param listener
@@ -422,7 +435,7 @@
      * 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.
      * <p />
-     * A buffer with {@code 0} bytes remaining to be read (that is a buffer already full), at the moment this method is initially
+     * 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 />
@@ -433,6 +446,10 @@
      * 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.
+     *
      * @param dst1
      *            the first buffer for the data to be read.
      * @param dst2
@@ -564,7 +581,7 @@
      * @param dst
      *            The buffer into which bytes are to be transferred
      *
-     * @return The number of bytes read, possibly zero, or {@code -1} if the device has reached end-of-stream
+     * @return The number of bytes read into {@code dst}, possibly zero, or {@code -1} if the device has reached end-of-stream
      *
      * @throws NullPointerException
      *             If {@code dst} is {@code null}.
@@ -592,7 +609,7 @@
      *
      * @param src
      *            The buffer from which bytes are to be retrieved
-     * @return The number of bytes written, possibly zero.
+     * @return The number of bytes written from {@code src}, possibly zero.
      * @throws NullPointerException
      *             If {@code src} is {@code null}.
      * @throws UnavailableDeviceException
--- a/src/share/classes/jdk/dio/uart/UARTConfig.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/UARTConfig.java	Thu Sep 11 13:40:27 2014 -0400
@@ -46,6 +46,7 @@
  *
  * @see DeviceManager#open(DeviceConfig)
  * @see DeviceManager#open(Class, DeviceConfig)
+ * @since 1.0
  */
 @SerializeMe
 public final class UARTConfig implements DeviceConfig<UART>, DeviceConfig.HardwareAddressing {
--- a/src/share/classes/jdk/dio/uart/UARTEvent.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/UARTEvent.java	Thu Sep 11 13:40:27 2014 -0400
@@ -33,6 +33,7 @@
  *
  * @see UART
  * @see UARTEventListener
+ * @since 1.0
  */
 public class UARTEvent extends DeviceEvent<UART> {
 
--- a/src/share/classes/jdk/dio/uart/UARTEventListener.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/UARTEventListener.java	Thu Sep 11 13:40:27 2014 -0400
@@ -34,6 +34,7 @@
  *
  * @see UART#setEventListener UART.setEventListener
  * @see UARTEvent
+ * @since 1.0
  */
 public interface UARTEventListener extends DeviceEventListener {
 
--- a/src/share/classes/jdk/dio/uart/UARTPermission.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/UARTPermission.java	Thu Sep 11 13:40:27 2014 -0400
@@ -55,6 +55,7 @@
  *
  * @see DeviceManager#open DeviceManager.open
  * @see jdk.dio.power.PowerManaged
+ * @since 1.0
  */
 @SuppressWarnings("serial")
 public class UARTPermission extends DevicePermission {
@@ -79,7 +80,7 @@
      * @param name
      *            the target name (as defined above).
      * @param actions
-     *            comma-delimited list of device operations: {@code open} or {@code powermanage}.
+     *            comma-separated list of device operations: {@code open} or {@code powermanage}.
      * @throws NullPointerException
      *             if {@code name} is {@code null}.
      * @throws IllegalArgumentException
--- a/src/share/classes/jdk/dio/uart/package-info.java	Wed Sep 10 11:05:24 2014 -0400
+++ b/src/share/classes/jdk/dio/uart/package-info.java	Thu Sep 11 13:40:27 2014 -0400
@@ -28,8 +28,8 @@
  * (UART), with optional Modem signals control.
  * <p />
  * In order to access and control a specific UART device, an application should first open and obtain an
- * {@link jdk.dio.uart.UART} instance for the UART device using its numeric ID, or name, or type (interface)
- * or combination of properties:
+ * {@link jdk.dio.uart.UART} instance for the UART device using its numeric ID, name, type (interface)
+ * and/or properties:
  * <dl>
  * <dt>Using its ID</dt>
  * <dd>
@@ -123,7 +123,7 @@
  * }
  * </pre>
  *
- * </blockquote> The preceding example is using a <em>try-with-resources</em> statement and that 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.
@@ -132,6 +132,8 @@
  * or interface in this package will cause a {@link java.lang.NullPointerException NullPointerException} to be thrown.
  * <p />
  * This package requires the {@link jdk.dio.modem} package.
+ *
+ * @since 1.0
  */
 package jdk.dio.uart;