Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/usb-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/gregkh/usb-2.6: (70 commits)
  USB: remove duplicate device id from zc0301
  USB: remove duplicate device id from usb_storage
  USB: remove duplicate device id from keyspan
  USB: remove duplicate device id from ftdi_sio
  USB: remove duplicate device id from visor
  USB: a bit more coding style cleanup
  usbcore: trivial whitespace fixes
  usb-storage: use first bulk endpoints, not last
  EHCI: fix interrupt-driven remote wakeup
  USB: switch ehci-hcd to new polling scheme
  USB: autosuspend for usb printer driver
  USB Input: Added kernel module to support all GTCO CalComp USB InterWrite School products
  USB: Sierra Wireless auto set D0
  USB: usb ethernet gadget recognizes HUSB2DEV
  USB: list atmel husb2_udc gadget controller
  USB: gadgetfs AIO tweaks
  USB: gadgetfs behaves better on userspace init bug
  USB: gadgetfs race fix
  USB: gadgetfs simplifications
  USB: gadgetfs cleanups
  ...

4 files changed, 156 insertions, 28 deletions

diff --git a/drivers/usb/net/Kconfig b/drivers/usb/net/Kconfig
index e081836014ac..a2b94ef512bc 100644
--- a/drivers/usb/net/Kconfig
+++ b/drivers/usb/net/Kconfig
@@ -222,13 +222,15 @@ config USB_NET_MCS7830
           adapters marketed under the DeLOCK brand.
 
 config USB_NET_RNDIS_HOST
-        tristate "Host for RNDIS devices (EXPERIMENTAL)"
+        tristate "Host for RNDIS and ActiveSync devices (EXPERIMENTAL)"
         depends on USB_USBNET && EXPERIMENTAL
         select USB_NET_CDCETHER
         help
           This option enables hosting "Remote NDIS" USB networking links,
           as encouraged by Microsoft (instead of CDC Ethernet!) for use in
-          various devices that may only support this protocol.
+          various devices that may only support this protocol.  A variant
+          of this protocol (with even less public documentation) seems to
+          be at the root of Microsoft's "ActiveSync" too.
 
           Avoid using this protocol unless you have no better options.
           The protocol specification is incomplete, and is controlled by
diff --git a/drivers/usb/net/cdc_ether.c b/drivers/usb/net/cdc_ether.c
index 44a91547146e..e5cdafa258dd 100644
--- a/drivers/usb/net/cdc_ether.c
+++ b/drivers/usb/net/cdc_ether.c
@@ -1,6 +1,7 @@
 /*
  * CDC Ethernet based networking peripherals
  * Copyright (C) 2003-2005 by David Brownell
+ * Copyright (C) 2006 by Ole Andre Vadla Ravnas (ActiveSync)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -35,6 +36,29 @@
 #include "usbnet.h"
 
 
+#if defined(CONFIG_USB_NET_RNDIS_HOST) || defined(CONFIG_USB_NET_RNDIS_HOST_MODULE)
+
+static int is_rndis(struct usb_interface_descriptor *desc)
+{
+        return desc->bInterfaceClass == USB_CLASS_COMM
+                && desc->bInterfaceSubClass == 2
+                && desc->bInterfaceProtocol == 0xff;
+}
+
+static int is_activesync(struct usb_interface_descriptor *desc)
+{
+        return desc->bInterfaceClass == USB_CLASS_MISC
+                && desc->bInterfaceSubClass == 1
+                && desc->bInterfaceProtocol == 1;
+}
+
+#else
+
+#define is_rndis(desc)          0
+#define is_activesync(desc)     0
+
+#endif
+
 /*
  * probes control interface, claims data interface, collects the bulk
  * endpoints, activates data interface (if needed), maybe sets MTU.
@@ -71,7 +95,8 @@ int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
         /* this assumes that if there's a non-RNDIS vendor variant
          * of cdc-acm, it'll fail RNDIS requests cleanly.
          */
