rtime.felk.cvut.cz Git - hercules2020/nv-tegra/linux-4.4.git/blob

1 // SPDX-License-Identifier: GPL-2.0-only

2 /*

4 *

5 * The probing code is heavily inspired by cdc_ether, which is:

8 */

9

10 #include <linux/module.h>

11 #include <linux/sched/signal.h>

12 #include <linux/netdevice.h>

13 #include <linux/ethtool.h>

14 #include <linux/etherdevice.h>

15 #include <linux/if_arp.h>

16 #include <linux/mii.h>

17 #include <linux/rtnetlink.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 #include <linux/u64_stats_sync.h>

23

24 /* This driver supports wwan (3G/LTE/?) devices using a vendor

25 * specific management protocol called Qualcomm MSM Interface (QMI) -

26 * in addition to the more common AT commands over serial interface

27 * management

28 *

29 * QMI is wrapped in CDC, using CDC encapsulated commands on the

30 * control ("master") interface of a two-interface CDC Union

31 * resembling standard CDC ECM. The devices do not use the control

32 * interface for any other CDC messages. Most likely because the

33 * management protocol is used in place of the standard CDC

34 * notifications NOTIFY_NETWORK_CONNECTION and NOTIFY_SPEED_CHANGE

35 *

36 * Alternatively, control and data functions can be combined in a

37 * single USB interface.

38 *

39 * Handling a protocol like QMI is out of the scope for any driver.

40 * It is exported as a character device using the cdc-wdm driver as

41 * a subdriver, enabling userspace applications ("modem managers") to

42 * handle it.

43 *

44 * These devices may alternatively/additionally be configured using AT

45 * commands on a serial interface

46 */

47

48 /* driver specific data */

49 struct qmi_wwan_state {

50 struct usb_driver *subdriver;

51 atomic_t pmcount;

52 unsigned long flags;

53 struct usb_interface *control;

54 struct usb_interface *data;

55 };

56

57 enum qmi_wwan_flags {

58 QMI_WWAN_FLAG_RAWIP = 1 << 0,

59 QMI_WWAN_FLAG_MUX = 1 << 1,

60 };

61

62 enum qmi_wwan_quirks {

63 QMI_WWAN_QUIRK_DTR = 1 << 0, /* needs "set DTR" request */

64 };

65

66 struct qmimux_hdr {

67 u8 pad;

68 u8 mux_id;

69 __be16 pkt_len;

70 };

71

72 struct qmimux_priv {

73 struct net_device *real_dev;

74 u8 mux_id;

75 struct pcpu_sw_netstats __percpu *stats64;

76 };

77

78 static int qmimux_open(struct net_device *dev)

79 {

80 struct qmimux_priv *priv = netdev_priv(dev);

81 struct net_device *real_dev = priv->real_dev;

82

83 if (!(priv->real_dev->flags & IFF_UP))

84 return -ENETDOWN;

85

86 if (netif_carrier_ok(real_dev))

87 netif_carrier_on(dev);

88 return 0;

89 }

90

91 static int qmimux_stop(struct net_device *dev)

92 {

93 netif_carrier_off(dev);

94 return 0;

95 }

96

97 static netdev_tx_t qmimux_start_xmit(struct sk_buff *skb, struct net_device *dev)

98 {

99 struct qmimux_priv *priv = netdev_priv(dev);

100 unsigned int len = skb->len;

101 struct qmimux_hdr *hdr;

102 netdev_tx_t ret;

103

104 hdr = skb_push(skb, sizeof(struct qmimux_hdr));

105 hdr->pad = 0;

106 hdr->mux_id = priv->mux_id;

107 hdr->pkt_len = cpu_to_be16(len);

108 skb->dev = priv->real_dev;

109 ret = dev_queue_xmit(skb);

110

111 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {

112 struct pcpu_sw_netstats *stats64 = this_cpu_ptr(priv->stats64);

113

114 u64_stats_update_begin(&stats64->syncp);

115 stats64->tx_packets++;

116 stats64->tx_bytes += len;

117 u64_stats_update_end(&stats64->syncp);

118 } else {

119 dev->stats.tx_dropped++;

120 }

121

122 return ret;

123 }

124

125 static void qmimux_get_stats64(struct net_device *net,

126 struct rtnl_link_stats64 *stats)

127 {

128 struct qmimux_priv *priv = netdev_priv(net);

129

130 netdev_stats_to_stats64(stats, &net->stats);

131 dev_fetch_sw_netstats(stats, priv->stats64);

132 }

133

134 static const struct net_device_ops qmimux_netdev_ops = {

135 .ndo_open = qmimux_open,

136 .ndo_stop = qmimux_stop,

137 .ndo_start_xmit = qmimux_start_xmit,

138 .ndo_get_stats64 = qmimux_get_stats64,

139 };

140

141 static void qmimux_setup(struct net_device *dev)

142 {

143 dev->header_ops = NULL; /* No header */

144 dev->type = ARPHRD_NONE;

145 dev->hard_header_len = 0;

146 dev->addr_len = 0;

147 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;

148 dev->netdev_ops = &qmimux_netdev_ops;

149 dev->mtu = 1500;

150 dev->needs_free_netdev = true;

151 }

152

153 static struct net_device *qmimux_find_dev(struct usbnet *dev, u8 mux_id)

154 {

155 struct qmimux_priv *priv;

156 struct list_head *iter;

157 struct net_device *ldev;

158

159 rcu_read_lock();

160 netdev_for_each_upper_dev_rcu(dev->net, ldev, iter) {

161 priv = netdev_priv(ldev);

162 if (priv->mux_id == mux_id) {

163 rcu_read_unlock();

164 return ldev;

165 }

166 }

167 rcu_read_unlock();

168 return NULL;

169 }

170

171 static bool qmimux_has_slaves(struct usbnet *dev)

172 {

173 return !list_empty(&dev->net->adj_list.upper);

174 }

175

176 static int qmimux_rx_fixup(struct usbnet *dev, struct sk_buff *skb)

177 {

178 unsigned int len, offset = 0, pad_len, pkt_len;

179 struct qmimux_hdr *hdr;

180 struct net_device *net;

181 struct sk_buff *skbn;

182 u8 qmimux_hdr_sz = sizeof(*hdr);

183

184 while (offset + qmimux_hdr_sz < skb->len) {

185 hdr = (struct qmimux_hdr *)(skb->data + offset);

186 len = be16_to_cpu(hdr->pkt_len);

187

188 /* drop the packet, bogus length */

189 if (offset + len + qmimux_hdr_sz > skb->len)

190 return 0;

191

192 /* control packet, we do not know what to do */

193 if (hdr->pad & 0x80)

194 goto skip;

195

196 /* extract padding length and check for valid length info */

197 pad_len = hdr->pad & 0x3f;

198 if (len == 0 || pad_len >= len)

199 goto skip;

200 pkt_len = len - pad_len;

201

202 net = qmimux_find_dev(dev, hdr->mux_id);

203 if (!net)

204 goto skip;

205 skbn = netdev_alloc_skb(net, pkt_len);

206 if (!skbn)

207 return 0;

208 skbn->dev = net;

209

210 switch (skb->data[offset + qmimux_hdr_sz] & 0xf0) {

211 case 0x40:

212 skbn->protocol = htons(ETH_P_IP);

213 break;

214 case 0x60:

215 skbn->protocol = htons(ETH_P_IPV6);

216 break;

217 default:

218 /* not ip - do not know what to do */

219 goto skip;

220 }

221

222 skb_put_data(skbn, skb->data + offset + qmimux_hdr_sz, pkt_len);

223 if (netif_rx(skbn) != NET_RX_SUCCESS) {

224 net->stats.rx_errors++;

225 return 0;

226 } else {

227 struct pcpu_sw_netstats *stats64;

228 struct qmimux_priv *priv = netdev_priv(net);

229

230 stats64 = this_cpu_ptr(priv->stats64);

231 u64_stats_update_begin(&stats64->syncp);

232 stats64->rx_packets++;

233 stats64->rx_bytes += pkt_len;

234 u64_stats_update_end(&stats64->syncp);

235 }

236

237 skip:

238 offset += len + qmimux_hdr_sz;

239 }

240 return 1;

241 }

242

243 static int qmimux_register_device(struct net_device *real_dev, u8 mux_id)

244 {

245 struct net_device *new_dev;

246 struct qmimux_priv *priv;

247 int err;

248

249 new_dev = alloc_netdev(sizeof(struct qmimux_priv),

250 "qmimux%d", NET_NAME_UNKNOWN, qmimux_setup);

251 if (!new_dev)

252 return -ENOBUFS;

253

254 dev_net_set(new_dev, dev_net(real_dev));

255 priv = netdev_priv(new_dev);

256 priv->mux_id = mux_id;

257 priv->real_dev = real_dev;

258

259 priv->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);

260 if (!priv->stats64) {

261 err = -ENOBUFS;

262 goto out_free_newdev;

263 }

264

265 err = register_netdevice(new_dev);

266 if (err < 0)

267 goto out_free_newdev;

268

269 /* Account for reference in struct qmimux_priv_priv */

270 dev_hold(real_dev);

271

272 err = netdev_upper_dev_link(real_dev, new_dev, NULL);

273 if (err)

274 goto out_unregister_netdev;

275

276 netif_stacked_transfer_operstate(real_dev, new_dev);

277

278 return 0;

279

280 out_unregister_netdev:

281 unregister_netdevice(new_dev);

282 dev_put(real_dev);

283

284 out_free_newdev:

285 free_netdev(new_dev);

286 return err;

287 }

288

289 static void qmimux_unregister_device(struct net_device *dev,

290 struct list_head *head)

291 {

292 struct qmimux_priv *priv = netdev_priv(dev);

293 struct net_device *real_dev = priv->real_dev;

294

295 free_percpu(priv->stats64);

296 netdev_upper_dev_unlink(real_dev, dev);

297 unregister_netdevice_queue(dev, head);

298

299 /* Get rid of the reference to real_dev */

300 dev_put(real_dev);

301 }

302

