7 files changed, 665 insertions, 167 deletions

diff --git a/Documentation/usb/WUSB-Design-overview.txt b/Documentation/usb/WUSB-Design-overview.txt
index c480e9c32dbd..4c5e37939344 100644
--- a/Documentation/usb/WUSB-Design-overview.txt
+++ b/Documentation/usb/WUSB-Design-overview.txt
@@ -381,7 +381,7 @@ descriptor that gives us the status of the transfer, its identification
 we issue another URB to read into the destination buffer the chunk of
 data coming out of the remote endpoint. Done, wait for the next guy. The
 callbacks for the URBs issued from here are the ones that will declare
-the xfer complete at some point and call it's callback.
+the xfer complete at some point and call its callback.
 
 Seems simple, but the implementation is not trivial.
 
diff --git a/Documentation/usb/bulk-streams.txt b/Documentation/usb/bulk-streams.txt
new file mode 100644
index 000000000000..ffc02021863e
--- /dev/null
+++ b/Documentation/usb/bulk-streams.txt
@@ -0,0 +1,78 @@
+Background
+==========
+
+Bulk endpoint streams were added in the USB 3.0 specification.  Streams allow a
+device driver to overload a bulk endpoint so that multiple transfers can be
+queued at once.
+
+Streams are defined in sections 4.4.6.4 and 8.12.1.4 of the Universal Serial Bus
+3.0 specification at http://www.usb.org/developers/docs/  The USB Attached SCSI
+Protocol, which uses streams to queue multiple SCSI commands, can be found on
+the T10 website (http://t10.org/).
+
+
+Device-side implications
+========================
+
+Once a buffer has been queued to a stream ring, the device is notified (through
+an out-of-band mechanism on another endpoint) that data is ready for that stream
+ID.  The device then tells the host which "stream" it wants to start.  The host
+can also initiate a transfer on a stream without the device asking, but the
+device can refuse that transfer.  Devices can switch between streams at any
+time.
+
+
+Driver implications
+===================
+
+int usb_alloc_streams(struct usb_interface *interface,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                unsigned int num_streams, gfp_t mem_flags);
+
+Device drivers will call this API to request that the host controller driver
+allocate memory so the driver can use up to num_streams stream IDs.  They must
+pass an array of usb_host_endpoints that need to be setup with similar stream
+IDs.  This is to ensure that a UASP driver will be able to use the same stream
+ID for the bulk IN and OUT endpoints used in a Bi-directional command sequence.
+
+The return value is an error condition (if one of the endpoints doesn't support
+streams, or the xHCI driver ran out of memory), or the number of streams the
+host controller allocated for this endpoint.  The xHCI host controller hardware
+declares how many stream IDs it can support, and each bulk endpoint on a
+SuperSpeed device will say how many stream IDs it can handle.  Therefore,
+drivers should be able to deal with being allocated less stream IDs than they
+requested.
+
+Do NOT call this function if you have URBs enqueued for any of the endpoints
+passed in as arguments.  Do not call this function to request less than two
+streams.
+
+Drivers will only be allowed to call this API once for the same endpoint
+without calling usb_free_streams().  This is a simplification for the xHCI host
+controller driver, and may change in the future.
+
+
+Picking new Stream IDs to use
+============================
+
+Stream ID 0 is reserved, and should not be used to communicate with devices.  If
+usb_alloc_streams() returns with a value of N, you may use streams 1 though N.
+To queue an URB for a specific stream, set the urb->stream_id value.  If the
+endpoint does not support streams, an error will be returned.
+
+Note that new API to choose the next stream ID will have to be added if the xHCI
+driver supports secondary stream IDs.
+
+
+Clean up
+========
+
+If a driver wishes to stop using streams to communicate with the device, it
+should call
+
+void usb_free_streams(struct usb_interface *interface,
+                struct usb_host_endpoint **eps, unsigned int num_eps,
+                gfp_t mem_flags);
+
+All stream IDs will be deallocated when the driver releases the interface, to
+ensure that drivers that don't support streams will be able to use the endpoint.
diff --git a/Documentation/usb/dma.txt b/Documentation/usb/dma.txt
index cfdcd16e3abf..84ef865237db 100644
--- a/Documentation/usb/dma.txt
+++ b/Documentation/usb/dma.txt
@@ -16,11 +16,11 @@ OR:  they can now be DMA-aware.
   manage dma mappings for existing dma-ready buffers (see below).
 
 - URBs have an additional "transfer_dma" field, as well as a transfer_flags
-  bit saying if it's valid.  (Control requests also have "setup_dma" and a
-  corresponding transfer_flags bit.)
+  bit saying if it's valid.  (Control requests also have "setup_dma", but
+  drivers must not use it.)
 
-- "usbcore" will map those DMA addresses, if a DMA-aware driver didn't do
-  it first and set URB_NO_TRANSFER_DMA_MAP or URB_NO_SETUP_DMA_MAP.  HCDs
+- "usbcore" will map this DMA address, if a DMA-aware driver didn't do
+  it first and set URB_NO_TRANSFER_DMA_MAP.  HCDs
   don't manage dma mappings for URBs.
 
 - There's a new "generic DMA API", parts of which are usable by USB device
@@ -43,22 +43,16 @@ and effects like cache-trashing can impose subtle penalties.
   kind of addresses to store in urb->transfer_buffer and urb->transfer_dma.
   You'd also set URB_NO_TRANSFER_DMA_MAP in urb->transfer_flags:
 