-        rndis = (intf->cur_altsetting->desc.bInterfaceProtocol == 0xff);
+        rndis = is_rndis(&intf->cur_altsetting->desc)
+                || is_activesync(&intf->cur_altsetting->desc);
 
         memset(info, 0, sizeof *info);
         info->control = intf;
@@ -99,6 +124,23 @@ int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
                                 goto bad_desc;
                         }
                         break;
+                case USB_CDC_ACM_TYPE:
+                        /* paranoia:  disambiguate a "real" vendor-specific
+                         * modem interface from an RNDIS non-modem.
+                         */
+                        if (rndis) {
+                                struct usb_cdc_acm_descriptor *d;
+
+                                d = (void *) buf;
+                                if (d->bmCapabilities) {
+                                        dev_dbg(&intf->dev,
+                                                "ACM capabilities %02x, "
+                                                "not really RNDIS?\n",
+                                                d->bmCapabilities);
+                                        goto bad_desc;
+                                }
+                        }
+                        break;
                 case USB_CDC_UNION_TYPE:
                         if (info->u) {
                                 dev_dbg(&intf->dev, "extra CDC union\n");
@@ -171,7 +213,21 @@ next_desc:
                 buf += buf [0];
         }
 
-        if (!info->header || !info->u || (!rndis && !info->ether)) {
+        /* Microsoft ActiveSync based RNDIS devices lack the CDC descriptors,
+         * so we'll hard-wire the interfaces and not check for descriptors.
+         */
+        if (is_activesync(&intf->cur_altsetting->desc) && !info->u) {
+                info->control = usb_ifnum_to_if(dev->udev, 0);
+                info->data = usb_ifnum_to_if(dev->udev, 1);
+                if (!info->control || !info->data) {
+                        dev_dbg(&intf->dev,
+                                "activesync: master #0/%p slave #1/%p\n",
+                                info->control,
+                                info->data);
+                        goto bad_desc;
+                }
+
+        } else if (!info->header || !info->u || (!rndis && !info->ether)) {
                 dev_dbg(&intf->dev, "missing cdc %s%s%sdescriptor\n",
                         info->header ? "" : "header ",
                         info->u ? "" : "union ",
diff --git a/drivers/usb/net/kaweth.c b/drivers/usb/net/kaweth.c
index fa78326d0bf0..36a989160a68 100644
--- a/drivers/usb/net/kaweth.c
+++ b/drivers/usb/net/kaweth.c
@@ -179,6 +179,7 @@ static struct usb_driver kaweth_driver = {
         .suspend =      kaweth_suspend,
         .resume =       kaweth_resume,
         .id_table =     usb_klsi_table,
+        .supports_autosuspend = 1,
 };
 
 typedef __u8 eth_addr_t[6];
@@ -225,6 +226,7 @@ struct kaweth_device
         struct delayed_work lowmem_work;
 
         struct usb_device *dev;
+        struct usb_interface *intf;
         struct net_device *net;
         wait_queue_head_t term_wait;
 
@@ -662,9 +664,14 @@ static int kaweth_open(struct net_device *net)
 
         dbg("Opening network device.");
 
+        res = usb_autopm_get_interface(kaweth->intf);
+        if (res) {
+                err("Interface cannot be resumed.");
+                return -EIO;
+        }
         res = kaweth_resubmit_rx_urb(kaweth, GFP_KERNEL);
         if (res)
-                return -EIO;
+                goto err_out;
 
         usb_fill_int_urb(
                 kaweth->irq_urb,
@@ -681,7 +688,7 @@ static int kaweth_open(struct net_device *net)
         res = usb_submit_urb(kaweth->irq_urb, GFP_KERNEL);
         if (res) {
                 usb_kill_urb(kaweth->rx_urb);
-                return -EIO;
+                goto err_out;
         }
         kaweth->opened = 1;
 
@@ -689,10 +696,14 @@ static int kaweth_open(struct net_device *net)
 
         kaweth_async_set_rx_mode(kaweth);
         return 0;
+
+err_out:
+        usb_autopm_enable(kaweth->intf);
+        return -EIO;
 }
 
 /****************************************************************
- *     kaweth_close
+ *     kaweth_kill_urbs
  ****************************************************************/
 static void kaweth_kill_urbs(struct kaweth_device *kaweth)
 {
@@ -724,17 +735,29 @@ static int kaweth_close(struct net_device *net)
 
         kaweth->status &= ~KAWETH_STATUS_CLOSING;
 
+        usb_autopm_enable(kaweth->intf);
+
         return 0;
 }
 
 static void kaweth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
+        struct kaweth_device *kaweth = netdev_priv(dev);
 
         strlcpy(info->driver, driver_name, sizeof(info->driver));
+        usb_make_path(kaweth->dev, info->bus_info, sizeof (info->bus_info));
+}
+
+static u32 kaweth_get_link(struct net_device *dev)
+{
+        struct kaweth_device *kaweth = netdev_priv(dev);
+
+        return kaweth->linkstate;
 }
 
 static struct ethtool_ops ops = {
-        .get_drvinfo = kaweth_get_drvinfo
+        .get_drvinfo    = kaweth_get_drvinfo,
+        .get_link       = kaweth_get_link
 };
 
 /****************************************************************
@@ -908,6 +931,7 @@ static int kaweth_suspend(struct usb_interface *intf, pm_message_t message)
         struct kaweth_device *kaweth = usb_get_intfdata(intf);
         unsigned long flags;
 
+        dbg("Suspending device");
         spin_lock_irqsave(&kaweth->device_lock, flags);
         kaweth->status |= KAWETH_STATUS_SUSPENDING;
         spin_unlock_irqrestore(&kaweth->device_lock, flags);
@@ -924,6 +948,7 @@ static int kaweth_resume(struct usb_interface *intf)
         struct kaweth_device *kaweth = usb_get_intfdata(intf);
         unsigned long flags;
 
+        dbg("Resuming device");
         spin_lock_irqsave(&kaweth->device_lock, flags);
         kaweth->status &= ~KAWETH_STATUS_SUSPENDING;
         spin_unlock_irqrestore(&kaweth->device_lock, flags);
@@ -1086,6 +1111,8 @@ err_fw:
 
         dbg("Initializing net device.");
 
+        kaweth->intf = intf;
+
         kaweth->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!kaweth->tx_urb)
                 goto err_free_netdev;
@@ -1265,7 +1292,7 @@ static int kaweth_internal_control_msg(struct usb_device *usb_dev,
 {
         struct urb *urb;
         int retv;
-        int length;
+        int length = 0; /* shut up GCC */
 
         urb = usb_alloc_urb(0, GFP_NOIO);
         if (!urb)
diff --git a/drivers/usb/net/rndis_host.c b/drivers/usb/net/rndis_host.c
index a322a16d9cf8..be888d2d813c 100644
--- a/drivers/usb/net/rndis_host.c
+++ b/drivers/usb/net/rndis_host.c
@@ -49,6 +49,8 @@
  *    - In some cases, MS-Windows will emit undocumented requests; this
  *      matters more to peripheral implementations than host ones.
  *
+ * Moreover there's a no-open-specs variant of RNDIS called "ActiveSync".
+ *
  * For these reasons and others, ** USE OF RNDIS IS STRONGLY DISCOURAGED ** in
  * favor of such non-proprietary alternatives as CDC Ethernet or the newer (and
  * currently rare) "Ethernet Emulation Model" (EEM).
@@ -61,6 +63,9 @@
  *  - control-in:  GET_ENCAPSULATED
  *
  * We'll try to ignore the RESPONSE_AVAILABLE notifications.
+ *
+ * REVISIT some RNDIS implementations seem to have curious issues still
+ * to be resolved.
  */
 struct rndis_msg_hdr {
         __le32  msg_type;                       /* RNDIS_MSG_* */
@@ -71,8 +76,14 @@ struct rndis_msg_hdr {
         // ... and more
 } __attribute__ ((packed));
 
-/* RNDIS defines this (absurdly huge) control timeout */
-#define RNDIS_CONTROL_TIMEOUT_MS        (10 * 1000)
+/* MS-Windows uses this strange size, but RNDIS spec says 1024 minimum */
+#define CONTROL_BUFFER_SIZE             1025
+
+/* RNDIS defines an (absurdly huge) 10 second control timeout,
+ * but ActiveSync seems to use a more usual 5 second timeout
+ * (which matches the USB 2.0 spec).
+ */
+#define RNDIS_CONTROL_TIMEOUT_MS        (5 * 1000)
 
 
 #define ccpu2 __constant_cpu_to_le32
@@ -270,6 +281,7 @@ static void rndis_status(struct usbnet *dev, struct urb *urb)
 static int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf)
 {
         struct cdc_state        *info = (void *) &dev->data;
+        int                     master_ifnum;
         int                     retval;
         unsigned                count;
         __le32                  rsp;
@@ -279,7 +291,7 @@ static int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf)
          * disconnect(): either serialize, or dispatch responses on xid
          */
 
-        /* Issue the request; don't bother byteswapping our xid */
+        /* Issue the request; xid is unique, don't bother byteswapping it */
         if (likely(buf->msg_type != RNDIS_MSG_HALT
                         && buf->msg_type != RNDIS_MSG_RESET)) {
                 xid = dev->xid++;
@@ -287,11 +299,12 @@ static int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf)
                         xid = dev->xid++;
                 buf->request_id = (__force __le32) xid;
         }
+        master_ifnum = info->control->cur_altsetting->desc.bInterfaceNumber;
         retval = usb_control_msg(dev->udev,
                 usb_sndctrlpipe(dev->udev, 0),
                 USB_CDC_SEND_ENCAPSULATED_COMMAND,
                 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                0, info->u->bMasterInterface0,
+                0, master_ifnum,
                 buf, le32_to_cpu(buf->msg_len),
                 RNDIS_CONTROL_TIMEOUT_MS);
         if (unlikely(retval < 0 || xid == 0))
@@ -306,13 +319,13 @@ static int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf)
          */
         rsp = buf->msg_type | RNDIS_MSG_COMPLETION;
         for (count = 0; count < 10; count++) {
-                memset(buf, 0, 1024);
+                memset(buf, 0, CONTROL_BUFFER_SIZE);
                 retval = usb_control_msg(dev->udev,
                         usb_rcvctrlpipe(dev->udev, 0),
                         USB_CDC_GET_ENCAPSULATED_RESPONSE,
                         USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                        0, info->u->bMasterInterface0,
-                        buf, 1024,
+                        0, master_ifnum,
+                        buf, CONTROL_BUFFER_SIZE,
                         RNDIS_CONTROL_TIMEOUT_MS);
                 if (likely(retval >= 8)) {
                         msg_len = le32_to_cpu(buf->msg_len);
@@ -350,7 +363,7 @@ static int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf)
                                         usb_sndctrlpipe(dev->udev, 0),
                                         USB_CDC_SEND_ENCAPSULATED_COMMAND,
                                         USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                                        0, info->u->bMasterInterface0,
+                                        0, master_ifnum,
                                         msg, sizeof *msg,
                                         RNDIS_CONTROL_TIMEOUT_MS);
                                 if (unlikely(retval < 0))