303 static void qmi_wwan_netdev_setup(struct net_device *net)

304 {

305 struct usbnet *dev = netdev_priv(net);

306 struct qmi_wwan_state *info = (void *)&dev->data;

307

308 if (info->flags & QMI_WWAN_FLAG_RAWIP) {

309 net->header_ops = NULL; /* No header */

310 net->type = ARPHRD_NONE;

311 net->hard_header_len = 0;

312 net->addr_len = 0;

313 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;

314 set_bit(EVENT_NO_IP_ALIGN, &dev->flags);

315 netdev_dbg(net, "mode: raw IP\n");

316 } else if (!net->header_ops) { /* don't bother if already set */

317 ether_setup(net);

318 /* Restoring min/max mtu values set originally by usbnet */

319 net->min_mtu = 0;

320 net->max_mtu = ETH_MAX_MTU;

321 clear_bit(EVENT_NO_IP_ALIGN, &dev->flags);

322 netdev_dbg(net, "mode: Ethernet\n");

323 }

324

325 /* recalculate buffers after changing hard_header_len */

326 usbnet_change_mtu(net, net->mtu);

327 }

328

329 static ssize_t raw_ip_show(struct device *d, struct device_attribute *attr, char *buf)

330 {

331 struct usbnet *dev = netdev_priv(to_net_dev(d));

332 struct qmi_wwan_state *info = (void *)&dev->data;

333

334 return sprintf(buf, "%c\n", info->flags & QMI_WWAN_FLAG_RAWIP ? 'Y' : 'N');

335 }

336

337 static ssize_t raw_ip_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len)

338 {

339 struct usbnet *dev = netdev_priv(to_net_dev(d));

340 struct qmi_wwan_state *info = (void *)&dev->data;

341 bool enable;

342 int ret;

343

344 if (strtobool(buf, &enable))

345 return -EINVAL;

346

347 /* no change? */

348 if (enable == (info->flags & QMI_WWAN_FLAG_RAWIP))

349 return len;

350

351 if (!rtnl_trylock())

352 return restart_syscall();

353

354 /* we don't want to modify a running netdev */

355 if (netif_running(dev->net)) {

356 netdev_err(dev->net, "Cannot change a running device\n");

357 ret = -EBUSY;

358 goto err;

359 }

360

361 /* let other drivers deny the change */

362 ret = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, dev->net);

363 ret = notifier_to_errno(ret);

364 if (ret) {

365 netdev_err(dev->net, "Type change was refused\n");

366 goto err;

367 }

368

369 if (enable)

370 info->flags |= QMI_WWAN_FLAG_RAWIP;

371 else

372 info->flags &= ~QMI_WWAN_FLAG_RAWIP;

373 qmi_wwan_netdev_setup(dev->net);

374 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev->net);

375 ret = len;

376 err:

377 rtnl_unlock();

378 return ret;

379 }

380

381 static ssize_t add_mux_show(struct device *d, struct device_attribute *attr, char *buf)

382 {

383 struct net_device *dev = to_net_dev(d);

384 struct qmimux_priv *priv;

385 struct list_head *iter;

386 struct net_device *ldev;

387 ssize_t count = 0;

388

389 rcu_read_lock();

390 netdev_for_each_upper_dev_rcu(dev, ldev, iter) {

391 priv = netdev_priv(ldev);

392 count += scnprintf(&buf[count], PAGE_SIZE - count,

393 "0x%02x\n", priv->mux_id);

394 }

395 rcu_read_unlock();

396 return count;

397 }

398

399 static ssize_t add_mux_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len)

400 {

401 struct usbnet *dev = netdev_priv(to_net_dev(d));

402 struct qmi_wwan_state *info = (void *)&dev->data;

403 u8 mux_id;

404 int ret;

405

406 if (kstrtou8(buf, 0, &mux_id))

407 return -EINVAL;

408

409 /* mux_id [1 - 254] for compatibility with ip(8) and the rmnet driver */

410 if (mux_id < 1 || mux_id > 254)

411 return -EINVAL;

412

413 if (!rtnl_trylock())

414 return restart_syscall();

415

416 if (qmimux_find_dev(dev, mux_id)) {

417 netdev_err(dev->net, "mux_id already present\n");

418 ret = -EINVAL;

419 goto err;

420 }

421

422 ret = qmimux_register_device(dev->net, mux_id);

423 if (!ret) {

424 info->flags |= QMI_WWAN_FLAG_MUX;

425 ret = len;

426 }

427 err:

428 rtnl_unlock();

429 return ret;

430 }

431

432 static ssize_t del_mux_show(struct device *d, struct device_attribute *attr, char *buf)

433 {

434 return add_mux_show(d, attr, buf);

435 }

436

437 static ssize_t del_mux_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len)

438 {

439 struct usbnet *dev = netdev_priv(to_net_dev(d));

440 struct qmi_wwan_state *info = (void *)&dev->data;

441 struct net_device *del_dev;

442 u8 mux_id;

443 int ret = 0;

444

445 if (kstrtou8(buf, 0, &mux_id))

446 return -EINVAL;

447

448 if (!rtnl_trylock())

449 return restart_syscall();

450

451 del_dev = qmimux_find_dev(dev, mux_id);

452 if (!del_dev) {

453 netdev_err(dev->net, "mux_id not present\n");

454 ret = -EINVAL;

455 goto err;

456 }

457 qmimux_unregister_device(del_dev, NULL);

458

459 if (!qmimux_has_slaves(dev))

460 info->flags &= ~QMI_WWAN_FLAG_MUX;

461 ret = len;

462 err:

463 rtnl_unlock();

464 return ret;

465 }

466

467 static DEVICE_ATTR_RW(raw_ip);

468 static DEVICE_ATTR_RW(add_mux);

469 static DEVICE_ATTR_RW(del_mux);

470

471 static struct attribute *qmi_wwan_sysfs_attrs[] = {

472 &dev_attr_raw_ip.attr,

473 &dev_attr_add_mux.attr,

474 &dev_attr_del_mux.attr,

475 NULL,

476 };

477

478 static struct attribute_group qmi_wwan_sysfs_attr_group = {

479 .name = "qmi",

480 .attrs = qmi_wwan_sysfs_attrs,

481 };

482

483 /* default ethernet address used by the modem */

484 static const u8 default_modem_addr[ETH_ALEN] = {0x02, 0x50, 0xf3};

485

486 static const u8 buggy_fw_addr[ETH_ALEN] = {0x00, 0xa0, 0xc6, 0x00, 0x00, 0x00};

487

488 /* Make up an ethernet header if the packet doesn't have one.

489 *

490 * A firmware bug common among several devices cause them to send raw

491 * IP packets under some circumstances. There is no way for the

492 * driver/host to know when this will happen. And even when the bug

493 * hits, some packets will still arrive with an intact header.

494 *

495 * The supported devices are only capably of sending IPv4, IPv6 and

496 * ARP packets on a point-to-point link. Any packet with an ethernet

497 * header will have either our address or a broadcast/multicast

498 * address as destination. ARP packets will always have a header.

499 *

500 * This means that this function will reliably add the appropriate

501 * header iff necessary, provided our hardware address does not start

502 * with 4 or 6.

503 *

504 * Another common firmware bug results in all packets being addressed

505 * to 00:a0:c6:00:00:00 despite the host address being different.

506 * This function will also fixup such packets.

507 */

508 static int qmi_wwan_rx_fixup(struct usbnet *dev, struct sk_buff *skb)

509 {

510 struct qmi_wwan_state *info = (void *)&dev->data;

511 bool rawip = info->flags & QMI_WWAN_FLAG_RAWIP;

512 __be16 proto;

513

514 /* This check is no longer done by usbnet */

515 if (skb->len < dev->net->hard_header_len)

516 return 0;

517

518 if (info->flags & QMI_WWAN_FLAG_MUX)

519 return qmimux_rx_fixup(dev, skb);

520

521 switch (skb->data[0] & 0xf0) {

522 case 0x40:

523 proto = htons(ETH_P_IP);

524 break;

525 case 0x60:

526 proto = htons(ETH_P_IPV6);

527 break;

528 case 0x00:

529 if (rawip)

530 return 0;

531 if (is_multicast_ether_addr(skb->data))

532 return 1;

533 /* possibly bogus destination - rewrite just in case */

534 skb_reset_mac_header(skb);

535 goto fix_dest;

536 default:

537 if (rawip)

538 return 0;

539 /* pass along other packets without modifications */

540 return 1;

541 }

542 if (rawip) {

543 skb_reset_mac_header(skb);

544 skb->dev = dev->net; /* normally set by eth_type_trans */

545 skb->protocol = proto;

546 return 1;

547 }

548

549 if (skb_headroom(skb) < ETH_HLEN)

550 return 0;

551 skb_push(skb, ETH_HLEN);

552 skb_reset_mac_header(skb);

553 eth_hdr(skb)->h_proto = proto;

554 eth_zero_addr(eth_hdr(skb)->h_source);

555 fix_dest:

556 memcpy(eth_hdr(skb)->h_dest, dev->net->dev_addr, ETH_ALEN);

557 return 1;

558 }

559

560 /* very simplistic detection of IPv4 or IPv6 headers */

561 static bool possibly_iphdr(const char *data)

562 {

563 return (data[0] & 0xd0) == 0x40;

564 }

565

566 /* disallow addresses which may be confused with IP headers */

567 static int qmi_wwan_mac_addr(struct net_device *dev, void *p)

568 {

569 int ret;

570 struct sockaddr *addr = p;

571

572 ret = eth_prepare_mac_addr_change(dev, p);

573 if (ret < 0)

574 return ret;

575 if (possibly_iphdr(addr->sa_data))

576 return -EADDRNOTAVAIL;

577 eth_commit_mac_addr_change(dev, p);

578 return 0;

579 }

580

