net: qmi_wwan: add Yota / Megafon M100-1 4g modem
[~shefty/rdma-dev.git] / drivers / net / usb / qmi_wwan.c
1 /*
2  * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
3  *
4  * The probing code is heavily inspired by cdc_ether, which is:
5  * Copyright (C) 2003-2005 by David Brownell
6  * Copyright (C) 2006 by Ole Andre Vadla Ravnas (ActiveSync)
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  */
12
13 #include <linux/module.h>
14 #include <linux/netdevice.h>
15 #include <linux/ethtool.h>
16 #include <linux/mii.h>
17 #include <linux/usb.h>
18 #include <linux/usb/cdc.h>
19 #include <linux/usb/usbnet.h>
20 #include <linux/usb/cdc-wdm.h>
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  * Alternatively, control and data functions can be combined in a
35  * single USB interface.
36  *
37  * Handling a protocol like QMI is out of the scope for any driver.
38  * It is exported as a character device using the cdc-wdm driver as
39  * a subdriver, enabling userspace applications ("modem managers") to
40  * handle it.
41  *
42  * These devices may alternatively/additionally be configured using AT
43  * commands on a serial interface
44  */
45
46 /* driver specific data */
47 struct qmi_wwan_state {
48         struct usb_driver *subdriver;
49         atomic_t pmcount;
50         unsigned long unused;
51         struct usb_interface *control;
52         struct usb_interface *data;
53 };
54
55 /* using a counter to merge subdriver requests with our own into a combined state */
56 static int qmi_wwan_manage_power(struct usbnet *dev, int on)
57 {
58         struct qmi_wwan_state *info = (void *)&dev->data;
59         int rv = 0;
60
61         dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__, atomic_read(&info->pmcount), on);
62
63         if ((on && atomic_add_return(1, &info->pmcount) == 1) || (!on && atomic_dec_and_test(&info->pmcount))) {
64                 /* need autopm_get/put here to ensure the usbcore sees the new value */
65                 rv = usb_autopm_get_interface(dev->intf);
66                 if (rv < 0)
67                         goto err;
68                 dev->intf->needs_remote_wakeup = on;
69                 usb_autopm_put_interface(dev->intf);
70         }
71 err:
72         return rv;
73 }
74
75 static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)
76 {
77         struct usbnet *dev = usb_get_intfdata(intf);
78
79         /* can be called while disconnecting */
80         if (!dev)
81                 return 0;
82         return qmi_wwan_manage_power(dev, on);
83 }
84
85 /* collect all three endpoints and register subdriver */
86 static int qmi_wwan_register_subdriver(struct usbnet *dev)
87 {
88         int rv;
89         struct usb_driver *subdriver = NULL;
90         struct qmi_wwan_state *info = (void *)&dev->data;
91
92         /* collect bulk endpoints */
93         rv = usbnet_get_endpoints(dev, info->data);
94         if (rv < 0)
95                 goto err;
96
97         /* update status endpoint if separate control interface */
98         if (info->control != info->data)
99                 dev->status = &info->control->cur_altsetting->endpoint[0];
100
101         /* require interrupt endpoint for subdriver */
102         if (!dev->status) {
103                 rv = -EINVAL;
104                 goto err;
105         }
106
107         /* for subdriver power management */
108         atomic_set(&info->pmcount, 0);
109
110         /* register subdriver */
111         subdriver = usb_cdc_wdm_register(info->control, &dev->status->desc, 4096, &qmi_wwan_cdc_wdm_manage_power);
112         if (IS_ERR(subdriver)) {
113                 dev_err(&info->control->dev, "subdriver registration failed\n");
114                 rv = PTR_ERR(subdriver);
115                 goto err;
116         }
117
118         /* prevent usbnet from using status endpoint */
119         dev->status = NULL;
120
121         /* save subdriver struct for suspend/resume wrappers */
122         info->subdriver = subdriver;
123
124 err:
125         return rv;
126 }
127
128 static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf)
129 {
130         int status = -1;
131         u8 *buf = intf->cur_altsetting->extra;
132         int len = intf->cur_altsetting->extralen;
133         struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;
134         struct usb_cdc_union_desc *cdc_union = NULL;
135         struct usb_cdc_ether_desc *cdc_ether = NULL;
136         u32 found = 0;
137         struct usb_driver *driver = driver_of(intf);
138         struct qmi_wwan_state *info = (void *)&dev->data;
139
140         BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) < sizeof(struct qmi_wwan_state)));
141
142         /* control and data is shared? */
143         if (intf->cur_altsetting->desc.bNumEndpoints == 3) {
144                 info->control = intf;
145                 info->data = intf;
146                 goto shared;
147         }
148
149         /* else require a single interrupt status endpoint on control intf */
150         if (intf->cur_altsetting->desc.bNumEndpoints != 1)
151                 goto err;
152
153         /* and a number of CDC descriptors */
154         while (len > 3) {
155                 struct usb_descriptor_header *h = (void *)buf;
156
157                 /* ignore any misplaced descriptors */
158                 if (h->bDescriptorType != USB_DT_CS_INTERFACE)
159                         goto next_desc;
160
161                 /* buf[2] is CDC descriptor subtype */
162                 switch (buf[2]) {
163                 case USB_CDC_HEADER_TYPE:
164                         if (found & 1 << USB_CDC_HEADER_TYPE) {
165                                 dev_dbg(&intf->dev, "extra CDC header\n");
166                                 goto err;
167                         }
168                         if (h->bLength != sizeof(struct usb_cdc_header_desc)) {
169                                 dev_dbg(&intf->dev, "CDC header len %u\n", h->bLength);
170                                 goto err;
171                         }
172                         break;
173                 case USB_CDC_UNION_TYPE:
174                         if (found & 1 << USB_CDC_UNION_TYPE) {
175                                 dev_dbg(&intf->dev, "extra CDC union\n");
176                                 goto err;
177                         }
178                         if (h->bLength != sizeof(struct usb_cdc_union_desc)) {
179                                 dev_dbg(&intf->dev, "CDC union len %u\n", h->bLength);
180                                 goto err;
181                         }
182                         cdc_union = (struct usb_cdc_union_desc *)buf;
183                         break;
184                 case USB_CDC_ETHERNET_TYPE:
185                         if (found & 1 << USB_CDC_ETHERNET_TYPE) {
186                                 dev_dbg(&intf->dev, "extra CDC ether\n");
187                                 goto err;
188                         }
189                         if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {
190                                 dev_dbg(&intf->dev, "CDC ether len %u\n",  h->bLength);
191                                 goto err;
192                         }
193                         cdc_ether = (struct usb_cdc_ether_desc *)buf;
194                         break;
195                 }
196
197                 /*
198                  * Remember which CDC functional descriptors we've seen.  Works
199                  * for all types we care about, of which USB_CDC_ETHERNET_TYPE
200                  * (0x0f) is the highest numbered
201                  */
202                 if (buf[2] < 32)
203                         found |= 1 << buf[2];
204
205 next_desc:
206                 len -= h->bLength;
207                 buf += h->bLength;
208         }
209
210         /* did we find all the required ones? */
211         if (!(found & (1 << USB_CDC_HEADER_TYPE)) ||
212             !(found & (1 << USB_CDC_UNION_TYPE))) {
213                 dev_err(&intf->dev, "CDC functional descriptors missing\n");
214                 goto err;
215         }
216
217         /* verify CDC Union */
218         if (desc->bInterfaceNumber != cdc_union->bMasterInterface0) {
219                 dev_err(&intf->dev, "bogus CDC Union: master=%u\n", cdc_union->bMasterInterface0);
220                 goto err;
221         }
222
223         /* need to save these for unbind */
224         info->control = intf;
225         info->data = usb_ifnum_to_if(dev->udev, cdc_union->bSlaveInterface0);
226         if (!info->data) {
227                 dev_err(&intf->dev, "bogus CDC Union: slave=%u\n", cdc_union->bSlaveInterface0);
228                 goto err;
229         }
230
231         /* errors aren't fatal - we can live with the dynamic address */
232         if (cdc_ether) {
233                 dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);
234                 usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);
235         }
236
237         /* claim data interface and set it up */
238         status = usb_driver_claim_interface(driver, info->data, dev);
239         if (status < 0)
240                 goto err;
241
242 shared:
243         status = qmi_wwan_register_subdriver(dev);
244         if (status < 0 && info->control != info->data) {
245                 usb_set_intfdata(info->data, NULL);
246                 usb_driver_release_interface(driver, info->data);
247         }
248
249 err:
250         return status;
251 }
252
253 static void qmi_wwan_unbind(struct usbnet *dev, struct usb_interface *intf)
254 {
255         struct qmi_wwan_state *info = (void *)&dev->data;
256         struct usb_driver *driver = driver_of(intf);
257         struct usb_interface *other;
258
259         if (info->subdriver && info->subdriver->disconnect)
260                 info->subdriver->disconnect(info->control);
261
262         /* allow user to unbind using either control or data */
263         if (intf == info->control)
264                 other = info->data;
265         else
266                 other = info->control;
267
268         /* only if not shared */
269         if (other && intf != other) {
270                 usb_set_intfdata(other, NULL);
271                 usb_driver_release_interface(driver, other);
272         }
273
274         info->subdriver = NULL;
275         info->data = NULL;
276         info->control = NULL;
277 }
278
279 /* suspend/resume wrappers calling both usbnet and the cdc-wdm
280  * subdriver if present.
281  *
282  * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide
283  * wrappers for those without adding usbnet reset support first.
284  */
285 static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message)
286 {
287         struct usbnet *dev = usb_get_intfdata(intf);
288         struct qmi_wwan_state *info = (void *)&dev->data;
289         int ret;
290
291         ret = usbnet_suspend(intf, message);
292         if (ret < 0)
293                 goto err;
294
295         if (intf == info->control && info->subdriver && info->subdriver->suspend)
296                 ret = info->subdriver->suspend(intf, message);
297         if (ret < 0)
298                 usbnet_resume(intf);
299 err:
300         return ret;
301 }
302
303 static int qmi_wwan_resume(struct usb_interface *intf)
304 {
305         struct usbnet *dev = usb_get_intfdata(intf);
306         struct qmi_wwan_state *info = (void *)&dev->data;
307         int ret = 0;
308         bool callsub = (intf == info->control && info->subdriver && info->subdriver->resume);
309
310         if (callsub)
311                 ret = info->subdriver->resume(intf);
312         if (ret < 0)
313                 goto err;
314         ret = usbnet_resume(intf);
315         if (ret < 0 && callsub && info->subdriver->suspend)
316                 info->subdriver->suspend(intf, PMSG_SUSPEND);
317 err:
318         return ret;
319 }
320
321 static const struct driver_info qmi_wwan_info = {
322         .description    = "WWAN/QMI device",
323         .flags          = FLAG_WWAN,
324         .bind           = qmi_wwan_bind,
325         .unbind         = qmi_wwan_unbind,
326         .manage_power   = qmi_wwan_manage_power,
327 };
328
329 #define HUAWEI_VENDOR_ID        0x12D1
330
331 /* map QMI/wwan function by a fixed interface number */
332 #define QMI_FIXED_INTF(vend, prod, num) \
333         USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \
334         .driver_info = (unsigned long)&qmi_wwan_info
335
336 /* Gobi 1000 QMI/wwan interface number is 3 according to qcserial */
337 #define QMI_GOBI1K_DEVICE(vend, prod) \
338         QMI_FIXED_INTF(vend, prod, 3)
339
340 /* Gobi 2000/3000 QMI/wwan interface number is 0 according to qcserial */
341 #define QMI_GOBI_DEVICE(vend, prod) \
342         QMI_FIXED_INTF(vend, prod, 0)
343
344 static const struct usb_device_id products[] = {
345         /* 1. CDC ECM like devices match on the control interface */
346         {       /* Huawei E392, E398 and possibly others sharing both device id and more... */
347                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 9),
348                 .driver_info        = (unsigned long)&qmi_wwan_info,
349         },
350         {       /* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */
351                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 57),
352                 .driver_info        = (unsigned long)&qmi_wwan_info,
353         },
354         {       /* HUAWEI_INTERFACE_NDIS_CONTROL_QUALCOMM */
355                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x69),
356                 .driver_info        = (unsigned long)&qmi_wwan_info,
357         },
358
359         /* 2. Combined interface devices matching on class+protocol */
360         {       /* Huawei E367 and possibly others in "Windows mode" */
361                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 7),
362                 .driver_info        = (unsigned long)&qmi_wwan_info,
363         },
364         {       /* Huawei E392, E398 and possibly others in "Windows mode" */
365                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 17),
366                 .driver_info        = (unsigned long)&qmi_wwan_info,
367         },
368         {       /* HUAWEI_NDIS_SINGLE_INTERFACE_VDF */
369                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x37),
370                 .driver_info        = (unsigned long)&qmi_wwan_info,
371         },
372         {       /* HUAWEI_INTERFACE_NDIS_HW_QUALCOMM */
373                 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x67),
374                 .driver_info        = (unsigned long)&qmi_wwan_info,
375         },
376         {       /* Pantech UML290, P4200 and more */
377                 USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf0, 0xff),
378                 .driver_info        = (unsigned long)&qmi_wwan_info,
379         },
380         {       /* Pantech UML290 - newer firmware */
381                 USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf1, 0xff),
382                 .driver_info        = (unsigned long)&qmi_wwan_info,
383         },
384         {       /* Novatel USB551L and MC551 */
385                 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0xb001,
386                                               USB_CLASS_COMM,
387                                               USB_CDC_SUBCLASS_ETHERNET,
388                                               USB_CDC_PROTO_NONE),
389                 .driver_info        = (unsigned long)&qmi_wwan_info,
390         },
391         {       /* Novatel E362 */
392                 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0x9010,
393                                               USB_CLASS_COMM,
394                                               USB_CDC_SUBCLASS_ETHERNET,
395                                               USB_CDC_PROTO_NONE),
396                 .driver_info        = (unsigned long)&qmi_wwan_info,
397         },
398         {       /* Dell Wireless 5800 (Novatel E362) */
399                 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8195,
400                                               USB_CLASS_COMM,
401                                               USB_CDC_SUBCLASS_ETHERNET,
402                                               USB_CDC_PROTO_NONE),
403                 .driver_info        = (unsigned long)&qmi_wwan_info,
404         },
405         {       /* Dell Wireless 5800 V2 (Novatel E362) */
406                 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8196,
407                                               USB_CLASS_COMM,
408                                               USB_CDC_SUBCLASS_ETHERNET,
409                                               USB_CDC_PROTO_NONE),
410                 .driver_info        = (unsigned long)&qmi_wwan_info,
411         },
412
413         /* 3. Combined interface devices matching on interface number */
414         {QMI_FIXED_INTF(0x0408, 0xea42, 4)},    /* Yota / Megafon M100-1 */
415         {QMI_FIXED_INTF(0x12d1, 0x140c, 1)},    /* Huawei E173 */
416         {QMI_FIXED_INTF(0x19d2, 0x0002, 1)},
417         {QMI_FIXED_INTF(0x19d2, 0x0012, 1)},
418         {QMI_FIXED_INTF(0x19d2, 0x0017, 3)},
419         {QMI_FIXED_INTF(0x19d2, 0x0021, 4)},
420         {QMI_FIXED_INTF(0x19d2, 0x0025, 1)},
421         {QMI_FIXED_INTF(0x19d2, 0x0031, 4)},
422         {QMI_FIXED_INTF(0x19d2, 0x0042, 4)},
423         {QMI_FIXED_INTF(0x19d2, 0x0049, 5)},
424         {QMI_FIXED_INTF(0x19d2, 0x0052, 4)},
425         {QMI_FIXED_INTF(0x19d2, 0x0055, 1)},    /* ZTE (Vodafone) K3520-Z */
426         {QMI_FIXED_INTF(0x19d2, 0x0058, 4)},
427         {QMI_FIXED_INTF(0x19d2, 0x0063, 4)},    /* ZTE (Vodafone) K3565-Z */
428         {QMI_FIXED_INTF(0x19d2, 0x0104, 4)},    /* ZTE (Vodafone) K4505-Z */
429         {QMI_FIXED_INTF(0x19d2, 0x0113, 5)},
430         {QMI_FIXED_INTF(0x19d2, 0x0118, 5)},
431         {QMI_FIXED_INTF(0x19d2, 0x0121, 5)},
432         {QMI_FIXED_INTF(0x19d2, 0x0123, 4)},
433         {QMI_FIXED_INTF(0x19d2, 0x0124, 5)},
434         {QMI_FIXED_INTF(0x19d2, 0x0125, 6)},
435         {QMI_FIXED_INTF(0x19d2, 0x0126, 5)},
436         {QMI_FIXED_INTF(0x19d2, 0x0130, 1)},
437         {QMI_FIXED_INTF(0x19d2, 0x0133, 3)},
438         {QMI_FIXED_INTF(0x19d2, 0x0141, 5)},
439         {QMI_FIXED_INTF(0x19d2, 0x0157, 5)},    /* ZTE MF683 */
440         {QMI_FIXED_INTF(0x19d2, 0x0158, 3)},
441         {QMI_FIXED_INTF(0x19d2, 0x0167, 4)},    /* ZTE MF820D */
442         {QMI_FIXED_INTF(0x19d2, 0x0168, 4)},
443         {QMI_FIXED_INTF(0x19d2, 0x0176, 3)},
444         {QMI_FIXED_INTF(0x19d2, 0x0178, 3)},
445         {QMI_FIXED_INTF(0x19d2, 0x0191, 4)},    /* ZTE EuFi890 */
446         {QMI_FIXED_INTF(0x19d2, 0x0199, 1)},    /* ZTE MF820S */
447         {QMI_FIXED_INTF(0x19d2, 0x0200, 1)},
448         {QMI_FIXED_INTF(0x19d2, 0x0257, 3)},    /* ZTE MF821 */
449         {QMI_FIXED_INTF(0x19d2, 0x0265, 4)},    /* ONDA MT8205 4G LTE */
450         {QMI_FIXED_INTF(0x19d2, 0x0284, 4)},    /* ZTE MF880 */
451         {QMI_FIXED_INTF(0x19d2, 0x0326, 4)},    /* ZTE MF821D */
452         {QMI_FIXED_INTF(0x19d2, 0x1008, 4)},    /* ZTE (Vodafone) K3570-Z */
453         {QMI_FIXED_INTF(0x19d2, 0x1010, 4)},    /* ZTE (Vodafone) K3571-Z */
454         {QMI_FIXED_INTF(0x19d2, 0x1012, 4)},
455         {QMI_FIXED_INTF(0x19d2, 0x1018, 3)},    /* ZTE (Vodafone) K5006-Z */
456         {QMI_FIXED_INTF(0x19d2, 0x1021, 2)},
457         {QMI_FIXED_INTF(0x19d2, 0x1245, 4)},
458         {QMI_FIXED_INTF(0x19d2, 0x1247, 4)},
459         {QMI_FIXED_INTF(0x19d2, 0x1252, 4)},
460         {QMI_FIXED_INTF(0x19d2, 0x1254, 4)},
461         {QMI_FIXED_INTF(0x19d2, 0x1255, 3)},
462         {QMI_FIXED_INTF(0x19d2, 0x1255, 4)},
463         {QMI_FIXED_INTF(0x19d2, 0x1256, 4)},
464         {QMI_FIXED_INTF(0x19d2, 0x1401, 2)},
465         {QMI_FIXED_INTF(0x19d2, 0x1402, 2)},    /* ZTE MF60 */
466         {QMI_FIXED_INTF(0x19d2, 0x1424, 2)},
467         {QMI_FIXED_INTF(0x19d2, 0x1425, 2)},
468         {QMI_FIXED_INTF(0x19d2, 0x1426, 2)},    /* ZTE MF91 */
469         {QMI_FIXED_INTF(0x19d2, 0x2002, 4)},    /* ZTE (Vodafone) K3765-Z */
470         {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)},    /* Sierra Wireless MC7700 */
471         {QMI_FIXED_INTF(0x114f, 0x68a2, 8)},    /* Sierra Wireless MC7750 */
472         {QMI_FIXED_INTF(0x1199, 0x68a2, 8)},    /* Sierra Wireless MC7710 in QMI mode */
473         {QMI_FIXED_INTF(0x1199, 0x68a2, 19)},   /* Sierra Wireless MC7710 in QMI mode */
474         {QMI_FIXED_INTF(0x1199, 0x901c, 8)},    /* Sierra Wireless EM7700 */
475         {QMI_FIXED_INTF(0x1bbb, 0x011e, 4)},    /* Telekom Speedstick LTE II (Alcatel One Touch L100V LTE) */
476         {QMI_FIXED_INTF(0x2357, 0x0201, 4)},    /* TP-LINK HSUPA Modem MA180 */
477         {QMI_FIXED_INTF(0x1bc7, 0x1200, 5)},    /* Telit LE920 */
478
479         /* 4. Gobi 1000 devices */
480         {QMI_GOBI1K_DEVICE(0x05c6, 0x9212)},    /* Acer Gobi Modem Device */
481         {QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)},    /* HP un2400 Gobi Modem Device */
482         {QMI_GOBI1K_DEVICE(0x04da, 0x250d)},    /* Panasonic Gobi Modem device */
483         {QMI_GOBI1K_DEVICE(0x413c, 0x8172)},    /* Dell Gobi Modem device */
484         {QMI_GOBI1K_DEVICE(0x1410, 0xa001)},    /* Novatel Gobi Modem device */
485         {QMI_GOBI1K_DEVICE(0x0b05, 0x1776)},    /* Asus Gobi Modem device */
486         {QMI_GOBI1K_DEVICE(0x19d2, 0xfff3)},    /* ONDA Gobi Modem device */
487         {QMI_GOBI1K_DEVICE(0x05c6, 0x9001)},    /* Generic Gobi Modem device */
488         {QMI_GOBI1K_DEVICE(0x05c6, 0x9002)},    /* Generic Gobi Modem device */
489         {QMI_GOBI1K_DEVICE(0x05c6, 0x9202)},    /* Generic Gobi Modem device */
490         {QMI_GOBI1K_DEVICE(0x05c6, 0x9203)},    /* Generic Gobi Modem device */
491         {QMI_GOBI1K_DEVICE(0x05c6, 0x9222)},    /* Generic Gobi Modem device */
492         {QMI_GOBI1K_DEVICE(0x05c6, 0x9009)},    /* Generic Gobi Modem device */
493
494         /* 5. Gobi 2000 and 3000 devices */
495         {QMI_GOBI_DEVICE(0x413c, 0x8186)},      /* Dell Gobi 2000 Modem device (N0218, VU936) */
496         {QMI_GOBI_DEVICE(0x413c, 0x8194)},      /* Dell Gobi 3000 Composite */
497         {QMI_GOBI_DEVICE(0x05c6, 0x920b)},      /* Generic Gobi 2000 Modem device */
498         {QMI_GOBI_DEVICE(0x05c6, 0x920d)},      /* Gobi 3000 Composite */
499         {QMI_GOBI_DEVICE(0x05c6, 0x9225)},      /* Sony Gobi 2000 Modem device (N0279, VU730) */
500         {QMI_GOBI_DEVICE(0x05c6, 0x9245)},      /* Samsung Gobi 2000 Modem device (VL176) */
501         {QMI_GOBI_DEVICE(0x03f0, 0x251d)},      /* HP Gobi 2000 Modem device (VP412) */
502         {QMI_GOBI_DEVICE(0x05c6, 0x9215)},      /* Acer Gobi 2000 Modem device (VP413) */
503         {QMI_GOBI_DEVICE(0x05c6, 0x9265)},      /* Asus Gobi 2000 Modem device (VR305) */
504         {QMI_GOBI_DEVICE(0x05c6, 0x9235)},      /* Top Global Gobi 2000 Modem device (VR306) */
505         {QMI_GOBI_DEVICE(0x05c6, 0x9275)},      /* iRex Technologies Gobi 2000 Modem device (VR307) */
506         {QMI_GOBI_DEVICE(0x1199, 0x68a5)},      /* Sierra Wireless Modem */
507         {QMI_GOBI_DEVICE(0x1199, 0x68a9)},      /* Sierra Wireless Modem */
508         {QMI_GOBI_DEVICE(0x1199, 0x9001)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
509         {QMI_GOBI_DEVICE(0x1199, 0x9002)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
510         {QMI_GOBI_DEVICE(0x1199, 0x9003)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
511         {QMI_GOBI_DEVICE(0x1199, 0x9004)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
512         {QMI_GOBI_DEVICE(0x1199, 0x9005)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
513         {QMI_GOBI_DEVICE(0x1199, 0x9006)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
514         {QMI_GOBI_DEVICE(0x1199, 0x9007)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
515         {QMI_GOBI_DEVICE(0x1199, 0x9008)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
516         {QMI_GOBI_DEVICE(0x1199, 0x9009)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
517         {QMI_GOBI_DEVICE(0x1199, 0x900a)},      /* Sierra Wireless Gobi 2000 Modem device (VT773) */
518         {QMI_GOBI_DEVICE(0x1199, 0x9011)},      /* Sierra Wireless Gobi 2000 Modem device (MC8305) */
519         {QMI_FIXED_INTF(0x1199, 0x9011, 5)},    /* alternate interface number!? */
520         {QMI_GOBI_DEVICE(0x16d8, 0x8002)},      /* CMDTech Gobi 2000 Modem device (VU922) */
521         {QMI_GOBI_DEVICE(0x05c6, 0x9205)},      /* Gobi 2000 Modem device */
522         {QMI_GOBI_DEVICE(0x1199, 0x9013)},      /* Sierra Wireless Gobi 3000 Modem device (MC8355) */
523         {QMI_GOBI_DEVICE(0x03f0, 0x371d)},      /* HP un2430 Mobile Broadband Module */
524         {QMI_GOBI_DEVICE(0x1199, 0x9015)},      /* Sierra Wireless Gobi 3000 Modem device */
525         {QMI_GOBI_DEVICE(0x1199, 0x9019)},      /* Sierra Wireless Gobi 3000 Modem device */
526         {QMI_GOBI_DEVICE(0x1199, 0x901b)},      /* Sierra Wireless MC7770 */
527         {QMI_GOBI_DEVICE(0x12d1, 0x14f1)},      /* Sony Gobi 3000 Composite */
528         {QMI_GOBI_DEVICE(0x1410, 0xa021)},      /* Foxconn Gobi 3000 Modem device (Novatel E396) */
529
530         { }                                     /* END */
531 };
532 MODULE_DEVICE_TABLE(usb, products);
533
534 static int qmi_wwan_probe(struct usb_interface *intf, const struct usb_device_id *prod)
535 {
536         struct usb_device_id *id = (struct usb_device_id *)prod;
537
538         /* Workaround to enable dynamic IDs.  This disables usbnet
539          * blacklisting functionality.  Which, if required, can be
540          * reimplemented here by using a magic "blacklist" value
541          * instead of 0 in the static device id table
542          */
543         if (!id->driver_info) {
544                 dev_dbg(&intf->dev, "setting defaults for dynamic device id\n");
545                 id->driver_info = (unsigned long)&qmi_wwan_info;
546         }
547
548         return usbnet_probe(intf, id);
549 }
550
551 static struct usb_driver qmi_wwan_driver = {
552         .name                 = "qmi_wwan",
553         .id_table             = products,
554         .probe                = qmi_wwan_probe,
555         .disconnect           = usbnet_disconnect,
556         .suspend              = qmi_wwan_suspend,
557         .resume               = qmi_wwan_resume,
558         .reset_resume         = qmi_wwan_resume,
559         .supports_autosuspend = 1,
560         .disable_hub_initiated_lpm = 1,
561 };
562
563 module_usb_driver(qmi_wwan_driver);
564
565 MODULE_AUTHOR("Bjørn Mork <bjorn@mork.no>");
566 MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver");
567 MODULE_LICENSE("GPL");