-        void *usb_buffer_alloc (struct usb_device *dev, size_t size,
+        void *usb_alloc_coherent (struct usb_device *dev, size_t size,
                 int mem_flags, dma_addr_t *dma);
 
-        void usb_buffer_free (struct usb_device *dev, size_t size,
+        void usb_free_coherent (struct usb_device *dev, size_t size,
                 void *addr, dma_addr_t dma);
 
   Most drivers should *NOT* be using these primitives; they don't need
   to use this type of memory ("dma-coherent"), and memory returned from
   kmalloc() will work just fine.
 
-  For control transfers you can use the buffer primitives or not for each
-  of the transfer buffer and setup buffer independently.  Set the flag bits
-  URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP to indicate which
-  buffers you have prepared.  For non-control transfers URB_NO_SETUP_DMA_MAP
-  is ignored.
-
   The memory buffer returned is "dma-coherent"; sometimes you might need to
   force a consistent memory access ordering by using memory barriers.  It's
   not using a streaming DMA mapping, so it's good for small transfers on
@@ -130,8 +124,8 @@ of Documentation/PCI/PCI-DMA-mapping.txt, titled "What memory is DMA-able?")
         void usb_buffer_unmap (struct urb *urb);
 
   The calls manage urb->transfer_dma for you, and set URB_NO_TRANSFER_DMA_MAP
-  so that usbcore won't map or unmap the buffer.  The same goes for
-  urb->setup_dma and URB_NO_SETUP_DMA_MAP for control requests.
+  so that usbcore won't map or unmap the buffer.  They cannot be used for
+  setup_packet buffers in control requests.
 
 Note that several of those interfaces are currently commented out, since
 they don't have current users.  See the source code.  Other than the dmasync
diff --git a/Documentation/usb/error-codes.txt b/Documentation/usb/error-codes.txt
index 9cf83e8c27b8..d83703ea74b2 100644
--- a/Documentation/usb/error-codes.txt
+++ b/Documentation/usb/error-codes.txt
@@ -41,8 +41,8 @@ USB-specific:
 
 -EFBIG          Host controller driver can't schedule that many ISO frames.
 
--EPIPE          Specified endpoint is stalled.  For non-control endpoints,
-                reset this status with usb_clear_halt().
+-EPIPE          The pipe type specified in the URB doesn't match the
+                endpoint's actual type.
 
 -EMSGSIZE       (a) endpoint maxpacket size is zero; it is not usable
                     in the current interface altsetting.
@@ -60,6 +60,8 @@ USB-specific:
 
 -EHOSTUNREACH   URB was rejected because the device is suspended.
 
+-ENOEXEC        A control URB doesn't contain a Setup packet.
+
 
 **************************************************************************
 *                   Error codes returned by in urb->status               *
diff --git a/Documentation/usb/gadget_hid.txt b/Documentation/usb/gadget_hid.txt
new file mode 100644
index 000000000000..f4a51f567427
--- /dev/null
+++ b/Documentation/usb/gadget_hid.txt
@@ -0,0 +1,445 @@
+
+                     Linux USB HID gadget driver
+
+Introduction
+
+        The HID Gadget driver provides emulation of USB Human Interface
+        Devices (HID). The basic HID handling is done in the kernel,
+        and HID reports can be sent/received through I/O on the
+        /dev/hidgX character devices.
+
+        For more details about HID, see the developer page on
+        http://www.usb.org/developers/hidpage/
+
+Configuration
+
+        g_hid is a platform driver, so to use it you need to add
+        struct platform_device(s) to your platform code defining the
+        HID function descriptors you want to use - E.G. something
+        like:
+
+#include <linux/platform_device.h>
+#include <linux/usb/g_hid.h>
+
+/* hid descriptor for a keyboard */
+static struct hidg_func_descriptor my_hid_data = {
+        .subclass               = 0, /* No subclass */
+        .protocol               = 1, /* Keyboard */
+        .report_length          = 8,
+        .report_desc_length     = 63,
+        .report_desc            = {
+                0x05, 0x01,     /* USAGE_PAGE (Generic Desktop)           */
+                0x09, 0x06,     /* USAGE (Keyboard)                       */
+                0xa1, 0x01,     /* COLLECTION (Application)               */
+                0x05, 0x07,     /*   USAGE_PAGE (Keyboard)                */
+                0x19, 0xe0,     /*   USAGE_MINIMUM (Keyboard LeftControl) */
+                0x29, 0xe7,     /*   USAGE_MAXIMUM (Keyboard Right GUI)   */
+                0x15, 0x00,     /*   LOGICAL_MINIMUM (0)                  */
+                0x25, 0x01,     /*   LOGICAL_MAXIMUM (1)                  */
+                0x75, 0x01,     /*   REPORT_SIZE (1)                      */
+                0x95, 0x08,     /*   REPORT_COUNT (8)                     */
+                0x81, 0x02,     /*   INPUT (Data,Var,Abs)                 */
+                0x95, 0x01,     /*   REPORT_COUNT (1)                     */
+                0x75, 0x08,     /*   REPORT_SIZE (8)                      */
+                0x81, 0x03,     /*   INPUT (Cnst,Var,Abs)                 */
+                0x95, 0x05,     /*   REPORT_COUNT (5)                     */
+                0x75, 0x01,     /*   REPORT_SIZE (1)                      */
+                0x05, 0x08,     /*   USAGE_PAGE (LEDs)                    */
+                0x19, 0x01,     /*   USAGE_MINIMUM (Num Lock)             */
+                0x29, 0x05,     /*   USAGE_MAXIMUM (Kana)                 */
+                0x91, 0x02,     /*   OUTPUT (Data,Var,Abs)                */
+                0x95, 0x01,     /*   REPORT_COUNT (1)                     */
+                0x75, 0x03,     /*   REPORT_SIZE (3)                      */
+                0x91, 0x03,     /*   OUTPUT (Cnst,Var,Abs)                */
+                0x95, 0x06,     /*   REPORT_COUNT (6)                     */
+                0x75, 0x08,     /*   REPORT_SIZE (8)                      */
+                0x15, 0x00,     /*   LOGICAL_MINIMUM (0)                  */
+                0x25, 0x65,     /*   LOGICAL_MAXIMUM (101)                */
+                0x05, 0x07,     /*   USAGE_PAGE (Keyboard)                */
+                0x19, 0x00,     /*   USAGE_MINIMUM (Reserved)             */
+                0x29, 0x65,     /*   USAGE_MAXIMUM (Keyboard Application) */
+                0x81, 0x00,     /*   INPUT (Data,Ary,Abs)                 */
+                0xc0            /* END_COLLECTION                         */
+        }
+};
+
+static struct platform_device my_hid = {
+        .name                   = "hidg",
+        .id                     = 0,
+        .num_resources          = 0,
+        .resource               = 0,
+        .dev.platform_data      = &my_hid_data,
+};
+
+        You can add as many HID functions as you want, only limited by
+        the amount of interrupt endpoints your gadget driver supports.
+
+Send and receive HID reports
+
+        HID reports can be sent/received using read/write on the
+        /dev/hidgX character devices. See below for an example program
+        to do this.
+
+        hid_gadget_test is a small interactive program to test the HID
+        gadget driver. To use, point it at a hidg device and set the
+        device type (keyboard / mouse / joystick) - E.G.:
+
+                # hid_gadget_test /dev/hidg0 keyboard
+
+        You are now in the prompt of hid_gadget_test. You can type any
+        combination of options and values. Available options and
+        values are listed at program start. In keyboard mode you can
+        send up to six values.
+
+        For example type: g i s t r --left-shift
+
+        Hit return and the corresponding report will be sent by the
+        HID gadget.
+
+        Another interesting example is the caps lock test. Type
+        -–caps-lock and hit return. A report is then sent by the
+        gadget and you should receive the host answer, corresponding
+        to the caps lock LED status.
+
+                --caps-lock
+                recv report:2
+
+        With this command:
+
+                # hid_gadget_test /dev/hidg1 mouse
+
+        You can test the mouse emulation. Values are two signed numbers.
+
+
+Sample code
+
+/* hid_gadget_test */
+
+#include <pthread.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define BUF_LEN 512
+
+struct options {
+        const char    *opt;
+        unsigned char val;
+};
+
+static struct options kmod[] = {
+        {.opt = "--left-ctrl",          .val = 0x01},
+        {.opt = "--right-ctrl",         .val = 0x10},
+        {.opt = "--left-shift",         .val = 0x02},
+        {.opt = "--right-shift",        .val = 0x20},
+        {.opt = "--left-alt",           .val = 0x04},
+        {.opt = "--right-alt",          .val = 0x40},
+        {.opt = "--left-meta",          .val = 0x08},
+        {.opt = "--right-meta",         .val = 0x80},
+        {.opt = NULL}
+};
+
+static struct options kval[] = {
+        {.opt = "--return",     .val = 0x28},
+        {.opt = "--esc",        .val = 0x29},
+        {.opt = "--bckspc",     .val = 0x2a},
+        {.opt = "--tab",        .val = 0x2b},
+        {.opt = "--spacebar",   .val = 0x2c},
+        {.opt = "--caps-lock",  .val = 0x39},
+        {.opt = "--f1",         .val = 0x3a},
+        {.opt = "--f2",         .val = 0x3b},
+        {.opt = "--f3",         .val = 0x3c},
+        {.opt = "--f4",         .val = 0x3d},
+        {.opt = "--f5",         .val = 0x3e},
+        {.opt = "--f6",         .val = 0x3f},
+        {.opt = "--f7",         .val = 0x40},
+        {.opt = "--f8",         .val = 0x41},
+        {.opt = "--f9",         .val = 0x42},
+        {.opt = "--f10",        .val = 0x43},
+        {.opt = "--f11",        .val = 0x44},
+        {.opt = "--f12",        .val = 0x45},
+        {.opt = "--insert",     .val = 0x49},
+        {.opt = "--home",       .val = 0x4a},
+        {.opt = "--pageup",     .val = 0x4b},
+        {.opt = "--del",        .val = 0x4c},
+        {.opt = "--end",        .val = 0x4d},
+        {.opt = "--pagedown",   .val = 0x4e},
+        {.opt = "--right",      .val = 0x4f},
+        {.opt = "--left",       .val = 0x50},
+        {.opt = "--down",       .val = 0x51},
+        {.opt = "--kp-enter",   .val = 0x58},
+        {.opt = "--up",         .val = 0x52},
+        {.opt = "--num-lock",   .val = 0x53},
+        {.opt = NULL}
+};
+
+int keyboard_fill_report(char report[8], char buf[BUF_LEN], int *hold)
+{
+        char *tok = strtok(buf, " ");
+        int key = 0;
+        int i = 0;
+
+        for (; tok != NULL; tok = strtok(NULL, " ")) {
+
+                if (strcmp(tok, "--quit") == 0)
+                        return -1;
+
+                if (strcmp(tok, "--hold") == 0) {
+                        *hold = 1;
+                        continue;
+                }
+
+                if (key < 6) {
+                        for (i = 0; kval[i].opt != NULL; i++)
+                                if (strcmp(tok, kval[i].opt) == 0) {
+                                        report[2 + key++] = kval[i].val;
+                                        break;
+                                }
+                        if (kval[i].opt != NULL)
+                                continue;
+                }
+
+                if (key < 6)
+                        if (islower(tok[0])) {
+                                report[2 + key++] = (tok[0] - ('a' - 0x04));
+                                continue;
+                        }
+
+                for (i = 0; kmod[i].opt != NULL; i++)
+                        if (strcmp(tok, kmod[i].opt) == 0) {
+                                report[0] = report[0] | kmod[i].val;
+                                break;
+                        }
+                if (kmod[i].opt != NULL)
+                        continue;
+
+                if (key < 6)
+                        fprintf(stderr, "unknown option: %s\n", tok);
+        }
+        return 8;
+}
+
+static struct options mmod[] = {
+        {.opt = "--b1", .val = 0x01},
+        {.opt = "--b2", .val = 0x02},
+        {.opt = "--b3", .val = 0x04},
+        {.opt = NULL}
+};
+
+int mouse_fill_report(char report[8], char buf[BUF_LEN], int *hold)
+{
+        char *tok = strtok(buf, " ");
+        int mvt = 0;
+        int i = 0;
+        for (; tok != NULL; tok = strtok(NULL, " ")) {
+
+                if (strcmp(tok, "--quit") == 0)
+                        return -1;
+
+                if (strcmp(tok, "--hold") == 0) {
+                        *hold = 1;
+                        continue;
+                }
+
+                for (i = 0; mmod[i].opt != NULL; i++)
+                        if (strcmp(tok, mmod[i].opt) == 0) {
+                                report[0] = report[0] | mmod[i].val;
+                                break;
+                        }
+                if (mmod[i].opt != NULL)
+                        continue;
+
+                if (!(tok[0] == '-' && tok[1] == '-') && mvt < 2) {
+                        errno = 0;
+                        report[1 + mvt++] = (char)strtol(tok, NULL, 0);
+                        if (errno != 0) {
+                                fprintf(stderr, "Bad value:'%s'\n", tok);
+                                report[1 + mvt--] = 0;
+                        }
+                        continue;
+                }
+
+                fprintf(stderr, "unknown option: %s\n", tok);
+        }
+        return 3;
+}
+
+static struct options jmod[] = {
+        {.opt = "--b1",         .val = 0x10},
+        {.opt = "--b2",         .val = 0x20},
+        {.opt = "--b3",         .val = 0x40},
+        {.opt = "--b4",         .val = 0x80},
+        {.opt = "--hat1",       .val = 0x00},
+        {.opt = "--hat2",       .val = 0x01},
+        {.opt = "--hat3",       .val = 0x02},
+        {.opt = "--hat4",       .val = 0x03},
+        {.opt = "--hatneutral", .val = 0x04},
+        {.opt = NULL}
+};
+
+int joystick_fill_report(char report[8], char buf[BUF_LEN], int *hold)
+{
+        char *tok = strtok(buf, " ");
+        int mvt = 0;
+        int i = 0;
+
+        *hold = 1;
+
+        /* set default hat position: neutral */
+        report[3] = 0x04;
+
+        for (; tok != NULL; tok = strtok(NULL, " ")) {
+
+                if (strcmp(tok, "--quit") == 0)
+                        return -1;
+
+                for (i = 0; jmod[i].opt != NULL; i++)
+                        if (strcmp(tok, jmod[i].opt) == 0) {
+                                report[3] = (report[3] & 0xF0) | jmod[i].val;
+                                break;
+                        }
+                if (jmod[i].opt != NULL)
+                        continue;
+
+                if (!(tok[0] == '-' && tok[1] == '-') && mvt < 3) {
+                        errno = 0;
+                        report[mvt++] = (char)strtol(tok, NULL, 0);
+                        if (errno != 0) {
+                                fprintf(stderr, "Bad value:'%s'\n", tok);
+                                report[mvt--] = 0;
+                        }
+                        continue;
+                }
+
+                fprintf(stderr, "unknown option: %s\n", tok);
+        }
+        return 4;
+}
+
+void print_options(char c)
+{
+        int i = 0;
+
+        if (c == 'k') {
+                printf("        keyboard options:\n"
+                       "                --hold\n");
+                for (i = 0; kmod[i].opt != NULL; i++)
+                        printf("\t\t%s\n", kmod[i].opt);
+                printf("\n      keyboard values:\n"
+                       "                [a-z] or\n");
+                for (i = 0; kval[i].opt != NULL; i++)
+                        printf("\t\t%-8s%s", kval[i].opt, i % 2 ? "\n" : "");
+                printf("\n");
+        } else if (c == 'm') {
+                printf("        mouse options:\n"
+                       "                --hold\n");
+                for (i = 0; mmod[i].opt != NULL; i++)
+                        printf("\t\t%s\n", mmod[i].opt);
+                printf("\n      mouse values:\n"
+                       "                Two signed numbers\n"
+                       "--quit to close\n");
+        } else {
+                printf("        joystick options:\n");
+                for (i = 0; jmod[i].opt != NULL; i++)
+                        printf("\t\t%s\n", jmod[i].opt);
+                printf("\n      joystick values:\n"
+                       "                three signed numbers\n"
+                       "--quit to close\n");
+        }
+}
+
+int main(int argc, const char *argv[])
+{
+        const char *filename = NULL;
+        int fd = 0;
+        char buf[BUF_LEN];
+        int cmd_len;
+        char report[8];
+        int to_send = 8;
+        int hold = 0;
+        fd_set rfds;
+        int retval, i;
+
+        if (argc < 3) {
+                fprintf(stderr, "Usage: %s devname mouse|keyboard|joystick\n",
+                        argv[0]);
+                return 1;
+        }
+
+        if (argv[2][0] != 'k' && argv[2][0] != 'm' && argv[2][0] != 'j')
+          return 2;
+
+        filename = argv[1];
+
+        if ((fd = open(filename, O_RDWR, 0666)) == -1) {
+                perror(filename);
+                return 3;
+        }
+
+        print_options(argv[2][0]);
+
+        while (42) {
+
+                FD_ZERO(&rfds);
+                FD_SET(STDIN_FILENO, &rfds);
+                FD_SET(fd, &rfds);
+
+                retval = select(fd + 1, &rfds, NULL, NULL, NULL);
+                if (retval == -1 && errno == EINTR)
+                        continue;
+                if (retval < 0) {
+                        perror("select()");
+                        return 4;
+                }
+
+                if (FD_ISSET(fd, &rfds)) {
+                        cmd_len = read(fd, buf, BUF_LEN - 1);
+                        printf("recv report:");
+                        for (i = 0; i < cmd_len; i++)
+                                printf(" %02x", buf[i]);
+                        printf("\n");
+                }
+
+                if (FD_ISSET(STDIN_FILENO, &rfds)) {
+                        memset(report, 0x0, sizeof(report));
+                        cmd_len = read(STDIN_FILENO, buf, BUF_LEN - 1);
+
+                        if (cmd_len == 0)
+                                break;
+
+                        buf[cmd_len - 1] = '\0';
+                        hold = 0;
+
+                        memset(report, 0x0, sizeof(report));
+                        if (argv[2][0] == 'k')
+                                to_send = keyboard_fill_report(report, buf, &hold);
+                        else if (argv[2][0] == 'm')
+                                to_send = mouse_fill_report(report, buf, &hold);
+                        else
+                                to_send = joystick_fill_report(report, buf, &hold);
+
+                        if (to_send == -1)
+                                break;
+
+                        if (write(fd, report, to_send) != to_send) {
+                                perror(filename);
+                                return 5;
+                        }
+                        if (!hold) {
+                                memset(report, 0x0, sizeof(report));
+                                if (write(fd, report, to_send) != to_send) {
+                                        perror(filename);
+                                        return 6;
+                                }
+                        }
+                }
+        }
+
+        close(fd);
+        return 0;
+}
diff --git a/Documentation/usb/power-management.txt b/Documentation/usb/power-management.txt
index 3bf6818c8cf5..b29d8e56cf28 100644
--- a/Documentation/usb/power-management.txt
+++ b/Documentation/usb/power-management.txt
@@ -2,7 +2,7 @@
 
                  Alan Stern <stern@rowland.harvard.edu>
 
-                            November 10, 2009
+                            December 11, 2009
 
 
 
@@ -29,9 +29,9 @@ covered to some extent (see Documentation/power/*.txt for more
 information about system PM).
 
 Note: Dynamic PM support for USB is present only if the kernel was
-built with CONFIG_USB_SUSPEND enabled.  System PM support is present
-only if the kernel was built with CONFIG_SUSPEND or CONFIG_HIBERNATION
-enabled.
+built with CONFIG_USB_SUSPEND enabled (which depends on
+CONFIG_PM_RUNTIME).  System PM support is present only if the kernel
+was built with CONFIG_SUSPEND or CONFIG_HIBERNATION enabled.
 
 
         What is Remote Wakeup?
@@ -107,7 +107,9 @@ allowed to issue dynamic suspends.
 The user interface for controlling dynamic PM is located in the power/
 subdirectory of each USB device's sysfs directory, that is, in
 /sys/bus/usb/devices/.../power/ where "..." is the device's ID.  The
-relevant attribute files are: wakeup, level, and autosuspend.
+relevant attribute files are: wakeup, control, and autosuspend.
+(There may also be a file named "level"; this file was deprecated
+as of the 2.6.35 kernel and replaced by the "control" file.)
 
         power/wakeup
 
@@ -120,7 +122,7 @@ relevant attribute files are: wakeup, level, and autosuspend.
                 while the device is suspended, the change won't take
                 effect until the following suspend.)
 
-        power/level
+        power/control
 
                 This file contains one of two words: "on" or "auto".
                 You can write those words to the file to change the
@@ -148,14 +150,15 @@ relevant attribute files are: wakeup, level, and autosuspend.
                 never to autosuspend.  You can write a number to the
                 file to change the autosuspend idle-delay time.
 
-Writing "-1" to power/autosuspend and writing "on" to power/level do
+Writing "-1" to power/autosuspend and writing "on" to power/control do
 essentially the same thing -- they both prevent the device from being
 autosuspended.  Yes, this is a redundancy in the API.
 
 (In 2.6.21 writing "0" to power/autosuspend would prevent the device
 from being autosuspended; the behavior was changed in 2.6.22.  The
 power/autosuspend attribute did not exist prior to 2.6.21, and the
-power/level attribute did not exist prior to 2.6.22.)
+power/level attribute did not exist prior to 2.6.22.  power/control
+was added in 2.6.34.)
 
 
         Changing the default idle-delay time
@@ -212,7 +215,7 @@ among printers and scanners, but plenty of other types of device have
 the same deficiency.
 
 For this reason, by default the kernel disables autosuspend (the
-power/level attribute is initialized to "on") for all devices other
+power/control attribute is initialized to "on") for all devices other
 than hubs.  Hubs, at least, appear to be reasonably well-behaved in
 this regard.
 
@@ -229,6 +232,11 @@ necessary operations by hand or add them to a udev script.  You can
 also change the idle-delay time; 2 seconds is not the best choice for
 every device.
 
+If a driver knows that its device has proper suspend/resume support,
+it can enable autosuspend all by itself.  For example, the video
+driver for a laptop's webcam might do this, since these devices are
+rarely used and so should normally be autosuspended.
+
 Sometimes it turns out that even when a device does work okay with
 autosuspend there are still problems.  For example, there are
 experimental patches adding autosuspend support to the usbhid driver,
@@ -321,69 +329,81 @@ driver does so by calling these six functions:
         void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
         void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
 
-The functions work by maintaining a counter in the usb_interface
-structure.  When intf->pm_usage_count is > 0 then the interface is
-deemed to be busy, and the kernel will not autosuspend the interface's
-device.  When intf->pm_usage_count is <= 0 then the interface is
-considered to be idle, and the kernel may autosuspend the device.
+The functions work by maintaining a usage counter in the
+usb_interface's embedded device structure.  When the counter is > 0
+then the interface is deemed to be busy, and the kernel will not
+autosuspend the interface's device.  When the usage counter is = 0
+then the interface is considered to be idle, and the kernel may
+autosuspend the device.
 
-(There is a similar pm_usage_count field in struct usb_device,
+(There is a similar usage counter field in struct usb_device,
 associated with the device itself rather than any of its interfaces.
-This field is used only by the USB core.)
-
-Drivers must not modify intf->pm_usage_count directly; its value
-should be changed only be using the functions listed above.  Drivers
-are responsible for insuring that the overall change to pm_usage_count
-during their lifetime balances out to 0 (it may be necessary for the
-disconnect method to call usb_autopm_put_interface() one or more times
-to fulfill this requirement).  The first two routines use the PM mutex
-in struct usb_device for mutual exclusion; drivers using the async
-routines are responsible for their own synchronization and mutual
-exclusion.
-
-        usb_autopm_get_interface() increments pm_usage_count and
-        attempts an autoresume if the new value is > 0 and the
-        device is suspended.
-
-        usb_autopm_put_interface() decrements pm_usage_count and
-        attempts an autosuspend if the new value is <= 0 and the
-        device isn't suspended.
+This counter is used only by the USB core.)
+
+Drivers need not be concerned about balancing changes to the usage
+counter; the USB core will undo any remaining "get"s when a driver
+is unbound from its interface.  As a corollary, drivers must not call
+any of the usb_autopm_* functions after their diconnect() routine has
+returned.
+
+Drivers using the async routines are responsible for their own
+synchronization and mutual exclusion.
+
+        usb_autopm_get_interface() increments the usage counter and
+        does an autoresume if the device is suspended.  If the
+        autoresume fails, the counter is decremented back.
+
+        usb_autopm_put_interface() decrements the usage counter and
+        attempts an autosuspend if the new value is = 0.
 
         usb_autopm_get_interface_async() and
         usb_autopm_put_interface_async() do almost the same things as
-        their non-async counterparts.  The differences are: they do
-        not acquire the PM mutex, and they use a workqueue to do their
+        their non-async counterparts.  The big difference is that they
+        use a workqueue to do the resume or suspend part of their
         jobs.  As a result they can be called in an atomic context,
         such as an URB's completion handler, but when they return the
-        device will not generally not yet be in the desired state.
+        device will generally not yet be in the desired state.
 
         usb_autopm_get_interface_no_resume() and
         usb_autopm_put_interface_no_suspend() merely increment or
-        decrement the pm_usage_count value; they do not attempt to
-        carry out an autoresume or an autosuspend.  Hence they can be
-        called in an atomic context.
+        decrement the usage counter; they do not attempt to carry out
+        an autoresume or an autosuspend.  Hence they can be called in
+        an atomic context.
 
-The conventional usage pattern is that a driver calls
+The simplest usage pattern is that a driver calls
 usb_autopm_get_interface() in its open routine and
-usb_autopm_put_interface() in its close or release routine.  But
-other patterns are possible.
+usb_autopm_put_interface() in its close or release routine.  But other
+patterns are possible.
 
 The autosuspend attempts mentioned above will often fail for one
-reason or another.  For example, the power/level attribute might be
+reason or another.  For example, the power/control attribute might be
 set to "on", or another interface in the same device might not be
 idle.  This is perfectly normal.  If the reason for failure was that
-the device hasn't been idle for long enough, a delayed workqueue
-routine is automatically set up to carry out the operation when the
-autosuspend idle-delay has expired.
+the device hasn't been idle for long enough, a timer is scheduled to
+carry out the operation automatically when the autosuspend idle-delay
+has expired.
 
 Autoresume attempts also can fail, although failure would mean that
 the device is no longer present or operating properly.  Unlike
-autosuspend, there's no delay for an autoresume.
+autosuspend, there's no idle-delay for an autoresume.
 
 
         Other parts of the driver interface
         -----------------------------------
 
+Drivers can enable autosuspend for their devices by calling
+
+        usb_enable_autosuspend(struct usb_device *udev);
+
+in their probe() routine, if they know that the device is capable of
+suspending and resuming correctly.  This is exactly equivalent to
+writing "auto" to the device's power/control attribute.  Likewise,
+drivers can disable autosuspend by calling
+
+        usb_disable_autosuspend(struct usb_device *udev);
+
+This is exactly the same as writing "on" to the power/control attribute.
+
 Sometimes a driver needs to make sure that remote wakeup is enabled
 during autosuspend.  For example, there's not much point
 autosuspending a keyboard if the user can't cause the keyboard to do a
@@ -395,26 +415,27 @@ though, setting this flag won't cause the kernel to autoresume it.
 Normally a driver would set this flag in its probe method, at which
 time the device is guaranteed not to be autosuspended.)
 
-The synchronous usb_autopm_* routines have to run in a sleepable
-process context; they must not be called from an interrupt handler or
-while holding a spinlock.  In fact, the entire autosuspend mechanism
-is not well geared toward interrupt-driven operation.  However there
-is one thing a driver can do in an interrupt handler:
+If a driver does its I/O asynchronously in interrupt context, it
+should call usb_autopm_get_interface_async() before starting output and
+usb_autopm_put_interface_async() when the output queue drains.  When
+it receives an input event, it should call
 
         usb_mark_last_busy(struct usb_device *udev);
 
-This sets udev->last_busy to the current time.  udev->last_busy is the
-field used for idle-delay calculations; updating it will cause any
-pending autosuspend to be moved back.  The usb_autopm_* routines will
-also set the last_busy field to the current time.
-
-Calling urb_mark_last_busy() from within an URB completion handler is
-subject to races: The kernel may have just finished deciding the
-device has been idle for long enough but not yet gotten around to
-calling the driver's suspend method.  The driver would have to be
-responsible for synchronizing its suspend method with its URB
-completion handler and causing the autosuspend to fail with -EBUSY if
-an URB had completed too recently.
+in the event handler.  This sets udev->last_busy to the current time.
+udev->last_busy is the field used for idle-delay calculations;
+updating it will cause any pending autosuspend to be moved back.  Most
+of the usb_autopm_* routines will also set the last_busy field to the
+current time.
+
+Asynchronous operation is always subject to races.  For example, a
+driver may call one of the usb_autopm_*_interface_async() routines at
+a time when the core has just finished deciding the device has been
+idle for long enough but not yet gotten around to calling the driver's
+suspend method.  The suspend method must be responsible for
+synchronizing with the output request routine and the URB completion
+handler; it should cause autosuspends to fail with -EBUSY if the
+driver needs to use the device.
 
 External suspend calls should never be allowed to fail in this way,
 only autosuspend calls.  The driver can tell them apart by checking
@@ -422,75 +443,23 @@ the PM_EVENT_AUTO bit in the message.event argument to the suspend
 method; this bit will be set for internal PM events (autosuspend) and
 clear for external PM events.
 
-Many of the ingredients in the autosuspend framework are oriented
-towards interfaces: The usb_interface structure contains the
-pm_usage_cnt field, and the usb_autopm_* routines take an interface
-pointer as their argument.  But somewhat confusingly, a few of the
-pieces (i.e., usb_mark_last_busy()) use the usb_device structure
-instead.  Drivers need to keep this straight; they can call
-interface_to_usbdev() to find the device structure for a given
-interface.
-
 
-        Locking requirements
-        --------------------
+        Mutual exclusion
+        ----------------
 
-All three suspend/resume methods are always called while holding the
-usb_device's PM mutex.  For external events -- but not necessarily for
-autosuspend or autoresume -- the device semaphore (udev->dev.sem) will
-also be held.  This implies that external suspend/resume events are
-mutually exclusive with calls to probe, disconnect, pre_reset, and
-post_reset; the USB core guarantees that this is true of internal
-suspend/resume events as well.
+For external events -- but not necessarily for autosuspend or
+autoresume -- the device semaphore (udev->dev.sem) will be held when a
+suspend or resume method is called.  This implies that external
+suspend/resume events are mutually exclusive with calls to probe,
+disconnect, pre_reset, and post_reset; the USB core guarantees that
+this is true of autosuspend/autoresume events as well.
 
 If a driver wants to block all suspend/resume calls during some
-critical section, it can simply acquire udev->pm_mutex. Note that
-calls to resume may be triggered indirectly. Block IO due to memory
-allocations can make the vm subsystem resume a device. Thus while
-holding this lock you must not allocate memory with GFP_KERNEL or
-GFP_NOFS.
-
-Alternatively, if the critical section might call some of the
-usb_autopm_* routines, the driver can avoid deadlock by doing:
-
-        down(&udev->dev.sem);
-        rc = usb_autopm_get_interface(intf);
-
-and at the end of the critical section:
-
-        if (!rc)
-                usb_autopm_put_interface(intf);
-        up(&udev->dev.sem);
-
-Holding the device semaphore will block all external PM calls, and the
-usb_autopm_get_interface() will prevent any internal PM calls, even if
-it fails.  (Exercise: Why?)
-
-The rules for locking order are:
-
-        Never acquire any device semaphore while holding any PM mutex.
-
-        Never acquire udev->pm_mutex while holding the PM mutex for
-        a device that isn't a descendant of udev.
-
-In other words, PM mutexes should only be acquired going up the device
-tree, and they should be acquired only after locking all the device
-semaphores you need to hold.  These rules don't matter to drivers very
-much; they usually affect just the USB core.
-
-Still, drivers do need to be careful.  For example, many drivers use a
-private mutex to synchronize their normal I/O activities with their
-disconnect method.  Now if the driver supports autosuspend then it
-must call usb_autopm_put_interface() from somewhere -- maybe from its
-close method.  It should make the call while holding the private mutex,
-since a driver shouldn't call any of the usb_autopm_* functions for an
-interface from which it has been unbound.
-
-But the usb_autpm_* routines always acquire the device's PM mutex, and
-consequently the locking order has to be: private mutex first, PM
-mutex second.  Since the suspend method is always called with the PM
-mutex held, it mustn't try to acquire the private mutex.  It has to
-synchronize with the driver's I/O activities in some other way.
+critical section, the best way is to lock the device and call
+usb_autopm_get_interface() (and do the reverse at the end of the
+critical section).  Holding the device semaphore will block all
+external PM calls, and the usb_autopm_get_interface() will prevent any
+internal PM calls, even if it fails.  (Exercise: Why?)
 
 
         Interaction between dynamic PM and system PM
@@ -499,22 +468,11 @@ synchronize with the driver's I/O activities in some other way.
 Dynamic power management and system power management can interact in
 a couple of ways.
 
-Firstly, a device may already be manually suspended or autosuspended
-when a system suspend occurs.  Since system suspends are supposed to
-be as transparent as possible, the device should remain suspended
-following the system resume.  The 2.6.23 kernel obeys this principle
-for manually suspended devices but not for autosuspended devices; they
-do get resumed when the system wakes up.  (Presumably they will be
-autosuspended again after their idle-delay time expires.)  In later
-kernels this behavior will be fixed.
-
-(There is an exception.  If a device would undergo a reset-resume
-instead of a normal resume, and the device is enabled for remote
-wakeup, then the reset-resume takes place even if the device was
-already suspended when the system suspend began.  The justification is
-that a reset-resume is a kind of remote-wakeup event.  Or to put it
-another way, a device which needs a reset won't be able to generate
-normal remote-wakeup signals, so it ought to be resumed immediately.)
+Firstly, a device may already be autosuspended when a system suspend
+occurs.  Since system suspends are supposed to be as transparent as
+possible, the device should remain suspended following the system
+resume.  But this theory may not work out well in practice; over time
+the kernel's behavior in this regard has changed.
 
 Secondly, a dynamic power-management event may occur as a system
 suspend is underway.  The window for this is short, since system
diff --git a/Documentation/usb/usb-serial.txt b/Documentation/usb/usb-serial.txt
index ff2c1ff57ba2..f4d214510259 100644
--- a/Documentation/usb/usb-serial.txt
+++ b/Documentation/usb/usb-serial.txt
@@ -194,6 +194,10 @@ FTDI Single Port Serial Driver
 
   This is a single port DB-25 serial adapter.
 
+  Devices supported include:
+                -TripNav TN-200 USB GPS
+                -Navis Engineering Bureau CH-4711 USB GPS
+
   For any questions or problems with this driver, please contact Bill Ryder.
 
 
@@ -216,7 +220,7 @@ Cypress M8 CY4601 Family Serial Driver
 
     Devices supported:
 
-                -DeLorme's USB Earthmate (SiRF Star II lp arch)
+                -DeLorme's USB Earthmate GPS (SiRF Star II lp arch)
                 -Cypress HID->COM RS232 adapter
         
                 Note: Cypress Semiconductor claims no affiliation with the
@@ -392,9 +396,10 @@ REINER SCT cyberJack pinpad/e-com USB chipcard reader
 Prolific PL2303 Driver
 
   This driver supports any device that has the PL2303 chip from Prolific
-  in it.  This includes a number of single port USB to serial
-  converters and USB GPS devices.  Devices from Aten (the UC-232) and
-  IO-Data work with this driver, as does the DCU-11 mobile-phone cable.
+  in it.  This includes a number of single port USB to serial converters,
+  more than 70% of USB GPS devices (in 2010), and some USB UPSes. Devices
+  from Aten (the UC-232) and IO-Data work with this driver, as does
+  the DCU-11 mobile-phone cable.
 
   For any questions or problems with this driver, please contact Greg
   Kroah-Hartman at greg@kroah.com
@@ -435,6 +440,22 @@ Winchiphead CH341 Driver
   For any questions or problems with this driver, please contact
   frank@kingswood-consulting.co.uk.
 
+Moschip MCS7720, MCS7715 driver
+
+  These chips are present in devices sold by various manufacturers, such as Syba
+  and Cables Unlimited.  There may be others.  The 7720 provides two serial
+  ports, and the 7715 provides one serial and one standard PC parallel port.
+  Support for the 7715's parallel port is enabled by a separate option, which
+  will not appear unless parallel port support is first enabled at the top-level
+  of the Device Drivers config menu.  Currently only compatibility mode is
+  supported on the parallel port (no ECP/EPP).
+
+  TODO:
+    - Implement ECP/EPP modes for the parallel port.
+    - Baud rates higher than 115200 are currently broken.
+    - Devices with a single serial port based on the Moschip MCS7703 may work
+      with this driver with a simple addition to the usb_device_id table.  I
+      don't have one of these devices, so I can't say for sure.
 
 Generic Serial driver