581 static const struct net_device_ops qmi_wwan_netdev_ops = {

582 .ndo_open = usbnet_open,

583 .ndo_stop = usbnet_stop,

584 .ndo_start_xmit = usbnet_start_xmit,

585 .ndo_tx_timeout = usbnet_tx_timeout,

586 .ndo_change_mtu = usbnet_change_mtu,

587 .ndo_get_stats64 = usbnet_get_stats64,

588 .ndo_set_mac_address = qmi_wwan_mac_addr,

589 .ndo_validate_addr = eth_validate_addr,

590 };

591

592 /* using a counter to merge subdriver requests with our own into a

593 * combined state

594 */

595 static int qmi_wwan_manage_power(struct usbnet *dev, int on)

596 {

597 struct qmi_wwan_state *info = (void *)&dev->data;

598 int rv;

599

600 dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__,

601 atomic_read(&info->pmcount), on);

602

603 if ((on && atomic_add_return(1, &info->pmcount) == 1) ||

604 (!on && atomic_dec_and_test(&info->pmcount))) {

605 /* need autopm_get/put here to ensure the usbcore sees

606 * the new value

607 */

608 rv = usb_autopm_get_interface(dev->intf);

609 dev->intf->needs_remote_wakeup = on;

610 if (!rv)

611 usb_autopm_put_interface(dev->intf);

612 }

613 return 0;

614 }

615

616 static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)

617 {

618 struct usbnet *dev = usb_get_intfdata(intf);

619

620 /* can be called while disconnecting */

621 if (!dev)

622 return 0;

623 return qmi_wwan_manage_power(dev, on);

624 }

625

626 /* collect all three endpoints and register subdriver */

627 static int qmi_wwan_register_subdriver(struct usbnet *dev)

628 {

629 int rv;

630 struct usb_driver *subdriver = NULL;

631 struct qmi_wwan_state *info = (void *)&dev->data;

632

633 /* collect bulk endpoints */

634 rv = usbnet_get_endpoints(dev, info->data);

635 if (rv < 0)

636 goto err;

637

638 /* update status endpoint if separate control interface */

639 if (info->control != info->data)

640 dev->status = &info->control->cur_altsetting->endpoint[0];

641

642 /* require interrupt endpoint for subdriver */

643 if (!dev->status) {

644 rv = -EINVAL;

645 goto err;

646 }

647

648 /* for subdriver power management */

649 atomic_set(&info->pmcount, 0);

650

651 /* register subdriver */

652 subdriver = usb_cdc_wdm_register(info->control, &dev->status->desc,

653 4096, &qmi_wwan_cdc_wdm_manage_power);

654 if (IS_ERR(subdriver)) {

655 dev_err(&info->control->dev, "subdriver registration failed\n");

656 rv = PTR_ERR(subdriver);

657 goto err;

658 }

659

660 /* prevent usbnet from using status endpoint */

661 dev->status = NULL;

662

663 /* save subdriver struct for suspend/resume wrappers */

664 info->subdriver = subdriver;

665

666 err:

667 return rv;

668 }

669

670 /* Send CDC SetControlLineState request, setting or clearing the DTR.

671 * "Required for Autoconnect and 9x30 to wake up" according to the

672 * GobiNet driver. The requirement has been verified on an MDM9230

673 * based Sierra Wireless MC7455

674 */

675 static int qmi_wwan_change_dtr(struct usbnet *dev, bool on)

676 {

677 u8 intf = dev->intf->cur_altsetting->desc.bInterfaceNumber;

678

679 return usbnet_write_cmd(dev, USB_CDC_REQ_SET_CONTROL_LINE_STATE,

680 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,

681 on ? 0x01 : 0x00, intf, NULL, 0);

682 }

683

684 static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf)

685 {

686 int status;

687 u8 *buf = intf->cur_altsetting->extra;

688 int len = intf->cur_altsetting->extralen;

689 struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;

690 struct usb_cdc_union_desc *cdc_union;

691 struct usb_cdc_ether_desc *cdc_ether;

692 struct usb_driver *driver = driver_of(intf);

693 struct qmi_wwan_state *info = (void *)&dev->data;

694 struct usb_cdc_parsed_header hdr;

695

696 BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) <

697 sizeof(struct qmi_wwan_state)));

698

699 /* set up initial state */

700 info->control = intf;

701 info->data = intf;

702

703 /* and a number of CDC descriptors */

704 cdc_parse_cdc_header(&hdr, intf, buf, len);

705 cdc_union = hdr.usb_cdc_union_desc;

706 cdc_ether = hdr.usb_cdc_ether_desc;

707

708 /* Use separate control and data interfaces if we found a CDC Union */

709 if (cdc_union) {

710 info->data = usb_ifnum_to_if(dev->udev,

711 cdc_union->bSlaveInterface0);

712 if (desc->bInterfaceNumber != cdc_union->bMasterInterface0 ||

713 !info->data) {

714 dev_err(&intf->dev,

715 "bogus CDC Union: master=%u, slave=%u\n",

716 cdc_union->bMasterInterface0,

717 cdc_union->bSlaveInterface0);

718

719 /* ignore and continue... */

720 cdc_union = NULL;

721 info->data = intf;

722 }

723 }

724

725 /* errors aren't fatal - we can live with the dynamic address */

726 if (cdc_ether && cdc_ether->wMaxSegmentSize) {

727 dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);

728 usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);

729 }

730

731 /* claim data interface and set it up */

732 if (info->control != info->data) {

733 status = usb_driver_claim_interface(driver, info->data, dev);

734 if (status < 0)

735 goto err;

736 }

737

738 status = qmi_wwan_register_subdriver(dev);

739 if (status < 0 && info->control != info->data) {

740 usb_set_intfdata(info->data, NULL);

741 usb_driver_release_interface(driver, info->data);

742 }

743

744 /* disabling remote wakeup on MDM9x30 devices has the same

745 * effect as clearing DTR. The device will not respond to QMI

746 * requests until we set DTR again. This is similar to a

747 * QMI_CTL SYNC request, clearing a lot of firmware state

748 * including the client ID allocations.

749 *

750 * Our usage model allows a session to span multiple

751 * open/close events, so we must prevent the firmware from

752 * clearing out state the clients might need.

753 *

754 * MDM9x30 is the first QMI chipset with USB3 support. Abuse

755 * this fact to enable the quirk for all USB3 devices.

756 *

757 * There are also chipsets with the same "set DTR" requirement

758 * but without USB3 support. Devices based on these chips

759 * need a quirk flag in the device ID table.

760 */

761 if (dev->driver_info->data & QMI_WWAN_QUIRK_DTR ||

762 le16_to_cpu(dev->udev->descriptor.bcdUSB) >= 0x0201) {

763 qmi_wwan_manage_power(dev, 1);

764 qmi_wwan_change_dtr(dev, true);

765 }

766

767 /* Never use the same address on both ends of the link, even if the

768 * buggy firmware told us to. Or, if device is assigned the well-known

769 * buggy firmware MAC address, replace it with a random address,

770 */

771 if (ether_addr_equal(dev->net->dev_addr, default_modem_addr) ||

772 ether_addr_equal(dev->net->dev_addr, buggy_fw_addr))

773 eth_hw_addr_random(dev->net);

774

775 /* make MAC addr easily distinguishable from an IP header */

776 if (possibly_iphdr(dev->net->dev_addr)) {

777 dev->net->dev_addr[0] |= 0x02; /* set local assignment bit */

778 dev->net->dev_addr[0] &= 0xbf; /* clear "IP" bit */

779 }

780 dev->net->netdev_ops = &qmi_wwan_netdev_ops;

781 dev->net->sysfs_groups[0] = &qmi_wwan_sysfs_attr_group;

782 err:

783 return status;

784 }

785

786 static void qmi_wwan_unbind(struct usbnet *dev, struct usb_interface *intf)

787 {

788 struct qmi_wwan_state *info = (void *)&dev->data;

789 struct usb_driver *driver = driver_of(intf);

790 struct usb_interface *other;

791

792 if (info->subdriver && info->subdriver->disconnect)

793 info->subdriver->disconnect(info->control);

794

795 /* disable MDM9x30 quirk */

796 if (le16_to_cpu(dev->udev->descriptor.bcdUSB) >= 0x0201) {

797 qmi_wwan_change_dtr(dev, false);

798 qmi_wwan_manage_power(dev, 0);

799 }

800

801 /* allow user to unbind using either control or data */

802 if (intf == info->control)

803 other = info->data;

804 else

805 other = info->control;

806

807 /* only if not shared */

808 if (other && intf != other) {

809 usb_set_intfdata(other, NULL);

810 usb_driver_release_interface(driver, other);

811 }

812

813 info->subdriver = NULL;

814 info->data = NULL;

815 info->control = NULL;

816 }

817

818 /* suspend/resume wrappers calling both usbnet and the cdc-wdm

819 * subdriver if present.

820 *

821 * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide

822 * wrappers for those without adding usbnet reset support first.

823 */

824 static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message)

825 {

826 struct usbnet *dev = usb_get_intfdata(intf);

827 struct qmi_wwan_state *info = (void *)&dev->data;

828 int ret;

829

830 /* Both usbnet_suspend() and subdriver->suspend() MUST return 0

831 * in system sleep context, otherwise, the resume callback has

832 * to recover device from previous suspend failure.

833 */

834 ret = usbnet_suspend(intf, message);

835 if (ret < 0)

836 goto err;

837

838 if (intf == info->control && info->subdriver &&

839 info->subdriver->suspend)

840 ret = info->subdriver->suspend(intf, message);

841 if (ret < 0)

842 usbnet_resume(intf);

843 err:

844 return ret;

845 }

846

847 static int qmi_wwan_resume(struct usb_interface *intf)

848 {

849 struct usbnet *dev = usb_get_intfdata(intf);

850 struct qmi_wwan_state *info = (void *)&dev->data;

851 int ret = 0;

852 bool callsub = (intf == info->control && info->subdriver &&

853 info->subdriver->resume);

854

855 if (callsub)

856 ret = info->subdriver->resume(intf);

857 if (ret < 0)

858 goto err;

859 ret = usbnet_resume(intf);

860 if (ret < 0 && callsub)

861 info->subdriver->suspend(intf, PMSG_SUSPEND);

862 err:

863 return ret;

864 }