@@ -393,38 +406,64 @@ static int rndis_bind(struct usbnet *dev, struct usb_interface *intf)
         u32                     tmp;
 
         /* we can't rely on i/o from stack working, or stack allocation */
-        u.buf = kmalloc(1024, GFP_KERNEL);
+        u.buf = kmalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
         if (!u.buf)
                 return -ENOMEM;
         retval = usbnet_generic_cdc_bind(dev, intf);
         if (retval < 0)
                 goto fail;
 
-        net->hard_header_len += sizeof (struct rndis_data_hdr);
-
-        /* initialize; max transfer is 16KB at full speed */
         u.init->msg_type = RNDIS_MSG_INIT;
         u.init->msg_len = ccpu2(sizeof *u.init);
         u.init->major_version = ccpu2(1);
         u.init->minor_version = ccpu2(0);
-        u.init->max_transfer_size = ccpu2(net->mtu + net->hard_header_len);
 
+        /* max transfer (in spec) is 0x4000 at full speed, but for
+         * TX we'll stick to one Ethernet packet plus RNDIS framing.
+         * For RX we handle drivers that zero-pad to end-of-packet.
+         * Don't let userspace change these settings.
+         */
+        net->hard_header_len += sizeof (struct rndis_data_hdr);
+        dev->hard_mtu = net->mtu + net->hard_header_len;
+
+        dev->rx_urb_size = dev->hard_mtu + (dev->maxpacket + 1);
+        dev->rx_urb_size &= ~(dev->maxpacket - 1);
+        u.init->max_transfer_size = cpu_to_le32(dev->rx_urb_size);
+
+        net->change_mtu = NULL;
         retval = rndis_command(dev, u.header);
         if (unlikely(retval < 0)) {
                 /* it might not even be an RNDIS device!! */
                 dev_err(&intf->dev, "RNDIS init failed, %d\n", retval);
+                goto fail_and_release;
+        }
+        tmp = le32_to_cpu(u.init_c->max_transfer_size);
+        if (tmp < dev->hard_mtu) {
+                dev_err(&intf->dev,
+                        "dev can't take %u byte packets (max %u)\n",
+                        dev->hard_mtu, tmp);
                 goto fail_and_release;
         }
