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/etherdevice.h> 17 #include <linux/mii.h> 18 #include <linux/usb.h> 19 #include <linux/usb/cdc.h> 20 #include <linux/usb/usbnet.h> 21 #include <linux/usb/cdc-wdm.h> 22 23 /* This driver supports wwan (3G/LTE/?) devices using a vendor 24 * specific management protocol called Qualcomm MSM Interface (QMI) - 25 * in addition to the more common AT commands over serial interface 26 * management 27 * 28 * QMI is wrapped in CDC, using CDC encapsulated commands on the 29 * control ("master") interface of a two-interface CDC Union 30 * resembling standard CDC ECM. The devices do not use the control 31 * interface for any other CDC messages. Most likely because the 32 * management protocol is used in place of the standard CDC 33 * notifications NOTIFY_NETWORK_CONNECTION and NOTIFY_SPEED_CHANGE 34 * 35 * Alternatively, control and data functions can be combined in a 36 * single USB interface. 37 * 38 * Handling a protocol like QMI is out of the scope for any driver. 39 * It is exported as a character device using the cdc-wdm driver as 40 * a subdriver, enabling userspace applications ("modem managers") to 41 * handle it. 42 * 43 * These devices may alternatively/additionally be configured using AT 44 * commands on a serial interface 45 */ 46 47 /* driver specific data */ 48 struct qmi_wwan_state { 49 struct usb_driver *subdriver; 50 atomic_t pmcount; 51 unsigned long unused; 52 struct usb_interface *control; 53 struct usb_interface *data; 54 }; 55 56 /* default ethernet address used by the modem */ 57 static const u8 default_modem_addr[ETH_ALEN] = {0x02, 0x50, 0xf3}; 58 59 /* Make up an ethernet header if the packet doesn't have one. 60 * 61 * A firmware bug common among several devices cause them to send raw 62 * IP packets under some circumstances. There is no way for the 63 * driver/host to know when this will happen. And even when the bug 64 * hits, some packets will still arrive with an intact header. 65 * 66 * The supported devices are only capably of sending IPv4, IPv6 and 67 * ARP packets on a point-to-point link. Any packet with an ethernet 68 * header will have either our address or a broadcast/multicast 69 * address as destination. ARP packets will always have a header. 70 * 71 * This means that this function will reliably add the appropriate 72 * header iff necessary, provided our hardware address does not start 73 * with 4 or 6. 74 * 75 * Another common firmware bug results in all packets being addressed 76 * to 00:a0:c6:00:00:00 despite the host address being different. 77 * This function will also fixup such packets. 78 */ 79 static int qmi_wwan_rx_fixup(struct usbnet *dev, struct sk_buff *skb) 80 { 81 __be16 proto; 82 83 /* usbnet rx_complete guarantees that skb->len is at least 84 * hard_header_len, so we can inspect the dest address without 85 * checking skb->len 86 */ 87 switch (skb->data[0] & 0xf0) { 88 case 0x40: 89 proto = htons(ETH_P_IP); 90 break; 91 case 0x60: 92 proto = htons(ETH_P_IPV6); 93 break; 94 case 0x00: 95 if (is_multicast_ether_addr(skb->data)) 96 return 1; 97 /* possibly bogus destination - rewrite just in case */ 98 skb_reset_mac_header(skb); 99 goto fix_dest; 100 default: 101 /* pass along other packets without modifications */ 102 return 1; 103 } 104 if (skb_headroom(skb) < ETH_HLEN) 105 return 0; 106 skb_push(skb, ETH_HLEN); 107 skb_reset_mac_header(skb); 108 eth_hdr(skb)->h_proto = proto; 109 memset(eth_hdr(skb)->h_source, 0, ETH_ALEN); 110 fix_dest: 111 memcpy(eth_hdr(skb)->h_dest, dev->net->dev_addr, ETH_ALEN); 112 return 1; 113 } 114 115 /* very simplistic detection of IPv4 or IPv6 headers */ 116 static bool possibly_iphdr(const char *data) 117 { 118 return (data[0] & 0xd0) == 0x40; 119 } 120 121 /* disallow addresses which may be confused with IP headers */ 122 static int qmi_wwan_mac_addr(struct net_device *dev, void *p) 123 { 124 int ret; 125 struct sockaddr *addr = p; 126 127 ret = eth_prepare_mac_addr_change(dev, p); 128 if (ret < 0) 129 return ret; 130 if (possibly_iphdr(addr->sa_data)) 131 return -EADDRNOTAVAIL; 132 eth_commit_mac_addr_change(dev, p); 133 return 0; 134 } 135 136 static const struct net_device_ops qmi_wwan_netdev_ops = { 137 .ndo_open = usbnet_open, 138 .ndo_stop = usbnet_stop, 139 .ndo_start_xmit = usbnet_start_xmit, 140 .ndo_tx_timeout = usbnet_tx_timeout, 141 .ndo_change_mtu = usbnet_change_mtu, 142 .ndo_set_mac_address = qmi_wwan_mac_addr, 143 .ndo_validate_addr = eth_validate_addr, 144 }; 145 146 /* using a counter to merge subdriver requests with our own into a combined state */ 147 static int qmi_wwan_manage_power(struct usbnet *dev, int on) 148 { 149 struct qmi_wwan_state *info = (void *)&dev->data; 150 int rv = 0; 151 152 dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__, atomic_read(&info->pmcount), on); 153 154 if ((on && atomic_add_return(1, &info->pmcount) == 1) || (!on && atomic_dec_and_test(&info->pmcount))) { 155 /* need autopm_get/put here to ensure the usbcore sees the new value */ 156 rv = usb_autopm_get_interface(dev->intf); 157 if (rv < 0) 158 goto err; 159 dev->intf->needs_remote_wakeup = on; 160 usb_autopm_put_interface(dev->intf); 161 } 162 err: 163 return rv; 164 } 165 166 static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on) 167 { 168 struct usbnet *dev = usb_get_intfdata(intf); 169 170 /* can be called while disconnecting */ 171 if (!dev) 172 return 0; 173 return qmi_wwan_manage_power(dev, on); 174 } 175 176 /* collect all three endpoints and register subdriver */ 177 static int qmi_wwan_register_subdriver(struct usbnet *dev) 178 { 179 int rv; 180 struct usb_driver *subdriver = NULL; 181 struct qmi_wwan_state *info = (void *)&dev->data; 182 183 /* collect bulk endpoints */ 184 rv = usbnet_get_endpoints(dev, info->data); 185 if (rv < 0) 186 goto err; 187 188 /* update status endpoint if separate control interface */ 189 if (info->control != info->data) 190 dev->status = &info->control->cur_altsetting->endpoint[0]; 191 192 /* require interrupt endpoint for subdriver */ 193 if (!dev->status) { 194 rv = -EINVAL; 195 goto err; 196 } 197 198 /* for subdriver power management */ 199 atomic_set(&info->pmcount, 0); 200 201 /* register subdriver */ 202 subdriver = usb_cdc_wdm_register(info->control, &dev->status->desc, 4096, &qmi_wwan_cdc_wdm_manage_power); 203 if (IS_ERR(subdriver)) { 204 dev_err(&info->control->dev, "subdriver registration failed\n"); 205 rv = PTR_ERR(subdriver); 206 goto err; 207 } 208 209 /* prevent usbnet from using status endpoint */ 210 dev->status = NULL; 211 212 /* save subdriver struct for suspend/resume wrappers */ 213 info->subdriver = subdriver; 214 215 err: 216 return rv; 217 } 218 219 static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf) 220 { 221 int status = -1; 222 u8 *buf = intf->cur_altsetting->extra; 223 int len = intf->cur_altsetting->extralen; 224 struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc; 225 struct usb_cdc_union_desc *cdc_union = NULL; 226 struct usb_cdc_ether_desc *cdc_ether = NULL; 227 u32 found = 0; 228 struct usb_driver *driver = driver_of(intf); 229 struct qmi_wwan_state *info = (void *)&dev->data; 230 231 BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) < sizeof(struct qmi_wwan_state))); 232 233 /* set up initial state */ 234 info->control = intf; 235 info->data = intf; 236 237 /* and a number of CDC descriptors */ 238 while (len > 3) { 239 struct usb_descriptor_header *h = (void *)buf; 240 241 /* ignore any misplaced descriptors */ 242 if (h->bDescriptorType != USB_DT_CS_INTERFACE) 243 goto next_desc; 244 245 /* buf[2] is CDC descriptor subtype */ 246 switch (buf[2]) { 247 case USB_CDC_HEADER_TYPE: 248 if (found & 1 << USB_CDC_HEADER_TYPE) { 249 dev_dbg(&intf->dev, "extra CDC header\n"); 250 goto err; 251 } 252 if (h->bLength != sizeof(struct usb_cdc_header_desc)) { 253 dev_dbg(&intf->dev, "CDC header len %u\n", h->bLength); 254 goto err; 255 } 256 break; 257 case USB_CDC_UNION_TYPE: 258 if (found & 1 << USB_CDC_UNION_TYPE) { 259 dev_dbg(&intf->dev, "extra CDC union\n"); 260 goto err; 261 } 262 if (h->bLength != sizeof(struct usb_cdc_union_desc)) { 263 dev_dbg(&intf->dev, "CDC union len %u\n", h->bLength); 264 goto err; 265 } 266 cdc_union = (struct usb_cdc_union_desc *)buf; 267 break; 268 case USB_CDC_ETHERNET_TYPE: 269 if (found & 1 << USB_CDC_ETHERNET_TYPE) { 270 dev_dbg(&intf->dev, "extra CDC ether\n"); 271 goto err; 272 } 273 if (h->bLength != sizeof(struct usb_cdc_ether_desc)) { 274 dev_dbg(&intf->dev, "CDC ether len %u\n", h->bLength); 275 goto err; 276 } 277 cdc_ether = (struct usb_cdc_ether_desc *)buf; 278 break; 279 } 280 281 /* 282 * Remember which CDC functional descriptors we've seen. Works 283 * for all types we care about, of which USB_CDC_ETHERNET_TYPE 284 * (0x0f) is the highest numbered 285 */ 286 if (buf[2] < 32) 287 found |= 1 << buf[2]; 288 289 next_desc: 290 len -= h->bLength; 291 buf += h->bLength; 292 } 293 294 /* Use separate control and data interfaces if we found a CDC Union */ 295 if (cdc_union) { 296 info->data = usb_ifnum_to_if(dev->udev, cdc_union->bSlaveInterface0); 297 if (desc->bInterfaceNumber != cdc_union->bMasterInterface0 || !info->data) { 298 dev_err(&intf->dev, "bogus CDC Union: master=%u, slave=%u\n", 299 cdc_union->bMasterInterface0, cdc_union->bSlaveInterface0); 300 goto err; 301 } 302 } 303 304 /* errors aren't fatal - we can live with the dynamic address */ 305 if (cdc_ether) { 306 dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize); 307 usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress); 308 } 309 310 /* claim data interface and set it up */ 311 if (info->control != info->data) { 312 status = usb_driver_claim_interface(driver, info->data, dev); 313 if (status < 0) 314 goto err; 315 } 316 317 status = qmi_wwan_register_subdriver(dev); 318 if (status < 0 && info->control != info->data) { 319 usb_set_intfdata(info->data, NULL); 320 usb_driver_release_interface(driver, info->data); 321 } 322 323 /* Never use the same address on both ends of the link, even 324 * if the buggy firmware told us to. 325 */ 326 if (!compare_ether_addr(dev->net->dev_addr, default_modem_addr)) 327 eth_hw_addr_random(dev->net); 328 329 /* make MAC addr easily distinguishable from an IP header */ 330 if (possibly_iphdr(dev->net->dev_addr)) { 331 dev->net->dev_addr[0] |= 0x02; /* set local assignment bit */ 332 dev->net->dev_addr[0] &= 0xbf; /* clear "IP" bit */ 333 } 334 dev->net->netdev_ops = &qmi_wwan_netdev_ops; 335 err: 336 return status; 337 } 338 339 static void qmi_wwan_unbind(struct usbnet *dev, struct usb_interface *intf) 340 { 341 struct qmi_wwan_state *info = (void *)&dev->data; 342 struct usb_driver *driver = driver_of(intf); 343 struct usb_interface *other; 344 345 if (info->subdriver && info->subdriver->disconnect) 346 info->subdriver->disconnect(info->control); 347 348 /* allow user to unbind using either control or data */ 349 if (intf == info->control) 350 other = info->data; 351 else 352 other = info->control; 353 354 /* only if not shared */ 355 if (other && intf != other) { 356 usb_set_intfdata(other, NULL); 357 usb_driver_release_interface(driver, other); 358 } 359 360 info->subdriver = NULL; 361 info->data = NULL; 362 info->control = NULL; 363 } 364 365 /* suspend/resume wrappers calling both usbnet and the cdc-wdm 366 * subdriver if present. 367 * 368 * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide 369 * wrappers for those without adding usbnet reset support first. 370 */ 371 static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message) 372 { 373 struct usbnet *dev = usb_get_intfdata(intf); 374 struct qmi_wwan_state *info = (void *)&dev->data; 375 int ret; 376 377 /* 378 * Both usbnet_suspend() and subdriver->suspend() MUST return 0 379 * in system sleep context, otherwise, the resume callback has 380 * to recover device from previous suspend failure. 381 */ 382 ret = usbnet_suspend(intf, message); 383 if (ret < 0) 384 goto err; 385 386 if (intf == info->control && info->subdriver && info->subdriver->suspend) 387 ret = info->subdriver->suspend(intf, message); 388 if (ret < 0) 389 usbnet_resume(intf); 390 err: 391 return ret; 392 } 393 394 static int qmi_wwan_resume(struct usb_interface *intf) 395 { 396 struct usbnet *dev = usb_get_intfdata(intf); 397 struct qmi_wwan_state *info = (void *)&dev->data; 398 int ret = 0; 399 bool callsub = (intf == info->control && info->subdriver && info->subdriver->resume); 400 401 if (callsub) 402 ret = info->subdriver->resume(intf); 403 if (ret < 0) 404 goto err; 405 ret = usbnet_resume(intf); 406 if (ret < 0 && callsub && info->subdriver->suspend) 407 info->subdriver->suspend(intf, PMSG_SUSPEND); 408 err: 409 return ret; 410 } 411 412 static const struct driver_info qmi_wwan_info = { 413 .description = "WWAN/QMI device", 414 .flags = FLAG_WWAN, 415 .bind = qmi_wwan_bind, 416 .unbind = qmi_wwan_unbind, 417 .manage_power = qmi_wwan_manage_power, 418 .rx_fixup = qmi_wwan_rx_fixup, 419 }; 420 421 #define HUAWEI_VENDOR_ID 0x12D1 422 423 /* map QMI/wwan function by a fixed interface number */ 424 #define QMI_FIXED_INTF(vend, prod, num) \ 425 USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \ 426 .driver_info = (unsigned long)&qmi_wwan_info 427 428 /* Gobi 1000 QMI/wwan interface number is 3 according to qcserial */ 429 #define QMI_GOBI1K_DEVICE(vend, prod) \ 430 QMI_FIXED_INTF(vend, prod, 3) 431 432 /* Gobi 2000/3000 QMI/wwan interface number is 0 according to qcserial */ 433 #define QMI_GOBI_DEVICE(vend, prod) \ 434 QMI_FIXED_INTF(vend, prod, 0) 435 436 static const struct usb_device_id products[] = { 437 /* 1. CDC ECM like devices match on the control interface */ 438 { /* Huawei E392, E398 and possibly others sharing both device id and more... */ 439 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 9), 440 .driver_info = (unsigned long)&qmi_wwan_info, 441 }, 442 { /* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */ 443 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 57), 444 .driver_info = (unsigned long)&qmi_wwan_info, 445 }, 446 { /* HUAWEI_INTERFACE_NDIS_CONTROL_QUALCOMM */ 447 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x69), 448 .driver_info = (unsigned long)&qmi_wwan_info, 449 }, 450 451 /* 2. Combined interface devices matching on class+protocol */ 452 { /* Huawei E367 and possibly others in "Windows mode" */ 453 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 7), 454 .driver_info = (unsigned long)&qmi_wwan_info, 455 }, 456 { /* Huawei E392, E398 and possibly others in "Windows mode" */ 457 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 17), 458 .driver_info = (unsigned long)&qmi_wwan_info, 459 }, 460 { /* HUAWEI_NDIS_SINGLE_INTERFACE_VDF */ 461 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x37), 462 .driver_info = (unsigned long)&qmi_wwan_info, 463 }, 464 { /* HUAWEI_INTERFACE_NDIS_HW_QUALCOMM */ 465 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x67), 466 .driver_info = (unsigned long)&qmi_wwan_info, 467 }, 468 { /* Pantech UML290, P4200 and more */ 469 USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf0, 0xff), 470 .driver_info = (unsigned long)&qmi_wwan_info, 471 }, 472 { /* Pantech UML290 - newer firmware */ 473 USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf1, 0xff), 474 .driver_info = (unsigned long)&qmi_wwan_info, 475 }, 476 { /* Novatel USB551L and MC551 */ 477 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0xb001, 478 USB_CLASS_COMM, 479 USB_CDC_SUBCLASS_ETHERNET, 480 USB_CDC_PROTO_NONE), 481 .driver_info = (unsigned long)&qmi_wwan_info, 482 }, 483 { /* Novatel E362 */ 484 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0x9010, 485 USB_CLASS_COMM, 486 USB_CDC_SUBCLASS_ETHERNET, 487 USB_CDC_PROTO_NONE), 488 .driver_info = (unsigned long)&qmi_wwan_info, 489 }, 490 { /* Dell Wireless 5800 (Novatel E362) */ 491 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8195, 492 USB_CLASS_COMM, 493 USB_CDC_SUBCLASS_ETHERNET, 494 USB_CDC_PROTO_NONE), 495 .driver_info = (unsigned long)&qmi_wwan_info, 496 }, 497 { /* Dell Wireless 5800 V2 (Novatel E362) */ 498 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8196, 499 USB_CLASS_COMM, 500 USB_CDC_SUBCLASS_ETHERNET, 501 USB_CDC_PROTO_NONE), 502 .driver_info = (unsigned long)&qmi_wwan_info, 503 }, 504 { /* Dell Wireless 5804 (Novatel E371) */ 505 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x819b, 506 USB_CLASS_COMM, 507 USB_CDC_SUBCLASS_ETHERNET, 508 USB_CDC_PROTO_NONE), 509 .driver_info = (unsigned long)&qmi_wwan_info, 510 }, 511 { /* ADU960S */ 512 USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a, 513 USB_CLASS_COMM, 514 USB_CDC_SUBCLASS_ETHERNET, 515 USB_CDC_PROTO_NONE), 516 .driver_info = (unsigned long)&qmi_wwan_info, 517 }, 518 519 /* 3. Combined interface devices matching on interface number */ 520 {QMI_FIXED_INTF(0x0408, 0xea42, 4)}, /* Yota / Megafon M100-1 */ 521 {QMI_FIXED_INTF(0x12d1, 0x140c, 1)}, /* Huawei E173 */ 522 {QMI_FIXED_INTF(0x19d2, 0x0002, 1)}, 523 {QMI_FIXED_INTF(0x19d2, 0x0012, 1)}, 524 {QMI_FIXED_INTF(0x19d2, 0x0017, 3)}, 525 {QMI_FIXED_INTF(0x19d2, 0x0021, 4)}, 526 {QMI_FIXED_INTF(0x19d2, 0x0025, 1)}, 527 {QMI_FIXED_INTF(0x19d2, 0x0031, 4)}, 528 {QMI_FIXED_INTF(0x19d2, 0x0042, 4)}, 529 {QMI_FIXED_INTF(0x19d2, 0x0049, 5)}, 530 {QMI_FIXED_INTF(0x19d2, 0x0052, 4)}, 531 {QMI_FIXED_INTF(0x19d2, 0x0055, 1)}, /* ZTE (Vodafone) K3520-Z */ 532 {QMI_FIXED_INTF(0x19d2, 0x0058, 4)}, 533 {QMI_FIXED_INTF(0x19d2, 0x0063, 4)}, /* ZTE (Vodafone) K3565-Z */ 534 {QMI_FIXED_INTF(0x19d2, 0x0104, 4)}, /* ZTE (Vodafone) K4505-Z */ 535 {QMI_FIXED_INTF(0x19d2, 0x0113, 5)}, 536 {QMI_FIXED_INTF(0x19d2, 0x0118, 5)}, 537 {QMI_FIXED_INTF(0x19d2, 0x0121, 5)}, 538 {QMI_FIXED_INTF(0x19d2, 0x0123, 4)}, 539 {QMI_FIXED_INTF(0x19d2, 0x0124, 5)}, 540 {QMI_FIXED_INTF(0x19d2, 0x0125, 6)}, 541 {QMI_FIXED_INTF(0x19d2, 0x0126, 5)}, 542 {QMI_FIXED_INTF(0x19d2, 0x0130, 1)}, 543 {QMI_FIXED_INTF(0x19d2, 0x0133, 3)}, 544 {QMI_FIXED_INTF(0x19d2, 0x0141, 5)}, 545 {QMI_FIXED_INTF(0x19d2, 0x0157, 5)}, /* ZTE MF683 */ 546 {QMI_FIXED_INTF(0x19d2, 0x0158, 3)}, 547 {QMI_FIXED_INTF(0x19d2, 0x0167, 4)}, /* ZTE MF820D */ 548 {QMI_FIXED_INTF(0x19d2, 0x0168, 4)}, 549 {QMI_FIXED_INTF(0x19d2, 0x0176, 3)}, 550 {QMI_FIXED_INTF(0x19d2, 0x0178, 3)}, 551 {QMI_FIXED_INTF(0x19d2, 0x0191, 4)}, /* ZTE EuFi890 */ 552 {QMI_FIXED_INTF(0x19d2, 0x0199, 1)}, /* ZTE MF820S */ 553 {QMI_FIXED_INTF(0x19d2, 0x0200, 1)}, 554 {QMI_FIXED_INTF(0x19d2, 0x0257, 3)}, /* ZTE MF821 */ 555 {QMI_FIXED_INTF(0x19d2, 0x0265, 4)}, /* ONDA MT8205 4G LTE */ 556 {QMI_FIXED_INTF(0x19d2, 0x0284, 4)}, /* ZTE MF880 */ 557 {QMI_FIXED_INTF(0x19d2, 0x0326, 4)}, /* ZTE MF821D */ 558 {QMI_FIXED_INTF(0x19d2, 0x0412, 4)}, /* Telewell TW-LTE 4G */ 559 {QMI_FIXED_INTF(0x19d2, 0x1008, 4)}, /* ZTE (Vodafone) K3570-Z */ 560 {QMI_FIXED_INTF(0x19d2, 0x1010, 4)}, /* ZTE (Vodafone) K3571-Z */ 561 {QMI_FIXED_INTF(0x19d2, 0x1012, 4)}, 562 {QMI_FIXED_INTF(0x19d2, 0x1018, 3)}, /* ZTE (Vodafone) K5006-Z */ 563 {QMI_FIXED_INTF(0x19d2, 0x1021, 2)}, 564 {QMI_FIXED_INTF(0x19d2, 0x1245, 4)}, 565 {QMI_FIXED_INTF(0x19d2, 0x1247, 4)}, 566 {QMI_FIXED_INTF(0x19d2, 0x1252, 4)}, 567 {QMI_FIXED_INTF(0x19d2, 0x1254, 4)}, 568 {QMI_FIXED_INTF(0x19d2, 0x1255, 3)}, 569 {QMI_FIXED_INTF(0x19d2, 0x1255, 4)}, 570 {QMI_FIXED_INTF(0x19d2, 0x1256, 4)}, 571 {QMI_FIXED_INTF(0x19d2, 0x1401, 2)}, 572 {QMI_FIXED_INTF(0x19d2, 0x1402, 2)}, /* ZTE MF60 */ 573 {QMI_FIXED_INTF(0x19d2, 0x1424, 2)}, 574 {QMI_FIXED_INTF(0x19d2, 0x1425, 2)}, 575 {QMI_FIXED_INTF(0x19d2, 0x1426, 2)}, /* ZTE MF91 */ 576 {QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */ 577 {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */ 578 {QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */ 579 {QMI_FIXED_INTF(0x1199, 0x68a2, 8)}, /* Sierra Wireless MC7710 in QMI mode */ 580 {QMI_FIXED_INTF(0x1199, 0x68a2, 19)}, /* Sierra Wireless MC7710 in QMI mode */ 581 {QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */ 582 {QMI_FIXED_INTF(0x1bbb, 0x011e, 4)}, /* Telekom Speedstick LTE II (Alcatel One Touch L100V LTE) */ 583 {QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */ 584 {QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */ 585 {QMI_FIXED_INTF(0x1e2d, 0x12d1, 4)}, /* Cinterion PLxx */ 586 587 /* 4. Gobi 1000 devices */ 588 {QMI_GOBI1K_DEVICE(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */ 589 {QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)}, /* HP un2400 Gobi Modem Device */ 590 {QMI_GOBI1K_DEVICE(0x04da, 0x250d)}, /* Panasonic Gobi Modem device */ 591 {QMI_GOBI1K_DEVICE(0x413c, 0x8172)}, /* Dell Gobi Modem device */ 592 {QMI_GOBI1K_DEVICE(0x1410, 0xa001)}, /* Novatel Gobi Modem device */ 593 {QMI_GOBI1K_DEVICE(0x0b05, 0x1776)}, /* Asus Gobi Modem device */ 594 {QMI_GOBI1K_DEVICE(0x19d2, 0xfff3)}, /* ONDA Gobi Modem device */ 595 {QMI_GOBI1K_DEVICE(0x05c6, 0x9001)}, /* Generic Gobi Modem device */ 596 {QMI_GOBI1K_DEVICE(0x05c6, 0x9002)}, /* Generic Gobi Modem device */ 597 {QMI_GOBI1K_DEVICE(0x05c6, 0x9202)}, /* Generic Gobi Modem device */ 598 {QMI_GOBI1K_DEVICE(0x05c6, 0x9203)}, /* Generic Gobi Modem device */ 599 {QMI_GOBI1K_DEVICE(0x05c6, 0x9222)}, /* Generic Gobi Modem device */ 600 {QMI_GOBI1K_DEVICE(0x05c6, 0x9009)}, /* Generic Gobi Modem device */ 601 602 /* 5. Gobi 2000 and 3000 devices */ 603 {QMI_GOBI_DEVICE(0x413c, 0x8186)}, /* Dell Gobi 2000 Modem device (N0218, VU936) */ 604 {QMI_GOBI_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */ 605 {QMI_GOBI_DEVICE(0x05c6, 0x920b)}, /* Generic Gobi 2000 Modem device */ 606 {QMI_GOBI_DEVICE(0x05c6, 0x920d)}, /* Gobi 3000 Composite */ 607 {QMI_GOBI_DEVICE(0x05c6, 0x9225)}, /* Sony Gobi 2000 Modem device (N0279, VU730) */ 608 {QMI_GOBI_DEVICE(0x05c6, 0x9245)}, /* Samsung Gobi 2000 Modem device (VL176) */ 609 {QMI_GOBI_DEVICE(0x03f0, 0x251d)}, /* HP Gobi 2000 Modem device (VP412) */ 610 {QMI_GOBI_DEVICE(0x05c6, 0x9215)}, /* Acer Gobi 2000 Modem device (VP413) */ 611 {QMI_GOBI_DEVICE(0x05c6, 0x9265)}, /* Asus Gobi 2000 Modem device (VR305) */ 612 {QMI_GOBI_DEVICE(0x05c6, 0x9235)}, /* Top Global Gobi 2000 Modem device (VR306) */ 613 {QMI_GOBI_DEVICE(0x05c6, 0x9275)}, /* iRex Technologies Gobi 2000 Modem device (VR307) */ 614 {QMI_GOBI_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */ 615 {QMI_GOBI_DEVICE(0x1199, 0x68a9)}, /* Sierra Wireless Modem */ 616 {QMI_GOBI_DEVICE(0x1199, 0x9001)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 617 {QMI_GOBI_DEVICE(0x1199, 0x9002)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 618 {QMI_GOBI_DEVICE(0x1199, 0x9003)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 619 {QMI_GOBI_DEVICE(0x1199, 0x9004)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 620 {QMI_GOBI_DEVICE(0x1199, 0x9005)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 621 {QMI_GOBI_DEVICE(0x1199, 0x9006)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 622 {QMI_GOBI_DEVICE(0x1199, 0x9007)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 623 {QMI_GOBI_DEVICE(0x1199, 0x9008)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 624 {QMI_GOBI_DEVICE(0x1199, 0x9009)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 625 {QMI_GOBI_DEVICE(0x1199, 0x900a)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 626 {QMI_GOBI_DEVICE(0x1199, 0x9011)}, /* Sierra Wireless Gobi 2000 Modem device (MC8305) */ 627 {QMI_FIXED_INTF(0x1199, 0x9011, 5)}, /* alternate interface number!? */ 628 {QMI_GOBI_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */ 629 {QMI_GOBI_DEVICE(0x05c6, 0x9205)}, /* Gobi 2000 Modem device */ 630 {QMI_GOBI_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */ 631 {QMI_GOBI_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Mobile Broadband Module */ 632 {QMI_GOBI_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */ 633 {QMI_GOBI_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */ 634 {QMI_GOBI_DEVICE(0x1199, 0x901b)}, /* Sierra Wireless MC7770 */ 635 {QMI_GOBI_DEVICE(0x12d1, 0x14f1)}, /* Sony Gobi 3000 Composite */ 636 {QMI_GOBI_DEVICE(0x1410, 0xa021)}, /* Foxconn Gobi 3000 Modem device (Novatel E396) */ 637 638 { } /* END */ 639 }; 640 MODULE_DEVICE_TABLE(usb, products); 641 642 static int qmi_wwan_probe(struct usb_interface *intf, const struct usb_device_id *prod) 643 { 644 struct usb_device_id *id = (struct usb_device_id *)prod; 645 646 /* Workaround to enable dynamic IDs. This disables usbnet 647 * blacklisting functionality. Which, if required, can be 648 * reimplemented here by using a magic "blacklist" value 649 * instead of 0 in the static device id table 650 */ 651 if (!id->driver_info) { 652 dev_dbg(&intf->dev, "setting defaults for dynamic device id\n"); 653 id->driver_info = (unsigned long)&qmi_wwan_info; 654 } 655 656 return usbnet_probe(intf, id); 657 } 658 659 static struct usb_driver qmi_wwan_driver = { 660 .name = "qmi_wwan", 661 .id_table = products, 662 .probe = qmi_wwan_probe, 663 .disconnect = usbnet_disconnect, 664 .suspend = qmi_wwan_suspend, 665 .resume = qmi_wwan_resume, 666 .reset_resume = qmi_wwan_resume, 667 .supports_autosuspend = 1, 668 .disable_hub_initiated_lpm = 1, 669 }; 670 671 module_usb_driver(qmi_wwan_driver); 672 673 MODULE_AUTHOR("Bjørn Mork <bjorn@mork.no>"); 674 MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver"); 675 MODULE_LICENSE("GPL"); 676