865

866 static const struct driver_info qmi_wwan_info = {

867 .description = "WWAN/QMI device",

868 .flags = FLAG_WWAN | FLAG_SEND_ZLP,

869 .bind = qmi_wwan_bind,

870 .unbind = qmi_wwan_unbind,

871 .manage_power = qmi_wwan_manage_power,

872 .rx_fixup = qmi_wwan_rx_fixup,

873 };

874

875 static const struct driver_info qmi_wwan_info_quirk_dtr = {

876 .description = "WWAN/QMI device",

877 .flags = FLAG_WWAN | FLAG_SEND_ZLP,

878 .bind = qmi_wwan_bind,

879 .unbind = qmi_wwan_unbind,

880 .manage_power = qmi_wwan_manage_power,

881 .rx_fixup = qmi_wwan_rx_fixup,

882 .data = QMI_WWAN_QUIRK_DTR,

883 };

884

885 #define HUAWEI_VENDOR_ID 0x12D1

886

887 /* map QMI/wwan function by a fixed interface number */

888 #define QMI_FIXED_INTF(vend, prod, num) \

889 USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \

890 .driver_info = (unsigned long)&qmi_wwan_info

891

892 /* devices requiring "set DTR" quirk */

893 #define QMI_QUIRK_SET_DTR(vend, prod, num) \

894 USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \

895 .driver_info = (unsigned long)&qmi_wwan_info_quirk_dtr

896

897 /* Gobi 1000 QMI/wwan interface number is 3 according to qcserial */

898 #define QMI_GOBI1K_DEVICE(vend, prod) \

899 QMI_FIXED_INTF(vend, prod, 3)

900

901 /* Gobi 2000/3000 QMI/wwan interface number is 0 according to qcserial */

902 #define QMI_GOBI_DEVICE(vend, prod) \

903 QMI_FIXED_INTF(vend, prod, 0)

904

905 /* Many devices have QMI and DIAG functions which are distinguishable

906 * from other vendor specific functions by class, subclass and

907 * protocol all being 0xff. The DIAG function has exactly 2 endpoints

908 * and is silently rejected when probed.

909 *

910 * This makes it possible to match dynamically numbered QMI functions

911 * as seen on e.g. many Quectel modems.

912 */

913 #define QMI_MATCH_FF_FF_FF(vend, prod) \

914 USB_DEVICE_AND_INTERFACE_INFO(vend, prod, USB_CLASS_VENDOR_SPEC, \

915 USB_SUBCLASS_VENDOR_SPEC, 0xff), \

916 .driver_info = (unsigned long)&qmi_wwan_info_quirk_dtr

917

918 static const struct usb_device_id products[] = {

919 /* 1. CDC ECM like devices match on the control interface */

920 { /* Huawei E392, E398 and possibly others sharing both device id and more... */

921 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 9),

922 .driver_info = (unsigned long)&qmi_wwan_info,

923 },

924 { /* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */

925 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 57),

926 .driver_info = (unsigned long)&qmi_wwan_info,

927 },

928 { /* HUAWEI_INTERFACE_NDIS_CONTROL_QUALCOMM */

929 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x69),

930 .driver_info = (unsigned long)&qmi_wwan_info,

931 },

932 { /* Motorola Mapphone devices with MDM6600 */

933 USB_VENDOR_AND_INTERFACE_INFO(0x22b8, USB_CLASS_VENDOR_SPEC, 0xfb, 0xff),

934 .driver_info = (unsigned long)&qmi_wwan_info,

935 },

936

937 /* 2. Combined interface devices matching on class+protocol */

938 { /* Huawei E367 and possibly others in "Windows mode" */

939 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 7),

940 .driver_info = (unsigned long)&qmi_wwan_info,

941 },

942 { /* Huawei E392, E398 and possibly others in "Windows mode" */

943 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 17),

944 .driver_info = (unsigned long)&qmi_wwan_info,

945 },

946 { /* HUAWEI_NDIS_SINGLE_INTERFACE_VDF */

947 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x37),

948 .driver_info = (unsigned long)&qmi_wwan_info,

949 },

950 { /* HUAWEI_INTERFACE_NDIS_HW_QUALCOMM */

951 USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x67),

952 .driver_info = (unsigned long)&qmi_wwan_info,

953 },

954 { /* Pantech UML290, P4200 and more */

955 USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf0, 0xff),

956 .driver_info = (unsigned long)&qmi_wwan_info,

957 },

958 { /* Pantech UML290 - newer firmware */

959 USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf1, 0xff),

960 .driver_info = (unsigned long)&qmi_wwan_info,

961 },

962 { /* Novatel USB551L and MC551 */

963 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0xb001,

964 USB_CLASS_COMM,

965 USB_CDC_SUBCLASS_ETHERNET,

966 USB_CDC_PROTO_NONE),

967 .driver_info = (unsigned long)&qmi_wwan_info,

968 },

969 { /* Novatel E362 */

970 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0x9010,

971 USB_CLASS_COMM,

972 USB_CDC_SUBCLASS_ETHERNET,

973 USB_CDC_PROTO_NONE),

974 .driver_info = (unsigned long)&qmi_wwan_info,

975 },

976 { /* Novatel Expedite E371 */

977 USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0x9011,

978 USB_CLASS_COMM,

979 USB_CDC_SUBCLASS_ETHERNET,

980 USB_CDC_PROTO_NONE),

981 .driver_info = (unsigned long)&qmi_wwan_info,

982 },

983 { /* Dell Wireless 5800 (Novatel E362) */

984 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8195,

985 USB_CLASS_COMM,

986 USB_CDC_SUBCLASS_ETHERNET,

987 USB_CDC_PROTO_NONE),

988 .driver_info = (unsigned long)&qmi_wwan_info,

989 },

990 { /* Dell Wireless 5800 V2 (Novatel E362) */

991 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8196,

992 USB_CLASS_COMM,

993 USB_CDC_SUBCLASS_ETHERNET,

994 USB_CDC_PROTO_NONE),

995 .driver_info = (unsigned long)&qmi_wwan_info,

996 },

997 { /* Dell Wireless 5804 (Novatel E371) */

998 USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x819b,

999 USB_CLASS_COMM,

1000 USB_CDC_SUBCLASS_ETHERNET,

1001 USB_CDC_PROTO_NONE),

1002 .driver_info = (unsigned long)&qmi_wwan_info,

1003 },

1004 { /* ADU960S */

1005 USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a,

1006 USB_CLASS_COMM,

1007 USB_CDC_SUBCLASS_ETHERNET,

1008 USB_CDC_PROTO_NONE),

1009 .driver_info = (unsigned long)&qmi_wwan_info,

1010 },

1011 { /* HP lt2523 (Novatel E371) */

1012 USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x421d,

1013 USB_CLASS_COMM,

1014 USB_CDC_SUBCLASS_ETHERNET,

1015 USB_CDC_PROTO_NONE),

1016 .driver_info = (unsigned long)&qmi_wwan_info,

1017 },

1018 { /* HP lt4112 LTE/HSPA+ Gobi 4G Module (Huawei me906e) */

1019 USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x581d, USB_CLASS_VENDOR_SPEC, 1, 7),

1020 .driver_info = (unsigned long)&qmi_wwan_info,

1021 },

