drivers/net/usb/qmi_wwan.c

   1 /*
   2  * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * version 2 as published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/ethtool.h>
  12 #include <linux/mii.h>
  13 #include <linux/usb.h>
  14 #include <linux/usb/cdc.h>
  15 #include <linux/usb/usbnet.h>
  16 #include <linux/usb/cdc-wdm.h>
  17
  18 /* The name of the CDC Device Management driver */
  19 #define DM_DRIVER "cdc_wdm"
  20
  21 /*
  22  * This driver supports wwan (3G/LTE/?) devices using a vendor
  23  * specific management protocol called Qualcomm MSM Interface (QMI) -
  24  * in addition to the more common AT commands over serial interface
  25  * management
  26  *
  27  * QMI is wrapped in CDC, using CDC encapsulated commands on the
  28  * control ("master") interface of a two-interface CDC Union
  29  * resembling standard CDC ECM.  The devices do not use the control
  30  * interface for any other CDC messages.  Most likely because the
  31  * management protocol is used in place of the standard CDC
  32  * notifications NOTIFY_NETWORK_CONNECTION and NOTIFY_SPEED_CHANGE
  33  *
  34  * Handling a protocol like QMI is out of the scope for any driver.
  35  * It can be exported as a character device using the cdc-wdm driver,
  36  * which will enable userspace applications ("modem managers") to
  37  * handle it.  This may be required to use the network interface
  38  * provided by the driver.
  39  *
  40  * These devices may alternatively/additionally be configured using AT
  41  * commands on any of the serial interfaces driven by the option driver
  42  *
  43  * This driver binds only to the data ("slave") interface to enable
  44  * the cdc-wdm driver to bind to the control interface.  It still
  45  * parses the CDC functional descriptors on the control interface to
  46  *  a) verify that this is indeed a handled interface (CDC Union
  47  *     header lists it as slave)
  48  *  b) get MAC address and other ethernet config from the CDC Ethernet
  49  *     header
  50  *  c) enable user bind requests against the control interface, which
  51  *     is the common way to bind to CDC Ethernet Control Model type
  52  *     interfaces
  53  *  d) provide a hint to the user about which interface is the
  54  *     corresponding management interface
  55  */
  56
  57 static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf)
  58 {
  59         int status = -1;
  60         struct usb_interface *control = NULL;
  61         u8 *buf = intf->cur_altsetting->extra;
  62         int len = intf->cur_altsetting->extralen;
  63         struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;
  64         struct usb_cdc_union_desc *cdc_union = NULL;
  65         struct usb_cdc_ether_desc *cdc_ether = NULL;
  66         u32 required = 1 << USB_CDC_HEADER_TYPE | 1 << USB_CDC_UNION_TYPE;
  67         u32 found = 0;
  68         atomic_t *pmcount = (void *)&dev->data[1];
  69
  70         atomic_set(pmcount, 0);
  71
  72         /*
  73          * assume a data interface has no additional descriptors and
  74          * that the control and data interface are numbered
  75          * consecutively - this holds for the Huawei device at least
  76          */
  77         if (len == 0 && desc->bInterfaceNumber > 0) {
  78                 control = usb_ifnum_to_if(dev->udev, desc->bInterfaceNumber - 1);
  79                 if (!control)
  80                         goto err;
  81
  82                 buf = control->cur_altsetting->extra;
  83                 len = control->cur_altsetting->extralen;
  84                 dev_dbg(&intf->dev, "guessing \"control\" => %s, \"data\" => this\n",
  85                         dev_name(&control->dev));
  86         }
  87
  88         while (len > 3) {
  89                 struct usb_descriptor_header *h = (void *)buf;
  90
  91                 /* ignore any misplaced descriptors */
  92                 if (h->bDescriptorType != USB_DT_CS_INTERFACE)
  93                         goto next_desc;
  94
  95                 /* buf[2] is CDC descriptor subtype */
  96                 switch (buf[2]) {
  97                 case USB_CDC_HEADER_TYPE:
  98                         if (found & 1 << USB_CDC_HEADER_TYPE) {
  99                                 dev_dbg(&intf->dev, "extra CDC header\n");
 100                                 goto err;
 101                         }
 102                         if (h->bLength != sizeof(struct usb_cdc_header_desc)) {
 103                                 dev_dbg(&intf->dev, "CDC header len %u\n", h->bLength);
 104                                 goto err;
 105                         }
 106                         break;
 107                 case USB_CDC_UNION_TYPE:
 108                         if (found & 1 << USB_CDC_UNION_TYPE) {
 109                                 dev_dbg(&intf->dev, "extra CDC union\n");
 110                                 goto err;
 111                         }
 112                         if (h->bLength != sizeof(struct usb_cdc_union_desc)) {
 113                                 dev_dbg(&intf->dev, "CDC union len %u\n", h->bLength);
 114                                 goto err;
 115                         }
 116                         cdc_union = (struct usb_cdc_union_desc *)buf;
 117                         break;
 118                 case USB_CDC_ETHERNET_TYPE:
 119                         if (found & 1 << USB_CDC_ETHERNET_TYPE) {
 120                                 dev_dbg(&intf->dev, "extra CDC ether\n");
 121                                 goto err;
 122                         }
 123                         if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {
 124                                 dev_dbg(&intf->dev, "CDC ether len %u\n",  h->bLength);
 125                                 goto err;
 126                         }
 127                         cdc_ether = (struct usb_cdc_ether_desc *)buf;
 128                         break;
 129                 }
 130
 131                 /*
 132                  * Remember which CDC functional descriptors we've seen.  Works
 133                  * for all types we care about, of which USB_CDC_ETHERNET_TYPE
 134                  * (0x0f) is the highest numbered
 135                  */
 136                 if (buf[2] < 32)
 137                         found |= 1 << buf[2];
 138
 139 next_desc:
 140                 len -= h->bLength;
 141                 buf += h->bLength;
 142         }
 143
 144         /* did we find all the required ones? */
 145         if ((found & required) != required) {
 146                 dev_err(&intf->dev, "CDC functional descriptors missing\n");
 147                 goto err;
 148         }
 149
 150         /* give the user a helpful hint if trying to bind to the wrong interface */
 151         if (cdc_union && desc->bInterfaceNumber == cdc_union->bMasterInterface0) {
 152                 dev_err(&intf->dev, "leaving \"control\" interface for " DM_DRIVER " - try binding to %s instead!\n",
 153                         dev_name(&usb_ifnum_to_if(dev->udev, cdc_union->bSlaveInterface0)->dev));
 154                 goto err;
 155         }
 156
 157         /* errors aren't fatal - we can live with the dynamic address */
 158         if (cdc_ether) {
 159                 dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);
 160                 usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);
 161         }
 162
 163         /* success! point the user to the management interface */
 164         if (control)
 165                 dev_info(&intf->dev, "Use \"" DM_DRIVER "\" for QMI interface %s\n",
 166                         dev_name(&control->dev));
 167
 168         /* XXX: add a sysfs symlink somewhere to help management applications find it? */
 169
 170         /* collect bulk endpoints now that we know intf == "data" interface */
 171         status = usbnet_get_endpoints(dev, intf);
 172
 173 err:
 174         return status;
 175 }
 176
 177 /* using a counter to merge subdriver requests with our own into a combined state */
 178 static int qmi_wwan_manage_power(struct usbnet *dev, int on)
 179 {
 180         atomic_t *pmcount = (void *)&dev->data[1];
 181         int rv = 0;
 182
 183         dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__, atomic_read(pmcount), on);
 184
 185         if ((on && atomic_add_return(1, pmcount) == 1) || (!on && atomic_dec_and_test(pmcount))) {
 186                 /* need autopm_get/put here to ensure the usbcore sees the new value */
 187                 rv = usb_autopm_get_interface(dev->intf);
 188                 if (rv < 0)
 189                         goto err;
 190                 dev->intf->needs_remote_wakeup = on;
 191                 usb_autopm_put_interface(dev->intf);
 192         }
 193 err:
 194         return rv;
 195 }
 196
 197 static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)
 198 {
 199         struct usbnet *dev = usb_get_intfdata(intf);
 200         return qmi_wwan_manage_power(dev, on);
 201 }
 202
 203 /* Some devices combine the "control" and "data" functions into a
 204  * single interface with all three endpoints: interrupt + bulk in and
 205  * out
 206  *
 207  * Setting up cdc-wdm as a subdriver owning the interrupt endpoint
 208  * will let it provide userspace access to the encapsulated QMI
 209  * protocol without interfering with the usbnet operations.
 210   */
 211 static int qmi_wwan_bind_shared(struct usbnet *dev, struct usb_interface *intf)
 212 {
 213         int rv;
 214         struct usb_driver *subdriver = NULL;
 215         atomic_t *pmcount = (void *)&dev->data[1];
 216
 217         atomic_set(pmcount, 0);
 218
 219         /* collect all three endpoints */
 220         rv = usbnet_get_endpoints(dev, intf);
 221         if (rv < 0)
 222                 goto err;
 223
 224         /* require interrupt endpoint for subdriver */
 225         if (!dev->status) {
 226                 rv = -EINVAL;
 227                 goto err;
 228         }
 229
 230         subdriver = usb_cdc_wdm_register(intf, &dev->status->desc, 512, &qmi_wwan_cdc_wdm_manage_power);
 231         if (IS_ERR(subdriver)) {
 232                 rv = PTR_ERR(subdriver);
 233                 goto err;
 234         }
 235
 236         /* can't let usbnet use the interrupt endpoint */
 237         dev->status = NULL;
 238
 239         /* save subdriver struct for suspend/resume wrappers */
 240         dev->data[0] = (unsigned long)subdriver;
 241
 242 err:
 243         return rv;
 244 }
 245
 246 static void qmi_wwan_unbind_shared(struct usbnet *dev, struct usb_interface *intf)
 247 {
 248         struct usb_driver *subdriver = (void *)dev->data[0];
 249
 250         if (subdriver && subdriver->disconnect)
 251                 subdriver->disconnect(intf);
 252
 253         dev->data[0] = (unsigned long)NULL;
 254 }
 255
 256 /* suspend/resume wrappers calling both usbnet and the cdc-wdm
 257  * subdriver if present.
 258  *
 259  * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide
 260  * wrappers for those without adding usbnet reset support first.
 261  */
 262 static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message)
 263 {
 264         struct usbnet *dev = usb_get_intfdata(intf);
 265         struct usb_driver *subdriver = (void *)dev->data[0];
 266         int ret;
 267
 268         ret = usbnet_suspend(intf, message);
 269         if (ret < 0)
 270                 goto err;
 271
 272         if (subdriver && subdriver->suspend)
 273                 ret = subdriver->suspend(intf, message);
 274         if (ret < 0)
 275                 usbnet_resume(intf);
 276 err:
 277         return ret;
 278 }
 279
 280 static int qmi_wwan_resume(struct usb_interface *intf)
 281 {
 282         struct usbnet *dev = usb_get_intfdata(intf);
 283         struct usb_driver *subdriver = (void *)dev->data[0];
 284         int ret = 0;
 285
 286         if (subdriver && subdriver->resume)
 287                 ret = subdriver->resume(intf);
 288         if (ret < 0)
 289                 goto err;
 290         ret = usbnet_resume(intf);
 291         if (ret < 0 && subdriver && subdriver->resume && subdriver->suspend)
 292                 subdriver->suspend(intf, PMSG_SUSPEND);
 293 err:
 294         return ret;
 295 }
 296
 297
 298 static const struct driver_info qmi_wwan_info = {
 299         .description    = "QMI speaking wwan device",
 300         .flags          = FLAG_WWAN,
 301         .bind           = qmi_wwan_bind,
 302         .manage_power   = qmi_wwan_manage_power,
 303 };
 304
 305 static const struct driver_info qmi_wwan_shared = {
 306         .description    = "QMI speaking wwan device with combined interface",
 307         .flags          = FLAG_WWAN,
 308         .bind           = qmi_wwan_bind_shared,
 309         .unbind         = qmi_wwan_unbind_shared,
 310         .manage_power   = qmi_wwan_manage_power,
 311 };
 312
 313 #define HUAWEI_VENDOR_ID        0x12D1
 314
 315 static const struct usb_device_id products[] = {
 316         {       /* Huawei E392, E398 and possibly others sharing both device id and more... */
 317                 .match_flags        = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO,
 318                 .idVendor           = HUAWEI_VENDOR_ID,
 319                 .bInterfaceClass    = USB_CLASS_VENDOR_SPEC,
 320                 .bInterfaceSubClass = 1,
 321                 .bInterfaceProtocol = 8, /* NOTE: This is the *slave* interface of the CDC Union! */
 322                 .driver_info        = (unsigned long)&qmi_wwan_info,
 323         },
 324         {       /* Huawei E392, E398 and possibly others in "Windows mode"
 325                  * using a combined control and data interface without any CDC
 326                  * functional descriptors
 327                  */
 328                 .match_flags        = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO,
 329                 .idVendor           = HUAWEI_VENDOR_ID,
 330                 .bInterfaceClass    = USB_CLASS_VENDOR_SPEC,
 331                 .bInterfaceSubClass = 1,
 332                 .bInterfaceProtocol = 17,
 333                 .driver_info        = (unsigned long)&qmi_wwan_shared,
 334         },
 335         { }     /* END */
 336 };
 337 MODULE_DEVICE_TABLE(usb, products);
 338
 339 static struct usb_driver qmi_wwan_driver = {
 340         .name                 = "qmi_wwan",
 341         .id_table             = products,
 342         .probe                = usbnet_probe,
 343         .disconnect           = usbnet_disconnect,
 344         .suspend              = qmi_wwan_suspend,
 345         .resume               = qmi_wwan_resume,
 346         .reset_resume         = qmi_wwan_resume,
 347         .supports_autosuspend = 1,
 348 };
 349
 350 static int __init qmi_wwan_init(void)
 351 {
 352         return usb_register(&qmi_wwan_driver);
 353 }
 354 module_init(qmi_wwan_init);
 355
 356 static void __exit qmi_wwan_exit(void)
 357 {
 358         usb_deregister(&qmi_wwan_driver);
 359 }
 360 module_exit(qmi_wwan_exit);
 361
 362 MODULE_AUTHOR("Bjørn Mork <bjorn@mork.no>");
 363 MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver");
 364 MODULE_LICENSE("GPL");