-        dev->hard_mtu = le32_to_cpu(u.init_c->max_transfer_size);
+
         /* REVISIT:  peripheral "alignment" request is ignored ... */
-        dev_dbg(&intf->dev, "hard mtu %u, align %d\n", dev->hard_mtu,
+        dev_dbg(&intf->dev,
+                "hard mtu %u (%u from dev), rx buflen %Zu, align %d\n",
+                dev->hard_mtu, tmp, dev->rx_urb_size,
                 1 << le32_to_cpu(u.init_c->packet_alignment));
 
-        /* get designated host ethernet address */
-        memset(u.get, 0, sizeof *u.get);
+        /* Get designated host ethernet address.
+         *
+         * Adding a payload exactly the same size as the expected response
+         * payload is an evident requirement MSFT added for ActiveSync.
+         * This undocumented (and nonsensical) issue was found by sniffing
+         * protocol requests from the ActiveSync 4.1 Windows driver.
+         */
+        memset(u.get, 0, sizeof *u.get + 48);
         u.get->msg_type = RNDIS_MSG_QUERY;
-        u.get->msg_len = ccpu2(sizeof *u.get);
+        u.get->msg_len = ccpu2(sizeof *u.get + 48);
         u.get->oid = OID_802_3_PERMANENT_ADDRESS;
+        u.get->len = ccpu2(48);
+        u.get->offset = ccpu2(20);
 
         retval = rndis_command(dev, u.header);
         if (unlikely(retval < 0)) {
@@ -432,7 +471,7 @@ static int rndis_bind(struct usbnet *dev, struct usb_interface *intf)
                 goto fail_and_release;
         }
         tmp = le32_to_cpu(u.get_c->offset);
-        if (unlikely((tmp + 8) > (1024 - ETH_ALEN)
+        if (unlikely((tmp + 8) > (CONTROL_BUFFER_SIZE - ETH_ALEN)
                         || u.get_c->len != ccpu2(ETH_ALEN))) {
                 dev_err(&intf->dev, "rndis ethaddr off %d len %d ?\n",
                         tmp, le32_to_cpu(u.get_c->len));
@@ -598,6 +637,10 @@ static const struct usb_device_id	products [] = {
         /* RNDIS is MSFT's un-official variant of CDC ACM */
         USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
         .driver_info = (unsigned long) &rndis_info,
+}, {
+        /* "ActiveSync" is an undocumented variant of RNDIS, used in WM5 */
+        USB_INTERFACE_INFO(USB_CLASS_MISC, 1, 1),
+        .driver_info = (unsigned long) &rndis_info,
 },
         { },            // END
 };