1022 {QMI_MATCH_FF_FF_FF(0x2c7c, 0x0125)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */

1023 {QMI_MATCH_FF_FF_FF(0x2c7c, 0x0306)}, /* Quectel EP06/EG06/EM06 */

1024 {QMI_MATCH_FF_FF_FF(0x2c7c, 0x0512)}, /* Quectel EG12/EM12 */

1025 {QMI_MATCH_FF_FF_FF(0x2c7c, 0x0620)}, /* Quectel EM160R-GL */

1026 {QMI_MATCH_FF_FF_FF(0x2c7c, 0x0800)}, /* Quectel RM500Q-GL */

1027 {QMI_MATCH_FF_FF_FF(0x2c7c, 0x0801)}, /* Quectel RM520N */

1028

1029 /* 3. Combined interface devices matching on interface number */

1030 {QMI_FIXED_INTF(0x0408, 0xea42, 4)}, /* Yota / Megafon M100-1 */

1031 {QMI_FIXED_INTF(0x05c6, 0x6001, 3)}, /* 4G LTE usb-modem U901 */

1032 {QMI_FIXED_INTF(0x05c6, 0x7000, 0)},

1033 {QMI_FIXED_INTF(0x05c6, 0x7001, 1)},

1034 {QMI_FIXED_INTF(0x05c6, 0x7002, 1)},

1035 {QMI_FIXED_INTF(0x05c6, 0x7101, 1)},

1036 {QMI_FIXED_INTF(0x05c6, 0x7101, 2)},

1037 {QMI_FIXED_INTF(0x05c6, 0x7101, 3)},

1038 {QMI_FIXED_INTF(0x05c6, 0x7102, 1)},

1039 {QMI_FIXED_INTF(0x05c6, 0x7102, 2)},

1040 {QMI_FIXED_INTF(0x05c6, 0x7102, 3)},

1041 {QMI_FIXED_INTF(0x05c6, 0x8000, 7)},

1042 {QMI_FIXED_INTF(0x05c6, 0x8001, 6)},

1043 {QMI_FIXED_INTF(0x05c6, 0x9000, 4)},

1044 {QMI_FIXED_INTF(0x05c6, 0x9003, 4)},

1045 {QMI_FIXED_INTF(0x05c6, 0x9005, 2)},

1046 {QMI_FIXED_INTF(0x05c6, 0x900a, 4)},

1047 {QMI_FIXED_INTF(0x05c6, 0x900b, 2)},

1048 {QMI_FIXED_INTF(0x05c6, 0x900c, 4)},

1049 {QMI_FIXED_INTF(0x05c6, 0x900c, 5)},

1050 {QMI_FIXED_INTF(0x05c6, 0x900c, 6)},

1051 {QMI_FIXED_INTF(0x05c6, 0x900d, 5)},

1052 {QMI_FIXED_INTF(0x05c6, 0x900f, 3)},

1053 {QMI_FIXED_INTF(0x05c6, 0x900f, 4)},

1054 {QMI_FIXED_INTF(0x05c6, 0x900f, 5)},

1055 {QMI_FIXED_INTF(0x05c6, 0x9010, 4)},

1056 {QMI_FIXED_INTF(0x05c6, 0x9010, 5)},

1057 {QMI_FIXED_INTF(0x05c6, 0x9011, 3)},

1058 {QMI_FIXED_INTF(0x05c6, 0x9011, 4)},

1059 {QMI_FIXED_INTF(0x05c6, 0x9021, 1)},

1060 {QMI_FIXED_INTF(0x05c6, 0x9022, 2)},

1061 {QMI_QUIRK_SET_DTR(0x05c6, 0x9025, 4)}, /* Alcatel-sbell ASB TL131 TDD LTE (China Mobile) */

1062 {QMI_FIXED_INTF(0x05c6, 0x9026, 3)},

1063 {QMI_FIXED_INTF(0x05c6, 0x902e, 5)},

1064 {QMI_FIXED_INTF(0x05c6, 0x9031, 5)},

1065 {QMI_FIXED_INTF(0x05c6, 0x9032, 4)},

1066 {QMI_FIXED_INTF(0x05c6, 0x9033, 3)},

1067 {QMI_FIXED_INTF(0x05c6, 0x9033, 4)},

1068 {QMI_FIXED_INTF(0x05c6, 0x9033, 5)},

1069 {QMI_FIXED_INTF(0x05c6, 0x9033, 6)},

1070 {QMI_FIXED_INTF(0x05c6, 0x9034, 3)},

1071 {QMI_FIXED_INTF(0x05c6, 0x9034, 4)},

1072 {QMI_FIXED_INTF(0x05c6, 0x9034, 5)},

1073 {QMI_FIXED_INTF(0x05c6, 0x9034, 6)},

1074 {QMI_FIXED_INTF(0x05c6, 0x9034, 7)},

1075 {QMI_FIXED_INTF(0x05c6, 0x9035, 4)},

1076 {QMI_FIXED_INTF(0x05c6, 0x9036, 3)},

1077 {QMI_FIXED_INTF(0x05c6, 0x9037, 5)},

1078 {QMI_FIXED_INTF(0x05c6, 0x9038, 4)},

1079 {QMI_FIXED_INTF(0x05c6, 0x903b, 7)},

1080 {QMI_FIXED_INTF(0x05c6, 0x903c, 6)},

1081 {QMI_FIXED_INTF(0x05c6, 0x903d, 6)},

1082 {QMI_FIXED_INTF(0x05c6, 0x903e, 5)},

1083 {QMI_FIXED_INTF(0x05c6, 0x9043, 3)},

1084 {QMI_FIXED_INTF(0x05c6, 0x9046, 3)},

1085 {QMI_FIXED_INTF(0x05c6, 0x9046, 4)},

1086 {QMI_FIXED_INTF(0x05c6, 0x9046, 5)},

1087 {QMI_FIXED_INTF(0x05c6, 0x9047, 2)},

1088 {QMI_FIXED_INTF(0x05c6, 0x9047, 3)},

1089 {QMI_FIXED_INTF(0x05c6, 0x9047, 4)},

1090 {QMI_FIXED_INTF(0x05c6, 0x9048, 4)},

1091 {QMI_FIXED_INTF(0x05c6, 0x9048, 5)},

1092 {QMI_FIXED_INTF(0x05c6, 0x9048, 6)},

1093 {QMI_FIXED_INTF(0x05c6, 0x9048, 7)},

1094 {QMI_FIXED_INTF(0x05c6, 0x9048, 8)},

1095 {QMI_FIXED_INTF(0x05c6, 0x904c, 5)},

1096 {QMI_FIXED_INTF(0x05c6, 0x904c, 6)},

1097 {QMI_FIXED_INTF(0x05c6, 0x904c, 7)},

1098 {QMI_FIXED_INTF(0x05c6, 0x904c, 8)},

1099 {QMI_FIXED_INTF(0x05c6, 0x9050, 3)},

1100 {QMI_FIXED_INTF(0x05c6, 0x9052, 4)},

1101 {QMI_FIXED_INTF(0x05c6, 0x9053, 6)},

1102 {QMI_FIXED_INTF(0x05c6, 0x9053, 7)},

1103 {QMI_FIXED_INTF(0x05c6, 0x9054, 5)},

1104 {QMI_FIXED_INTF(0x05c6, 0x9054, 6)},

1105 {QMI_FIXED_INTF(0x05c6, 0x9055, 3)},

1106 {QMI_FIXED_INTF(0x05c6, 0x9055, 4)},

1107 {QMI_FIXED_INTF(0x05c6, 0x9055, 5)},

1108 {QMI_FIXED_INTF(0x05c6, 0x9055, 6)},

1109 {QMI_FIXED_INTF(0x05c6, 0x9055, 7)},

1110 {QMI_FIXED_INTF(0x05c6, 0x9056, 3)},

1111 {QMI_FIXED_INTF(0x05c6, 0x9062, 2)},

1112 {QMI_FIXED_INTF(0x05c6, 0x9062, 3)},

1113 {QMI_FIXED_INTF(0x05c6, 0x9062, 4)},

1114 {QMI_FIXED_INTF(0x05c6, 0x9062, 5)},

1115 {QMI_FIXED_INTF(0x05c6, 0x9062, 6)},

1116 {QMI_FIXED_INTF(0x05c6, 0x9062, 7)},

1117 {QMI_FIXED_INTF(0x05c6, 0x9062, 8)},

1118 {QMI_FIXED_INTF(0x05c6, 0x9062, 9)},

1119 {QMI_FIXED_INTF(0x05c6, 0x9064, 3)},

1120 {QMI_FIXED_INTF(0x05c6, 0x9065, 6)},

1121 {QMI_FIXED_INTF(0x05c6, 0x9065, 7)},

1122 {QMI_FIXED_INTF(0x05c6, 0x9066, 5)},

1123 {QMI_FIXED_INTF(0x05c6, 0x9066, 6)},

1124 {QMI_FIXED_INTF(0x05c6, 0x9067, 1)},

1125 {QMI_FIXED_INTF(0x05c6, 0x9068, 2)},

1126 {QMI_FIXED_INTF(0x05c6, 0x9068, 3)},

1127 {QMI_FIXED_INTF(0x05c6, 0x9068, 4)},

1128 {QMI_FIXED_INTF(0x05c6, 0x9068, 5)},

1129 {QMI_FIXED_INTF(0x05c6, 0x9068, 6)},

1130 {QMI_FIXED_INTF(0x05c6, 0x9068, 7)},

1131 {QMI_FIXED_INTF(0x05c6, 0x9069, 5)},

1132 {QMI_FIXED_INTF(0x05c6, 0x9069, 6)},

1133 {QMI_FIXED_INTF(0x05c6, 0x9069, 7)},

1134 {QMI_FIXED_INTF(0x05c6, 0x9069, 8)},

1135 {QMI_FIXED_INTF(0x05c6, 0x9070, 4)},

1136 {QMI_FIXED_INTF(0x05c6, 0x9070, 5)},

1137 {QMI_FIXED_INTF(0x05c6, 0x9075, 5)},

1138 {QMI_FIXED_INTF(0x05c6, 0x9076, 4)},

1139 {QMI_FIXED_INTF(0x05c6, 0x9076, 5)},

1140 {QMI_FIXED_INTF(0x05c6, 0x9076, 6)},

1141 {QMI_FIXED_INTF(0x05c6, 0x9076, 7)},

1142 {QMI_FIXED_INTF(0x05c6, 0x9076, 8)},

1143 {QMI_FIXED_INTF(0x05c6, 0x9077, 3)},

1144 {QMI_FIXED_INTF(0x05c6, 0x9077, 4)},

1145 {QMI_FIXED_INTF(0x05c6, 0x9077, 5)},

1146 {QMI_FIXED_INTF(0x05c6, 0x9077, 6)},

1147 {QMI_FIXED_INTF(0x05c6, 0x9078, 3)},

1148 {QMI_FIXED_INTF(0x05c6, 0x9079, 4)},

1149 {QMI_FIXED_INTF(0x05c6, 0x9079, 5)},

1150 {QMI_FIXED_INTF(0x05c6, 0x9079, 6)},

1151 {QMI_FIXED_INTF(0x05c6, 0x9079, 7)},

1152 {QMI_FIXED_INTF(0x05c6, 0x9079, 8)},

1153 {QMI_FIXED_INTF(0x05c6, 0x9080, 5)},

1154 {QMI_FIXED_INTF(0x05c6, 0x9080, 6)},

1155 {QMI_FIXED_INTF(0x05c6, 0x9080, 7)},

1156 {QMI_FIXED_INTF(0x05c6, 0x9080, 8)},

1157 {QMI_FIXED_INTF(0x05c6, 0x9083, 3)},

1158 {QMI_FIXED_INTF(0x05c6, 0x9084, 4)},

1159 {QMI_FIXED_INTF(0x05c6, 0x90b2, 3)}, /* ublox R410M */

1160 {QMI_FIXED_INTF(0x05c6, 0x920d, 0)},

1161 {QMI_FIXED_INTF(0x05c6, 0x920d, 5)},

1162 {QMI_QUIRK_SET_DTR(0x05c6, 0x9625, 4)}, /* YUGA CLM920-NC5 */

1163 {QMI_FIXED_INTF(0x0846, 0x68a2, 8)},

1164 {QMI_FIXED_INTF(0x0846, 0x68d3, 8)}, /* Netgear Aircard 779S */

1165 {QMI_FIXED_INTF(0x12d1, 0x140c, 1)}, /* Huawei E173 */

1166 {QMI_FIXED_INTF(0x12d1, 0x14ac, 1)}, /* Huawei E1820 */

1167 {QMI_FIXED_INTF(0x1435, 0x0918, 3)}, /* Wistron NeWeb D16Q1 */

1168 {QMI_FIXED_INTF(0x1435, 0x0918, 4)}, /* Wistron NeWeb D16Q1 */

1169 {QMI_FIXED_INTF(0x1435, 0x0918, 5)}, /* Wistron NeWeb D16Q1 */

1170 {QMI_FIXED_INTF(0x1435, 0x3185, 4)}, /* Wistron NeWeb M18Q5 */

1171 {QMI_FIXED_INTF(0x1435, 0xd111, 4)}, /* M9615A DM11-1 D51QC */

1172 {QMI_FIXED_INTF(0x1435, 0xd181, 3)}, /* Wistron NeWeb D18Q1 */

1173 {QMI_FIXED_INTF(0x1435, 0xd181, 4)}, /* Wistron NeWeb D18Q1 */

1174 {QMI_FIXED_INTF(0x1435, 0xd181, 5)}, /* Wistron NeWeb D18Q1 */

1175 {QMI_FIXED_INTF(0x1435, 0xd182, 4)}, /* Wistron NeWeb D18 */

1176 {QMI_FIXED_INTF(0x1435, 0xd182, 5)}, /* Wistron NeWeb D18 */

1177 {QMI_FIXED_INTF(0x1435, 0xd191, 4)}, /* Wistron NeWeb D19Q1 */

1178 {QMI_QUIRK_SET_DTR(0x1508, 0x1001, 4)}, /* Fibocom NL668 series */

1179 {QMI_FIXED_INTF(0x1690, 0x7588, 4)}, /* ASKEY WWHC050 */

1180 {QMI_FIXED_INTF(0x16d8, 0x6003, 0)}, /* CMOTech 6003 */

1181 {QMI_FIXED_INTF(0x16d8, 0x6007, 0)}, /* CMOTech CHE-628S */

1182 {QMI_FIXED_INTF(0x16d8, 0x6008, 0)}, /* CMOTech CMU-301 */

1183 {QMI_FIXED_INTF(0x16d8, 0x6280, 0)}, /* CMOTech CHU-628 */

1184 {QMI_FIXED_INTF(0x16d8, 0x7001, 0)}, /* CMOTech CHU-720S */

1185 {QMI_FIXED_INTF(0x16d8, 0x7002, 0)}, /* CMOTech 7002 */

1186 {QMI_FIXED_INTF(0x16d8, 0x7003, 4)}, /* CMOTech CHU-629K */

1187 {QMI_FIXED_INTF(0x16d8, 0x7004, 3)}, /* CMOTech 7004 */

1188 {QMI_FIXED_INTF(0x16d8, 0x7006, 5)}, /* CMOTech CGU-629 */

1189 {QMI_FIXED_INTF(0x16d8, 0x700a, 4)}, /* CMOTech CHU-629S */

1190 {QMI_FIXED_INTF(0x16d8, 0x7211, 0)}, /* CMOTech CHU-720I */

1191 {QMI_FIXED_INTF(0x16d8, 0x7212, 0)}, /* CMOTech 7212 */

1192 {QMI_FIXED_INTF(0x16d8, 0x7213, 0)}, /* CMOTech 7213 */

1193 {QMI_FIXED_INTF(0x16d8, 0x7251, 1)}, /* CMOTech 7251 */

1194 {QMI_FIXED_INTF(0x16d8, 0x7252, 1)}, /* CMOTech 7252 */

1195 {QMI_FIXED_INTF(0x16d8, 0x7253, 1)}, /* CMOTech 7253 */

1196 {QMI_FIXED_INTF(0x19d2, 0x0002, 1)},

1197 {QMI_FIXED_INTF(0x19d2, 0x0012, 1)},

1198 {QMI_FIXED_INTF(0x19d2, 0x0017, 3)},

1199 {QMI_FIXED_INTF(0x19d2, 0x0019, 3)}, /* ONDA MT689DC */

1200 {QMI_FIXED_INTF(0x19d2, 0x0021, 4)},

1201 {QMI_FIXED_INTF(0x19d2, 0x0025, 1)},

1202 {QMI_FIXED_INTF(0x19d2, 0x0031, 4)},

1203 {QMI_FIXED_INTF(0x19d2, 0x0042, 4)},

1204 {QMI_FIXED_INTF(0x19d2, 0x0049, 5)},

1205 {QMI_FIXED_INTF(0x19d2, 0x0052, 4)},

1206 {QMI_FIXED_INTF(0x19d2, 0x0055, 1)}, /* ZTE (Vodafone) K3520-Z */

1207 {QMI_FIXED_INTF(0x19d2, 0x0058, 4)},

1208 {QMI_FIXED_INTF(0x19d2, 0x0063, 4)}, /* ZTE (Vodafone) K3565-Z */

1209 {QMI_FIXED_INTF(0x19d2, 0x0104, 4)}, /* ZTE (Vodafone) K4505-Z */

1210 {QMI_FIXED_INTF(0x19d2, 0x0113, 5)},

1211 {QMI_FIXED_INTF(0x19d2, 0x0118, 5)},

1212 {QMI_FIXED_INTF(0x19d2, 0x0121, 5)},

1213 {QMI_FIXED_INTF(0x19d2, 0x0123, 4)},

1214 {QMI_FIXED_INTF(0x19d2, 0x0124, 5)},

1215 {QMI_FIXED_INTF(0x19d2, 0x0125, 6)},

1216 {QMI_FIXED_INTF(0x19d2, 0x0126, 5)},

1217 {QMI_FIXED_INTF(0x19d2, 0x0130, 1)},

1218 {QMI_FIXED_INTF(0x19d2, 0x0133, 3)},

1219 {QMI_FIXED_INTF(0x19d2, 0x0141, 5)},

1220 {QMI_FIXED_INTF(0x19d2, 0x0157, 5)}, /* ZTE MF683 */

1221 {QMI_FIXED_INTF(0x19d2, 0x0158, 3)},

1222 {QMI_FIXED_INTF(0x19d2, 0x0167, 4)}, /* ZTE MF820D */

1223 {QMI_FIXED_INTF(0x19d2, 0x0168, 4)},

1224 {QMI_FIXED_INTF(0x19d2, 0x0176, 3)},

1225 {QMI_FIXED_INTF(0x19d2, 0x0178, 3)},

1226 {QMI_FIXED_INTF(0x19d2, 0x0191, 4)}, /* ZTE EuFi890 */

1227 {QMI_FIXED_INTF(0x19d2, 0x0199, 1)}, /* ZTE MF820S */

1228 {QMI_FIXED_INTF(0x19d2, 0x0200, 1)},

1229 {QMI_FIXED_INTF(0x19d2, 0x0257, 3)}, /* ZTE MF821 */

1230 {QMI_FIXED_INTF(0x19d2, 0x0265, 4)}, /* ONDA MT8205 4G LTE */

1231 {QMI_FIXED_INTF(0x19d2, 0x0284, 4)}, /* ZTE MF880 */

1232 {QMI_FIXED_INTF(0x19d2, 0x0326, 4)}, /* ZTE MF821D */

1233 {QMI_FIXED_INTF(0x19d2, 0x0396, 3)}, /* ZTE ZM8620 */

1234 {QMI_FIXED_INTF(0x19d2, 0x0412, 4)}, /* Telewell TW-LTE 4G */

1235 {QMI_FIXED_INTF(0x19d2, 0x1008, 4)}, /* ZTE (Vodafone) K3570-Z */

1236 {QMI_FIXED_INTF(0x19d2, 0x1010, 4)}, /* ZTE (Vodafone) K3571-Z */

1237 {QMI_FIXED_INTF(0x19d2, 0x1012, 4)},

1238 {QMI_FIXED_INTF(0x19d2, 0x1018, 3)}, /* ZTE (Vodafone) K5006-Z */

1239 {QMI_FIXED_INTF(0x19d2, 0x1021, 2)},

1240 {QMI_FIXED_INTF(0x19d2, 0x1245, 4)},

1241 {QMI_FIXED_INTF(0x19d2, 0x1247, 4)},

1242 {QMI_FIXED_INTF(0x19d2, 0x1252, 4)},

1243 {QMI_FIXED_INTF(0x19d2, 0x1254, 4)},

1244 {QMI_FIXED_INTF(0x19d2, 0x1255, 3)},

1245 {QMI_FIXED_INTF(0x19d2, 0x1255, 4)},

1246 {QMI_FIXED_INTF(0x19d2, 0x1256, 4)},

1247 {QMI_FIXED_INTF(0x19d2, 0x1270, 5)}, /* ZTE MF667 */

1248 {QMI_FIXED_INTF(0x19d2, 0x1275, 3)}, /* ZTE P685M */

1249 {QMI_FIXED_INTF(0x19d2, 0x1401, 2)},

1250 {QMI_FIXED_INTF(0x19d2, 0x1402, 2)}, /* ZTE MF60 */

1251 {QMI_FIXED_INTF(0x19d2, 0x1424, 2)},

1252 {QMI_FIXED_INTF(0x19d2, 0x1425, 2)},

1253 {QMI_FIXED_INTF(0x19d2, 0x1426, 2)}, /* ZTE MF91 */

1254 {QMI_FIXED_INTF(0x19d2, 0x1428, 2)}, /* Telewell TW-LTE 4G v2 */

1255 {QMI_FIXED_INTF(0x19d2, 0x1432, 3)}, /* ZTE ME3620 */

1256 {QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */

1257 {QMI_FIXED_INTF(0x2001, 0x7e16, 3)}, /* D-Link DWM-221 */

1258 {QMI_FIXED_INTF(0x2001, 0x7e19, 4)}, /* D-Link DWM-221 B1 */

1259 {QMI_FIXED_INTF(0x2001, 0x7e35, 4)}, /* D-Link DWM-222 */

1260 {QMI_FIXED_INTF(0x2001, 0x7e3d, 4)}, /* D-Link DWM-222 A2 */

1261 {QMI_FIXED_INTF(0x2020, 0x2031, 4)}, /* Olicard 600 */

1262 {QMI_FIXED_INTF(0x2020, 0x2033, 4)}, /* BroadMobi BM806U */

1263 {QMI_FIXED_INTF(0x2020, 0x2060, 4)}, /* BroadMobi BM818 */

1264 {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */

1265 {QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */

1266 {QMI_FIXED_INTF(0x1199, 0x68a2, 8)}, /* Sierra Wireless MC7710 in QMI mode */

1267 {QMI_FIXED_INTF(0x1199, 0x68a2, 19)}, /* Sierra Wireless MC7710 in QMI mode */

1268 {QMI_QUIRK_SET_DTR(0x1199, 0x68c0, 8)}, /* Sierra Wireless MC7304/MC7354, WP76xx */

1269 {QMI_QUIRK_SET_DTR(0x1199, 0x68c0, 10)},/* Sierra Wireless MC7304/MC7354 */

1270 {QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */

1271 {QMI_FIXED_INTF(0x1199, 0x901f, 8)}, /* Sierra Wireless EM7355 */

1272 {QMI_FIXED_INTF(0x1199, 0x9041, 8)}, /* Sierra Wireless MC7305/MC7355 */

1273 {QMI_FIXED_INTF(0x1199, 0x9041, 10)}, /* Sierra Wireless MC7305/MC7355 */

1274 {QMI_FIXED_INTF(0x1199, 0x9051, 8)}, /* Netgear AirCard 340U */

1275 {QMI_FIXED_INTF(0x1199, 0x9053, 8)}, /* Sierra Wireless Modem */

1276 {QMI_FIXED_INTF(0x1199, 0x9054, 8)}, /* Sierra Wireless Modem */

1277 {QMI_FIXED_INTF(0x1199, 0x9055, 8)}, /* Netgear AirCard 341U */

1278 {QMI_FIXED_INTF(0x1199, 0x9056, 8)}, /* Sierra Wireless Modem */

1279 {QMI_FIXED_INTF(0x1199, 0x9057, 8)},

1280 {QMI_FIXED_INTF(0x1199, 0x9061, 8)}, /* Sierra Wireless Modem */

1281 {QMI_FIXED_INTF(0x1199, 0x9063, 8)}, /* Sierra Wireless EM7305 */

1282 {QMI_FIXED_INTF(0x1199, 0x9063, 10)}, /* Sierra Wireless EM7305 */

1283 {QMI_QUIRK_SET_DTR(0x1199, 0x9071, 8)}, /* Sierra Wireless MC74xx */

1284 {QMI_QUIRK_SET_DTR(0x1199, 0x9071, 10)},/* Sierra Wireless MC74xx */

1285 {QMI_QUIRK_SET_DTR(0x1199, 0x9079, 8)}, /* Sierra Wireless EM74xx */

1286 {QMI_QUIRK_SET_DTR(0x1199, 0x9079, 10)},/* Sierra Wireless EM74xx */

1287 {QMI_QUIRK_SET_DTR(0x1199, 0x907b, 8)}, /* Sierra Wireless EM74xx */

1288 {QMI_QUIRK_SET_DTR(0x1199, 0x907b, 10)},/* Sierra Wireless EM74xx */

1289 {QMI_QUIRK_SET_DTR(0x1199, 0x9091, 8)}, /* Sierra Wireless EM7565 */

1290 {QMI_FIXED_INTF(0x1bbb, 0x011e, 4)}, /* Telekom Speedstick LTE II (Alcatel One Touch L100V LTE) */

1291 {QMI_FIXED_INTF(0x1bbb, 0x0203, 2)}, /* Alcatel L800MA */

1292 {QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */

1293 {QMI_FIXED_INTF(0x2357, 0x9000, 4)}, /* TP-LINK MA260 */

1294 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1031, 3)}, /* Telit LE910C1-EUX */

1295 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */

1296 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1050, 2)}, /* Telit FN980 */

1297 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1060, 2)}, /* Telit LN920 */

1298 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1070, 2)}, /* Telit FN990 */

1299 {QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */

1300 {QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */

1301 {QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */

1302 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1201, 2)}, /* Telit LE920, LE920A4 */

1303 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1230, 2)}, /* Telit LE910Cx */

1304 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1260, 2)}, /* Telit LE910Cx */

1305 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1261, 2)}, /* Telit LE910Cx */

1306 {QMI_QUIRK_SET_DTR(0x1bc7, 0x1900, 1)}, /* Telit LN940 series */

1307 {QMI_FIXED_INTF(0x1c9e, 0x9801, 3)}, /* Telewell TW-3G HSPA+ */

1308 {QMI_FIXED_INTF(0x1c9e, 0x9803, 4)}, /* Telewell TW-3G HSPA+ */

1309 {QMI_FIXED_INTF(0x1c9e, 0x9b01, 3)}, /* XS Stick W100-2 from 4G Systems */

1310 {QMI_FIXED_INTF(0x0b3c, 0xc000, 4)}, /* Olivetti Olicard 100 */

1311 {QMI_FIXED_INTF(0x0b3c, 0xc001, 4)}, /* Olivetti Olicard 120 */

1312 {QMI_FIXED_INTF(0x0b3c, 0xc002, 4)}, /* Olivetti Olicard 140 */

1313 {QMI_FIXED_INTF(0x0b3c, 0xc004, 6)}, /* Olivetti Olicard 155 */

1314 {QMI_FIXED_INTF(0x0b3c, 0xc005, 6)}, /* Olivetti Olicard 200 */

1315 {QMI_FIXED_INTF(0x0b3c, 0xc00a, 6)}, /* Olivetti Olicard 160 */

1316 {QMI_FIXED_INTF(0x0b3c, 0xc00b, 4)}, /* Olivetti Olicard 500 */

1317 {QMI_FIXED_INTF(0x1e2d, 0x0060, 4)}, /* Cinterion PLxx */

1318 {QMI_QUIRK_SET_DTR(0x1e2d, 0x006f, 8)}, /* Cinterion PLS83/PLS63 */

1319 {QMI_FIXED_INTF(0x1e2d, 0x0053, 4)}, /* Cinterion PHxx,PXxx */

1320 {QMI_FIXED_INTF(0x1e2d, 0x0063, 10)}, /* Cinterion ALASxx (1 RmNet) */

1321 {QMI_FIXED_INTF(0x1e2d, 0x0082, 4)}, /* Cinterion PHxx,PXxx (2 RmNet) */

1322 {QMI_FIXED_INTF(0x1e2d, 0x0082, 5)}, /* Cinterion PHxx,PXxx (2 RmNet) */

1323 {QMI_FIXED_INTF(0x1e2d, 0x0083, 4)}, /* Cinterion PHxx,PXxx (1 RmNet + USB Audio)*/

1324 {QMI_QUIRK_SET_DTR(0x1e2d, 0x00b0, 4)}, /* Cinterion CLS8 */

1325 {QMI_FIXED_INTF(0x1e2d, 0x00b7, 0)}, /* Cinterion MV31 RmNet */

1326 {QMI_FIXED_INTF(0x413c, 0x81a2, 8)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */

1327 {QMI_FIXED_INTF(0x413c, 0x81a3, 8)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */

1328 {QMI_FIXED_INTF(0x413c, 0x81a4, 8)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */

1329 {QMI_FIXED_INTF(0x413c, 0x81a8, 8)}, /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card */

1330 {QMI_FIXED_INTF(0x413c, 0x81a9, 8)}, /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */

1331 {QMI_FIXED_INTF(0x413c, 0x81b1, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card */

1332 {QMI_FIXED_INTF(0x413c, 0x81b3, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */

1333 {QMI_FIXED_INTF(0x413c, 0x81b6, 8)}, /* Dell Wireless 5811e */

1334 {QMI_FIXED_INTF(0x413c, 0x81b6, 10)}, /* Dell Wireless 5811e */

1335 {QMI_FIXED_INTF(0x413c, 0x81cc, 8)}, /* Dell Wireless 5816e */

1336 {QMI_FIXED_INTF(0x413c, 0x81d7, 0)}, /* Dell Wireless 5821e */

1337 {QMI_FIXED_INTF(0x413c, 0x81d7, 1)}, /* Dell Wireless 5821e preproduction config */

1338 {QMI_FIXED_INTF(0x413c, 0x81e0, 0)}, /* Dell Wireless 5821e with eSIM support*/

1339 {QMI_FIXED_INTF(0x413c, 0x81e4, 0)}, /* Dell Wireless 5829e with eSIM support*/

1340 {QMI_FIXED_INTF(0x413c, 0x81e6, 0)}, /* Dell Wireless 5829e */

1341 {QMI_FIXED_INTF(0x03f0, 0x4e1d, 8)}, /* HP lt4111 LTE/EV-DO/HSPA+ Gobi 4G Module */

1342 {QMI_FIXED_INTF(0x03f0, 0x9d1d, 1)}, /* HP lt4120 Snapdragon X5 LTE */

1343 {QMI_FIXED_INTF(0x22de, 0x9061, 3)}, /* WeTelecom WPD-600N */

1344 {QMI_QUIRK_SET_DTR(0x1e0e, 0x9001, 5)}, /* SIMCom 7100E, 7230E, 7600E ++ */

1345 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0121, 4)}, /* Quectel EC21 Mini PCIe */

1346 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0191, 4)}, /* Quectel EG91 */

1347 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0195, 4)}, /* Quectel EG95 */

1348 {QMI_FIXED_INTF(0x2c7c, 0x0296, 4)}, /* Quectel BG96 */

1349 {QMI_QUIRK_SET_DTR(0x2cb7, 0x0104, 4)}, /* Fibocom NL678 series */

1350 {QMI_FIXED_INTF(0x0489, 0xe0b4, 0)}, /* Foxconn T77W968 LTE */

1351 {QMI_FIXED_INTF(0x0489, 0xe0b5, 0)}, /* Foxconn T77W968 LTE with eSIM support*/

1352 {QMI_FIXED_INTF(0x2692, 0x9025, 4)}, /* Cellient MPL200 (rebranded Qualcomm 05c6:9025) */

1353

1354 /* 4. Gobi 1000 devices */

1355 {QMI_GOBI1K_DEVICE(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */

1356 {QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)}, /* HP un2400 Gobi Modem Device */

1357 {QMI_GOBI1K_DEVICE(0x04da, 0x250d)}, /* Panasonic Gobi Modem device */

1358 {QMI_GOBI1K_DEVICE(0x413c, 0x8172)}, /* Dell Gobi Modem device */

1359 {QMI_GOBI1K_DEVICE(0x1410, 0xa001)}, /* Novatel/Verizon USB-1000 */

1360 {QMI_GOBI1K_DEVICE(0x1410, 0xa002)}, /* Novatel Gobi Modem device */

1361 {QMI_GOBI1K_DEVICE(0x1410, 0xa003)}, /* Novatel Gobi Modem device */

1362 {QMI_GOBI1K_DEVICE(0x1410, 0xa004)}, /* Novatel Gobi Modem device */

1363 {QMI_GOBI1K_DEVICE(0x1410, 0xa005)}, /* Novatel Gobi Modem device */

1364 {QMI_GOBI1K_DEVICE(0x1410, 0xa006)}, /* Novatel Gobi Modem device */

1365 {QMI_GOBI1K_DEVICE(0x1410, 0xa007)}, /* Novatel Gobi Modem device */

1366 {QMI_GOBI1K_DEVICE(0x0b05, 0x1776)}, /* Asus Gobi Modem device */

1367 {QMI_GOBI1K_DEVICE(0x19d2, 0xfff3)}, /* ONDA Gobi Modem device */

1368 {QMI_GOBI1K_DEVICE(0x05c6, 0x9001)}, /* Generic Gobi Modem device */

1369 {QMI_GOBI1K_DEVICE(0x05c6, 0x9002)}, /* Generic Gobi Modem device */

1370 {QMI_GOBI1K_DEVICE(0x05c6, 0x9202)}, /* Generic Gobi Modem device */

1371 {QMI_GOBI1K_DEVICE(0x05c6, 0x9203)}, /* Generic Gobi Modem device */

1372 {QMI_GOBI1K_DEVICE(0x05c6, 0x9222)}, /* Generic Gobi Modem device */

1373 {QMI_GOBI1K_DEVICE(0x05c6, 0x9009)}, /* Generic Gobi Modem device */

1374

1375 /* 5. Gobi 2000 and 3000 devices */

1376 {QMI_GOBI_DEVICE(0x413c, 0x8186)}, /* Dell Gobi 2000 Modem device (N0218, VU936) */

1377 {QMI_GOBI_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */

1378 {QMI_GOBI_DEVICE(0x05c6, 0x920b)}, /* Generic Gobi 2000 Modem device */

1379 {QMI_GOBI_DEVICE(0x05c6, 0x9225)}, /* Sony Gobi 2000 Modem device (N0279, VU730) */

1380 {QMI_GOBI_DEVICE(0x05c6, 0x9245)}, /* Samsung Gobi 2000 Modem device (VL176) */

1381 {QMI_GOBI_DEVICE(0x03f0, 0x251d)}, /* HP Gobi 2000 Modem device (VP412) */

1382 {QMI_GOBI_DEVICE(0x05c6, 0x9215)}, /* Acer Gobi 2000 Modem device (VP413) */

1383 {QMI_FIXED_INTF(0x05c6, 0x9215, 4)}, /* Quectel EC20 Mini PCIe */

1384 {QMI_GOBI_DEVICE(0x05c6, 0x9265)}, /* Asus Gobi 2000 Modem device (VR305) */

1385 {QMI_GOBI_DEVICE(0x05c6, 0x9235)}, /* Top Global Gobi 2000 Modem device (VR306) */

1386 {QMI_GOBI_DEVICE(0x05c6, 0x9275)}, /* iRex Technologies Gobi 2000 Modem device (VR307) */

1387 {QMI_GOBI_DEVICE(0x0af0, 0x8120)}, /* Option GTM681W */

1388 {QMI_GOBI_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */

1389 {QMI_GOBI_DEVICE(0x1199, 0x68a9)}, /* Sierra Wireless Modem */

1390 {QMI_GOBI_DEVICE(0x1199, 0x9001)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1391 {QMI_GOBI_DEVICE(0x1199, 0x9002)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1392 {QMI_GOBI_DEVICE(0x1199, 0x9003)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1393 {QMI_GOBI_DEVICE(0x1199, 0x9004)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1394 {QMI_GOBI_DEVICE(0x1199, 0x9005)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1395 {QMI_GOBI_DEVICE(0x1199, 0x9006)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1396 {QMI_GOBI_DEVICE(0x1199, 0x9007)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1397 {QMI_GOBI_DEVICE(0x1199, 0x9008)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1398 {QMI_GOBI_DEVICE(0x1199, 0x9009)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1399 {QMI_GOBI_DEVICE(0x1199, 0x900a)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */

1400 {QMI_GOBI_DEVICE(0x1199, 0x9011)}, /* Sierra Wireless Gobi 2000 Modem device (MC8305) */

1401 {QMI_GOBI_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */

1402 {QMI_GOBI_DEVICE(0x05c6, 0x9205)}, /* Gobi 2000 Modem device */

1403 {QMI_GOBI_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */

1404 {QMI_GOBI_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Mobile Broadband Module */

1405 {QMI_GOBI_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */

1406 {QMI_GOBI_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */

1407 {QMI_GOBI_DEVICE(0x1199, 0x901b)}, /* Sierra Wireless MC7770 */

1408 {QMI_GOBI_DEVICE(0x12d1, 0x14f1)}, /* Sony Gobi 3000 Composite */

1409 {QMI_GOBI_DEVICE(0x1410, 0xa021)}, /* Foxconn Gobi 3000 Modem device (Novatel E396) */

1410

1411 { } /* END */

1412 };

1413 MODULE_DEVICE_TABLE(usb, products);

1414

1415 static bool quectel_ec20_detected(struct usb_interface *intf)

1416 {

1417 struct usb_device *dev = interface_to_usbdev(intf);

1418

1419 if (dev->actconfig &&

1420 le16_to_cpu(dev->descriptor.idVendor) == 0x05c6 &&

1421 le16_to_cpu(dev->descriptor.idProduct) == 0x9215 &&

1422 dev->actconfig->desc.bNumInterfaces == 5)

1423 return true;

1424

1425 return false;

1426 }

1427

1428 static int qmi_wwan_probe(struct usb_interface *intf,

1429 const struct usb_device_id *prod)

1430 {

1431 struct usb_device_id *id = (struct usb_device_id *)prod;

1432 struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;

1433

1434 /* Workaround to enable dynamic IDs. This disables usbnet

1435 * blacklisting functionality. Which, if required, can be

1436 * reimplemented here by using a magic "blacklist" value

1437 * instead of 0 in the static device id table

1438 */

1439 if (!id->driver_info) {

1440 dev_dbg(&intf->dev, "setting defaults for dynamic device id\n");

1441 id->driver_info = (unsigned long)&qmi_wwan_info;

1442 }

1443

1444 /* There are devices where the same interface number can be

1445 * configured as different functions. We should only bind to

1446 * vendor specific functions when matching on interface number

1447 */

1448 if (id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER &&

1449 desc->bInterfaceClass != USB_CLASS_VENDOR_SPEC) {

1450 dev_dbg(&intf->dev,

1451 "Rejecting interface number match for class %02x\n",

1452 desc->bInterfaceClass);

1453 return -ENODEV;

1454 }

1455

1456 /* Quectel EC20 quirk where we've QMI on interface 4 instead of 0 */

1457 if (quectel_ec20_detected(intf) && desc->bInterfaceNumber == 0) {

1458 dev_dbg(&intf->dev, "Quectel EC20 quirk, skipping interface 0\n");

1459 return -ENODEV;

1460 }

1461

1462 /* Several Quectel modems supports dynamic interface configuration, so

1463 * we need to match on class/subclass/protocol. These values are

1464 * identical for the diagnostic- and QMI-interface, but bNumEndpoints is

1465 * different. Ignore the current interface if the number of endpoints

1466 * equals the number for the diag interface (two).

1467 */

1468 if (desc->bNumEndpoints == 2)

1469 return -ENODEV;

1470

1471 return usbnet_probe(intf, id);

1472 }

1473

1474 static void qmi_wwan_disconnect(struct usb_interface *intf)

1475 {

1476 struct usbnet *dev = usb_get_intfdata(intf);

1477 struct qmi_wwan_state *info;

1478 struct list_head *iter;

1479 struct net_device *ldev;

1480 LIST_HEAD(list);

1481

1482 /* called twice if separate control and data intf */

1483 if (!dev)

1484 return;

1485 info = (void *)&dev->data;

1486 if (info->flags & QMI_WWAN_FLAG_MUX) {

1487 if (!rtnl_trylock()) {

1488 restart_syscall();

1489 return;

1490 }

1491 rcu_read_lock();

1492 netdev_for_each_upper_dev_rcu(dev->net, ldev, iter)

1493 qmimux_unregister_device(ldev, &list);

1494 rcu_read_unlock();

1495 unregister_netdevice_many(&list);

1496 rtnl_unlock();

1497 info->flags &= ~QMI_WWAN_FLAG_MUX;

1498 }

1499 usbnet_disconnect(intf);

1500 }

1501

1502 static struct usb_driver qmi_wwan_driver = {

1503 .name = "qmi_wwan",

1504 .id_table = products,

1505 .probe = qmi_wwan_probe,

1506 .disconnect = qmi_wwan_disconnect,

1507 .suspend = qmi_wwan_suspend,

1508 .resume = qmi_wwan_resume,

1509 .reset_resume = qmi_wwan_resume,

1510 .supports_autosuspend = 1,

1511 .disable_hub_initiated_lpm = 1,

1512 };

1513

1514 module_usb_driver(qmi_wwan_driver);

1515

1516 MODULE_AUTHOR("Bjørn Mork <bjorn@mork.no>");

1517 MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver");

1518 MODULE_LICENSE("GPL");