├── LICENSE ├── Makefile ├── Quectel_WCDMA<E_Linux_USB_Driver_User_Guide_V1.8.pdf ├── README.md └── drivers ├── net └── usb │ ├── qmi_wwan.c │ └── usbnet.c └── usb └── serial ├── option.c ├── qcserial.c ├── usb-wwan.h └── usb_wwan.c /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 HaiBac Ngo 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | KERNELDIR := /lib/modules/$(shell uname -r)/build 2 | PWD := $(shell pwd) 3 | 4 | obj-m+=./drivers/usb/serial/usb_wwan.o 5 | obj-m+=./drivers/usb/serial/option.o 6 | obj-m+=./drivers/usb/serial/qcserial.o 7 | obj-m+=./drivers/net/usb/qmi_wwan.o 8 | 9 | modules: clean 10 | $(MAKE) -C $(KERNELDIR) M=$(PWD) modules 11 | 12 | install: modules 13 | cp $(PWD)/drivers/usb/serial/option.ko /lib/modules/$(shell uname -r)/kernel/drivers/usb/serial/ 14 | cp $(PWD)/drivers/usb/serial/usb_wwan.ko /lib/modules/$(shell uname -r)/kernel/drivers/usb/serial/ 15 | cp $(PWD)/drivers/usb/serial/qcserial.ko /lib/modules/$(shell uname -r)/kernel/drivers/usb/serial/ 16 | cp $(PWD)/drivers/net/usb/qmi_wwan.ko /lib/modules/$(shell uname -r)/kernel/drivers/net/usb/ 17 | modprobe -r option qcserial qmi_wwan 18 | depmod 19 | 20 | clean: 21 | rm -rf *~ .tmp_versions modules.order Module.symvers 22 | find . -type f -name *~ -o -name *.o -o -name *.ko -o -name *.cmd -o -name *.mod.c | xargs rm -rf 23 | -------------------------------------------------------------------------------- /Quectel_WCDMA<E_Linux_USB_Driver_User_Guide_V1.8.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bacnh85/Quectel_Linux_USB_Driver/fd8bb12cdd6b7be7461e5c127beb8a1b18962603/Quectel_WCDMA<E_Linux_USB_Driver_User_Guide_V1.8.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Introduction 2 | 3 | Quectel USB Serial Driver for UCxx/EC2x/EGxx/EP06/EM06/BG96/AG35. 4 | 5 | As I am working in Quectel as an FAE for Vietnam and South East Asia, we will try our best to support all world wide customers. 6 | 7 | # Prepare 8 | 9 | Ubuntu 16.04 running kernel 4.15.0-43-generic. 10 | 11 | ``` 12 | $ uname -a 13 | Linux ubuntu 4.15.0-43-generic #46~16.04.1-Ubuntu SMP Fri Dec 7 13:31:08 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux 14 | 15 | ``` 16 | 17 | Download Ubuntu linux headers: 18 | 19 | ``` 20 | $ sudo apt-get install linux-headers-$(uname -r) 21 | ``` 22 | 23 | the Linux headers will be located in /usr/src/ 24 | 25 | # Compile/Install 26 | 27 | Determine the kernel version: 28 | 29 | ``` 30 | $ uname -r 31 | ``` 32 | Checkout the driver to the correct kernel version: 33 | 34 | ``` 35 | $ git clone git@github.com:ngohaibac/Quectel_USB_Serial_Driver.git 36 | $ cd Quectel_USB_Serial_Driver 37 | $ git checkout 4.15.0 38 | $ make 39 | $ sudo make install 40 | ``` 41 | 42 | # Credit 43 | 44 | This guide and kernel driver is based on Quectel Driver User Guide V1.8 by Quectel Wirreless Solutions. 45 | -------------------------------------------------------------------------------- /drivers/net/usb/qmi_wwan.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2012 Bjørn Mork 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 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | 26 | /* This driver supports wwan (3G/LTE/?) devices using a vendor 27 | * specific management protocol called Qualcomm MSM Interface (QMI) - 28 | * in addition to the more common AT commands over serial interface 29 | * management 30 | * 31 | * QMI is wrapped in CDC, using CDC encapsulated commands on the 32 | * control ("master") interface of a two-interface CDC Union 33 | * resembling standard CDC ECM. The devices do not use the control 34 | * interface for any other CDC messages. Most likely because the 35 | * management protocol is used in place of the standard CDC 36 | * notifications NOTIFY_NETWORK_CONNECTION and NOTIFY_SPEED_CHANGE 37 | * 38 | * Alternatively, control and data functions can be combined in a 39 | * single USB interface. 40 | * 41 | * Handling a protocol like QMI is out of the scope for any driver. 42 | * It is exported as a character device using the cdc-wdm driver as 43 | * a subdriver, enabling userspace applications ("modem managers") to 44 | * handle it. 45 | * 46 | * These devices may alternatively/additionally be configured using AT 47 | * commands on a serial interface 48 | */ 49 | 50 | /* driver specific data */ 51 | struct qmi_wwan_state { 52 | struct usb_driver *subdriver; 53 | atomic_t pmcount; 54 | unsigned long flags; 55 | struct usb_interface *control; 56 | struct usb_interface *data; 57 | }; 58 | 59 | enum qmi_wwan_flags { 60 | QMI_WWAN_FLAG_RAWIP = 1 << 0, 61 | QMI_WWAN_FLAG_MUX = 1 << 1, 62 | }; 63 | 64 | enum qmi_wwan_quirks { 65 | QMI_WWAN_QUIRK_DTR = 1 << 0, /* needs "set DTR" request */ 66 | }; 67 | 68 | struct qmimux_hdr { 69 | u8 pad; 70 | u8 mux_id; 71 | __be16 pkt_len; 72 | }; 73 | 74 | struct qmimux_priv { 75 | struct net_device *real_dev; 76 | u8 mux_id; 77 | }; 78 | 79 | static int qmimux_open(struct net_device *dev) 80 | { 81 | struct qmimux_priv *priv = netdev_priv(dev); 82 | struct net_device *real_dev = priv->real_dev; 83 | 84 | if (!(priv->real_dev->flags & IFF_UP)) 85 | return -ENETDOWN; 86 | 87 | if (netif_carrier_ok(real_dev)) 88 | netif_carrier_on(dev); 89 | return 0; 90 | } 91 | 92 | static int qmimux_stop(struct net_device *dev) 93 | { 94 | netif_carrier_off(dev); 95 | return 0; 96 | } 97 | 98 | static netdev_tx_t qmimux_start_xmit(struct sk_buff *skb, struct net_device *dev) 99 | { 100 | struct qmimux_priv *priv = netdev_priv(dev); 101 | unsigned int len = skb->len; 102 | struct qmimux_hdr *hdr; 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 | return dev_queue_xmit(skb); 110 | } 111 | 112 | static const struct net_device_ops qmimux_netdev_ops = { 113 | .ndo_open = qmimux_open, 114 | .ndo_stop = qmimux_stop, 115 | .ndo_start_xmit = qmimux_start_xmit, 116 | }; 117 | 118 | static void qmimux_setup(struct net_device *dev) 119 | { 120 | dev->header_ops = NULL; /* No header */ 121 | dev->type = ARPHRD_NONE; 122 | dev->hard_header_len = 0; 123 | dev->addr_len = 0; 124 | dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 125 | dev->netdev_ops = &qmimux_netdev_ops; 126 | dev->needs_free_netdev = true; 127 | } 128 | 129 | static struct net_device *qmimux_find_dev(struct usbnet *dev, u8 mux_id) 130 | { 131 | struct qmimux_priv *priv; 132 | struct list_head *iter; 133 | struct net_device *ldev; 134 | 135 | rcu_read_lock(); 136 | netdev_for_each_upper_dev_rcu(dev->net, ldev, iter) { 137 | priv = netdev_priv(ldev); 138 | if (priv->mux_id == mux_id) { 139 | rcu_read_unlock(); 140 | return ldev; 141 | } 142 | } 143 | rcu_read_unlock(); 144 | return NULL; 145 | } 146 | 147 | static bool qmimux_has_slaves(struct usbnet *dev) 148 | { 149 | return !list_empty(&dev->net->adj_list.upper); 150 | } 151 | 152 | static int qmimux_rx_fixup(struct usbnet *dev, struct sk_buff *skb) 153 | { 154 | unsigned int len, offset = sizeof(struct qmimux_hdr); 155 | struct qmimux_hdr *hdr; 156 | struct net_device *net; 157 | struct sk_buff *skbn; 158 | 159 | while (offset < skb->len) { 160 | hdr = (struct qmimux_hdr *)skb->data; 161 | len = be16_to_cpu(hdr->pkt_len); 162 | 163 | /* drop the packet, bogus length */ 164 | if (offset + len > skb->len) 165 | return 0; 166 | 167 | /* control packet, we do not know what to do */ 168 | if (hdr->pad & 0x80) 169 | goto skip; 170 | 171 | net = qmimux_find_dev(dev, hdr->mux_id); 172 | if (!net) 173 | goto skip; 174 | skbn = netdev_alloc_skb(net, len); 175 | if (!skbn) 176 | return 0; 177 | skbn->dev = net; 178 | 179 | switch (skb->data[offset] & 0xf0) { 180 | case 0x40: 181 | skbn->protocol = htons(ETH_P_IP); 182 | break; 183 | case 0x60: 184 | skbn->protocol = htons(ETH_P_IPV6); 185 | break; 186 | default: 187 | /* not ip - do not know what to do */ 188 | goto skip; 189 | } 190 | 191 | skb_put_data(skbn, skb->data + offset, len); 192 | if (netif_rx(skbn) != NET_RX_SUCCESS) 193 | return 0; 194 | 195 | skip: 196 | offset += len + sizeof(struct qmimux_hdr); 197 | } 198 | return 1; 199 | } 200 | 201 | static int qmimux_register_device(struct net_device *real_dev, u8 mux_id) 202 | { 203 | struct net_device *new_dev; 204 | struct qmimux_priv *priv; 205 | int err; 206 | 207 | new_dev = alloc_netdev(sizeof(struct qmimux_priv), 208 | "qmimux%d", NET_NAME_UNKNOWN, qmimux_setup); 209 | if (!new_dev) 210 | return -ENOBUFS; 211 | 212 | dev_net_set(new_dev, dev_net(real_dev)); 213 | priv = netdev_priv(new_dev); 214 | priv->mux_id = mux_id; 215 | priv->real_dev = real_dev; 216 | 217 | err = register_netdevice(new_dev); 218 | if (err < 0) 219 | goto out_free_newdev; 220 | 221 | /* Account for reference in struct qmimux_priv_priv */ 222 | dev_hold(real_dev); 223 | 224 | err = netdev_upper_dev_link(real_dev, new_dev, NULL); 225 | if (err) 226 | goto out_unregister_netdev; 227 | 228 | netif_stacked_transfer_operstate(real_dev, new_dev); 229 | 230 | return 0; 231 | 232 | out_unregister_netdev: 233 | unregister_netdevice(new_dev); 234 | dev_put(real_dev); 235 | 236 | out_free_newdev: 237 | free_netdev(new_dev); 238 | return err; 239 | } 240 | 241 | static void qmimux_unregister_device(struct net_device *dev) 242 | { 243 | struct qmimux_priv *priv = netdev_priv(dev); 244 | struct net_device *real_dev = priv->real_dev; 245 | 246 | netdev_upper_dev_unlink(real_dev, dev); 247 | unregister_netdevice(dev); 248 | 249 | /* Get rid of the reference to real_dev */ 250 | dev_put(real_dev); 251 | } 252 | 253 | static void qmi_wwan_netdev_setup(struct net_device *net) 254 | { 255 | struct usbnet *dev = netdev_priv(net); 256 | struct qmi_wwan_state *info = (void *)&dev->data; 257 | 258 | if (info->flags & QMI_WWAN_FLAG_RAWIP) { 259 | net->header_ops = NULL; /* No header */ 260 | net->type = ARPHRD_NONE; 261 | net->hard_header_len = 0; 262 | net->addr_len = 0; 263 | net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 264 | set_bit(EVENT_NO_IP_ALIGN, &dev->flags); 265 | netdev_dbg(net, "mode: raw IP\n"); 266 | } else if (!net->header_ops) { /* don't bother if already set */ 267 | ether_setup(net); 268 | clear_bit(EVENT_NO_IP_ALIGN, &dev->flags); 269 | netdev_dbg(net, "mode: Ethernet\n"); 270 | } 271 | 272 | /* recalculate buffers after changing hard_header_len */ 273 | usbnet_change_mtu(net, net->mtu); 274 | } 275 | 276 | static ssize_t raw_ip_show(struct device *d, struct device_attribute *attr, char *buf) 277 | { 278 | struct usbnet *dev = netdev_priv(to_net_dev(d)); 279 | struct qmi_wwan_state *info = (void *)&dev->data; 280 | 281 | return sprintf(buf, "%c\n", info->flags & QMI_WWAN_FLAG_RAWIP ? 'Y' : 'N'); 282 | } 283 | 284 | static ssize_t raw_ip_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 285 | { 286 | struct usbnet *dev = netdev_priv(to_net_dev(d)); 287 | struct qmi_wwan_state *info = (void *)&dev->data; 288 | bool enable; 289 | int ret; 290 | 291 | if (strtobool(buf, &enable)) 292 | return -EINVAL; 293 | 294 | /* no change? */ 295 | if (enable == (info->flags & QMI_WWAN_FLAG_RAWIP)) 296 | return len; 297 | 298 | if (!rtnl_trylock()) 299 | return restart_syscall(); 300 | 301 | /* we don't want to modify a running netdev */ 302 | if (netif_running(dev->net)) { 303 | netdev_err(dev->net, "Cannot change a running device\n"); 304 | ret = -EBUSY; 305 | goto err; 306 | } 307 | 308 | /* let other drivers deny the change */ 309 | ret = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, dev->net); 310 | ret = notifier_to_errno(ret); 311 | if (ret) { 312 | netdev_err(dev->net, "Type change was refused\n"); 313 | goto err; 314 | } 315 | 316 | if (enable) 317 | info->flags |= QMI_WWAN_FLAG_RAWIP; 318 | else 319 | info->flags &= ~QMI_WWAN_FLAG_RAWIP; 320 | qmi_wwan_netdev_setup(dev->net); 321 | call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev->net); 322 | ret = len; 323 | err: 324 | rtnl_unlock(); 325 | return ret; 326 | } 327 | 328 | static ssize_t add_mux_show(struct device *d, struct device_attribute *attr, char *buf) 329 | { 330 | struct net_device *dev = to_net_dev(d); 331 | struct qmimux_priv *priv; 332 | struct list_head *iter; 333 | struct net_device *ldev; 334 | ssize_t count = 0; 335 | 336 | rcu_read_lock(); 337 | netdev_for_each_upper_dev_rcu(dev, ldev, iter) { 338 | priv = netdev_priv(ldev); 339 | count += scnprintf(&buf[count], PAGE_SIZE - count, 340 | "0x%02x\n", priv->mux_id); 341 | } 342 | rcu_read_unlock(); 343 | return count; 344 | } 345 | 346 | static ssize_t add_mux_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 347 | { 348 | struct usbnet *dev = netdev_priv(to_net_dev(d)); 349 | struct qmi_wwan_state *info = (void *)&dev->data; 350 | u8 mux_id; 351 | int ret; 352 | 353 | if (kstrtou8(buf, 0, &mux_id)) 354 | return -EINVAL; 355 | 356 | /* mux_id [1 - 0x7f] range empirically found */ 357 | if (mux_id < 1 || mux_id > 0x7f) 358 | return -EINVAL; 359 | 360 | if (!rtnl_trylock()) 361 | return restart_syscall(); 362 | 363 | if (qmimux_find_dev(dev, mux_id)) { 364 | netdev_err(dev->net, "mux_id already present\n"); 365 | ret = -EINVAL; 366 | goto err; 367 | } 368 | 369 | /* we don't want to modify a running netdev */ 370 | if (netif_running(dev->net)) { 371 | netdev_err(dev->net, "Cannot change a running device\n"); 372 | ret = -EBUSY; 373 | goto err; 374 | } 375 | 376 | ret = qmimux_register_device(dev->net, mux_id); 377 | if (!ret) { 378 | info->flags |= QMI_WWAN_FLAG_MUX; 379 | ret = len; 380 | } 381 | err: 382 | rtnl_unlock(); 383 | return ret; 384 | } 385 | 386 | static ssize_t del_mux_show(struct device *d, struct device_attribute *attr, char *buf) 387 | { 388 | return add_mux_show(d, attr, buf); 389 | } 390 | 391 | static ssize_t del_mux_store(struct device *d, struct device_attribute *attr, const char *buf, size_t len) 392 | { 393 | struct usbnet *dev = netdev_priv(to_net_dev(d)); 394 | struct qmi_wwan_state *info = (void *)&dev->data; 395 | struct net_device *del_dev; 396 | u8 mux_id; 397 | int ret = 0; 398 | 399 | if (kstrtou8(buf, 0, &mux_id)) 400 | return -EINVAL; 401 | 402 | if (!rtnl_trylock()) 403 | return restart_syscall(); 404 | 405 | /* we don't want to modify a running netdev */ 406 | if (netif_running(dev->net)) { 407 | netdev_err(dev->net, "Cannot change a running device\n"); 408 | ret = -EBUSY; 409 | goto err; 410 | } 411 | 412 | del_dev = qmimux_find_dev(dev, mux_id); 413 | if (!del_dev) { 414 | netdev_err(dev->net, "mux_id not present\n"); 415 | ret = -EINVAL; 416 | goto err; 417 | } 418 | qmimux_unregister_device(del_dev); 419 | 420 | if (!qmimux_has_slaves(dev)) 421 | info->flags &= ~QMI_WWAN_FLAG_MUX; 422 | ret = len; 423 | err: 424 | rtnl_unlock(); 425 | return ret; 426 | } 427 | 428 | static DEVICE_ATTR_RW(raw_ip); 429 | static DEVICE_ATTR_RW(add_mux); 430 | static DEVICE_ATTR_RW(del_mux); 431 | 432 | static struct attribute *qmi_wwan_sysfs_attrs[] = { 433 | &dev_attr_raw_ip.attr, 434 | &dev_attr_add_mux.attr, 435 | &dev_attr_del_mux.attr, 436 | NULL, 437 | }; 438 | 439 | static struct attribute_group qmi_wwan_sysfs_attr_group = { 440 | .name = "qmi", 441 | .attrs = qmi_wwan_sysfs_attrs, 442 | }; 443 | 444 | /* default ethernet address used by the modem */ 445 | static const u8 default_modem_addr[ETH_ALEN] = {0x02, 0x50, 0xf3}; 446 | 447 | static const u8 buggy_fw_addr[ETH_ALEN] = {0x00, 0xa0, 0xc6, 0x00, 0x00, 0x00}; 448 | 449 | /* Make up an ethernet header if the packet doesn't have one. 450 | * 451 | * A firmware bug common among several devices cause them to send raw 452 | * IP packets under some circumstances. There is no way for the 453 | * driver/host to know when this will happen. And even when the bug 454 | * hits, some packets will still arrive with an intact header. 455 | * 456 | * The supported devices are only capably of sending IPv4, IPv6 and 457 | * ARP packets on a point-to-point link. Any packet with an ethernet 458 | * header will have either our address or a broadcast/multicast 459 | * address as destination. ARP packets will always have a header. 460 | * 461 | * This means that this function will reliably add the appropriate 462 | * header iff necessary, provided our hardware address does not start 463 | * with 4 or 6. 464 | * 465 | * Another common firmware bug results in all packets being addressed 466 | * to 00:a0:c6:00:00:00 despite the host address being different. 467 | * This function will also fixup such packets. 468 | */ 469 | static int qmi_wwan_rx_fixup(struct usbnet *dev, struct sk_buff *skb) 470 | { 471 | struct qmi_wwan_state *info = (void *)&dev->data; 472 | bool rawip = info->flags & QMI_WWAN_FLAG_RAWIP; 473 | __be16 proto; 474 | 475 | /* This check is no longer done by usbnet */ 476 | if (skb->len < dev->net->hard_header_len) 477 | return 0; 478 | 479 | if (info->flags & QMI_WWAN_FLAG_MUX) 480 | return qmimux_rx_fixup(dev, skb); 481 | 482 | switch (skb->data[0] & 0xf0) { 483 | case 0x40: 484 | proto = htons(ETH_P_IP); 485 | break; 486 | case 0x60: 487 | proto = htons(ETH_P_IPV6); 488 | break; 489 | case 0x00: 490 | if (rawip) 491 | return 0; 492 | if (is_multicast_ether_addr(skb->data)) 493 | return 1; 494 | /* possibly bogus destination - rewrite just in case */ 495 | skb_reset_mac_header(skb); 496 | goto fix_dest; 497 | default: 498 | if (rawip) 499 | return 0; 500 | /* pass along other packets without modifications */ 501 | return 1; 502 | } 503 | if (rawip) { 504 | skb_reset_mac_header(skb); 505 | skb->dev = dev->net; /* normally set by eth_type_trans */ 506 | skb->protocol = proto; 507 | return 1; 508 | } 509 | 510 | if (skb_headroom(skb) < ETH_HLEN) 511 | return 0; 512 | skb_push(skb, ETH_HLEN); 513 | skb_reset_mac_header(skb); 514 | eth_hdr(skb)->h_proto = proto; 515 | eth_zero_addr(eth_hdr(skb)->h_source); 516 | fix_dest: 517 | memcpy(eth_hdr(skb)->h_dest, dev->net->dev_addr, ETH_ALEN); 518 | return 1; 519 | } 520 | 521 | /* very simplistic detection of IPv4 or IPv6 headers */ 522 | static bool possibly_iphdr(const char *data) 523 | { 524 | return (data[0] & 0xd0) == 0x40; 525 | } 526 | 527 | /* disallow addresses which may be confused with IP headers */ 528 | static int qmi_wwan_mac_addr(struct net_device *dev, void *p) 529 | { 530 | int ret; 531 | struct sockaddr *addr = p; 532 | 533 | ret = eth_prepare_mac_addr_change(dev, p); 534 | if (ret < 0) 535 | return ret; 536 | if (possibly_iphdr(addr->sa_data)) 537 | return -EADDRNOTAVAIL; 538 | eth_commit_mac_addr_change(dev, p); 539 | return 0; 540 | } 541 | 542 | static const struct net_device_ops qmi_wwan_netdev_ops = { 543 | .ndo_open = usbnet_open, 544 | .ndo_stop = usbnet_stop, 545 | .ndo_start_xmit = usbnet_start_xmit, 546 | .ndo_tx_timeout = usbnet_tx_timeout, 547 | .ndo_change_mtu = usbnet_change_mtu, 548 | .ndo_get_stats64 = usbnet_get_stats64, 549 | .ndo_set_mac_address = qmi_wwan_mac_addr, 550 | .ndo_validate_addr = eth_validate_addr, 551 | }; 552 | 553 | /* using a counter to merge subdriver requests with our own into a 554 | * combined state 555 | */ 556 | static int qmi_wwan_manage_power(struct usbnet *dev, int on) 557 | { 558 | struct qmi_wwan_state *info = (void *)&dev->data; 559 | int rv; 560 | 561 | dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__, 562 | atomic_read(&info->pmcount), on); 563 | 564 | if ((on && atomic_add_return(1, &info->pmcount) == 1) || 565 | (!on && atomic_dec_and_test(&info->pmcount))) { 566 | /* need autopm_get/put here to ensure the usbcore sees 567 | * the new value 568 | */ 569 | rv = usb_autopm_get_interface(dev->intf); 570 | dev->intf->needs_remote_wakeup = on; 571 | if (!rv) 572 | usb_autopm_put_interface(dev->intf); 573 | } 574 | return 0; 575 | } 576 | 577 | static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on) 578 | { 579 | struct usbnet *dev = usb_get_intfdata(intf); 580 | 581 | /* can be called while disconnecting */ 582 | if (!dev) 583 | return 0; 584 | return qmi_wwan_manage_power(dev, on); 585 | } 586 | 587 | /* collect all three endpoints and register subdriver */ 588 | static int qmi_wwan_register_subdriver(struct usbnet *dev) 589 | { 590 | int rv; 591 | struct usb_driver *subdriver = NULL; 592 | struct qmi_wwan_state *info = (void *)&dev->data; 593 | 594 | /* collect bulk endpoints */ 595 | rv = usbnet_get_endpoints(dev, info->data); 596 | if (rv < 0) 597 | goto err; 598 | 599 | /* update status endpoint if separate control interface */ 600 | if (info->control != info->data) 601 | dev->status = &info->control->cur_altsetting->endpoint[0]; 602 | 603 | /* require interrupt endpoint for subdriver */ 604 | if (!dev->status) { 605 | rv = -EINVAL; 606 | goto err; 607 | } 608 | 609 | /* for subdriver power management */ 610 | atomic_set(&info->pmcount, 0); 611 | 612 | /* register subdriver */ 613 | subdriver = usb_cdc_wdm_register(info->control, &dev->status->desc, 614 | 4096, &qmi_wwan_cdc_wdm_manage_power); 615 | if (IS_ERR(subdriver)) { 616 | dev_err(&info->control->dev, "subdriver registration failed\n"); 617 | rv = PTR_ERR(subdriver); 618 | goto err; 619 | } 620 | 621 | /* prevent usbnet from using status endpoint */ 622 | dev->status = NULL; 623 | 624 | /* save subdriver struct for suspend/resume wrappers */ 625 | info->subdriver = subdriver; 626 | 627 | err: 628 | return rv; 629 | } 630 | 631 | /* Send CDC SetControlLineState request, setting or clearing the DTR. 632 | * "Required for Autoconnect and 9x30 to wake up" according to the 633 | * GobiNet driver. The requirement has been verified on an MDM9230 634 | * based Sierra Wireless MC7455 635 | */ 636 | static int qmi_wwan_change_dtr(struct usbnet *dev, bool on) 637 | { 638 | u8 intf = dev->intf->cur_altsetting->desc.bInterfaceNumber; 639 | 640 | return usbnet_write_cmd(dev, USB_CDC_REQ_SET_CONTROL_LINE_STATE, 641 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 642 | on ? 0x01 : 0x00, intf, NULL, 0); 643 | } 644 | 645 | static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf) 646 | { 647 | int status = -1; 648 | u8 *buf = intf->cur_altsetting->extra; 649 | int len = intf->cur_altsetting->extralen; 650 | struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc; 651 | struct usb_cdc_union_desc *cdc_union; 652 | struct usb_cdc_ether_desc *cdc_ether; 653 | struct usb_driver *driver = driver_of(intf); 654 | struct qmi_wwan_state *info = (void *)&dev->data; 655 | struct usb_cdc_parsed_header hdr; 656 | 657 | BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) < 658 | sizeof(struct qmi_wwan_state))); 659 | 660 | /* set up initial state */ 661 | info->control = intf; 662 | info->data = intf; 663 | 664 | /* and a number of CDC descriptors */ 665 | cdc_parse_cdc_header(&hdr, intf, buf, len); 666 | cdc_union = hdr.usb_cdc_union_desc; 667 | cdc_ether = hdr.usb_cdc_ether_desc; 668 | 669 | /* Use separate control and data interfaces if we found a CDC Union */ 670 | if (cdc_union) { 671 | info->data = usb_ifnum_to_if(dev->udev, 672 | cdc_union->bSlaveInterface0); 673 | if (desc->bInterfaceNumber != cdc_union->bMasterInterface0 || 674 | !info->data) { 675 | dev_err(&intf->dev, 676 | "bogus CDC Union: master=%u, slave=%u\n", 677 | cdc_union->bMasterInterface0, 678 | cdc_union->bSlaveInterface0); 679 | 680 | /* ignore and continue... */ 681 | cdc_union = NULL; 682 | info->data = intf; 683 | } 684 | } 685 | 686 | /* errors aren't fatal - we can live with the dynamic address */ 687 | if (cdc_ether && cdc_ether->wMaxSegmentSize) { 688 | dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize); 689 | usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress); 690 | } 691 | 692 | /* claim data interface and set it up */ 693 | if (info->control != info->data) { 694 | status = usb_driver_claim_interface(driver, info->data, dev); 695 | if (status < 0) 696 | goto err; 697 | } 698 | 699 | status = qmi_wwan_register_subdriver(dev); 700 | if (status < 0 && info->control != info->data) { 701 | usb_set_intfdata(info->data, NULL); 702 | usb_driver_release_interface(driver, info->data); 703 | } 704 | 705 | /* disabling remote wakeup on MDM9x30 devices has the same 706 | * effect as clearing DTR. The device will not respond to QMI 707 | * requests until we set DTR again. This is similar to a 708 | * QMI_CTL SYNC request, clearing a lot of firmware state 709 | * including the client ID allocations. 710 | * 711 | * Our usage model allows a session to span multiple 712 | * open/close events, so we must prevent the firmware from 713 | * clearing out state the clients might need. 714 | * 715 | * MDM9x30 is the first QMI chipset with USB3 support. Abuse 716 | * this fact to enable the quirk for all USB3 devices. 717 | * 718 | * There are also chipsets with the same "set DTR" requirement 719 | * but without USB3 support. Devices based on these chips 720 | * need a quirk flag in the device ID table. 721 | */ 722 | if (dev->driver_info->data & QMI_WWAN_QUIRK_DTR || 723 | le16_to_cpu(dev->udev->descriptor.bcdUSB) >= 0x0201) { 724 | qmi_wwan_manage_power(dev, 1); 725 | qmi_wwan_change_dtr(dev, true); 726 | } 727 | 728 | /* Never use the same address on both ends of the link, even if the 729 | * buggy firmware told us to. Or, if device is assigned the well-known 730 | * buggy firmware MAC address, replace it with a random address, 731 | */ 732 | if (ether_addr_equal(dev->net->dev_addr, default_modem_addr) || 733 | ether_addr_equal(dev->net->dev_addr, buggy_fw_addr)) 734 | eth_hw_addr_random(dev->net); 735 | 736 | /* make MAC addr easily distinguishable from an IP header */ 737 | if (possibly_iphdr(dev->net->dev_addr)) { 738 | dev->net->dev_addr[0] |= 0x02; /* set local assignment bit */ 739 | dev->net->dev_addr[0] &= 0xbf; /* clear "IP" bit */ 740 | } 741 | dev->net->netdev_ops = &qmi_wwan_netdev_ops; 742 | dev->net->sysfs_groups[0] = &qmi_wwan_sysfs_attr_group; 743 | err: 744 | return status; 745 | } 746 | 747 | static void qmi_wwan_unbind(struct usbnet *dev, struct usb_interface *intf) 748 | { 749 | struct qmi_wwan_state *info = (void *)&dev->data; 750 | struct usb_driver *driver = driver_of(intf); 751 | struct usb_interface *other; 752 | 753 | if (info->subdriver && info->subdriver->disconnect) 754 | info->subdriver->disconnect(info->control); 755 | 756 | /* disable MDM9x30 quirk */ 757 | if (le16_to_cpu(dev->udev->descriptor.bcdUSB) >= 0x0201) { 758 | qmi_wwan_change_dtr(dev, false); 759 | qmi_wwan_manage_power(dev, 0); 760 | } 761 | 762 | /* allow user to unbind using either control or data */ 763 | if (intf == info->control) 764 | other = info->data; 765 | else 766 | other = info->control; 767 | 768 | /* only if not shared */ 769 | if (other && intf != other) { 770 | usb_set_intfdata(other, NULL); 771 | usb_driver_release_interface(driver, other); 772 | } 773 | 774 | info->subdriver = NULL; 775 | info->data = NULL; 776 | info->control = NULL; 777 | } 778 | 779 | /* suspend/resume wrappers calling both usbnet and the cdc-wdm 780 | * subdriver if present. 781 | * 782 | * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide 783 | * wrappers for those without adding usbnet reset support first. 784 | */ 785 | static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message) 786 | { 787 | struct usbnet *dev = usb_get_intfdata(intf); 788 | struct qmi_wwan_state *info = (void *)&dev->data; 789 | int ret; 790 | 791 | /* Both usbnet_suspend() and subdriver->suspend() MUST return 0 792 | * in system sleep context, otherwise, the resume callback has 793 | * to recover device from previous suspend failure. 794 | */ 795 | ret = usbnet_suspend(intf, message); 796 | if (ret < 0) 797 | goto err; 798 | 799 | if (intf == info->control && info->subdriver && 800 | info->subdriver->suspend) 801 | ret = info->subdriver->suspend(intf, message); 802 | if (ret < 0) 803 | usbnet_resume(intf); 804 | err: 805 | return ret; 806 | } 807 | 808 | static int qmi_wwan_resume(struct usb_interface *intf) 809 | { 810 | struct usbnet *dev = usb_get_intfdata(intf); 811 | struct qmi_wwan_state *info = (void *)&dev->data; 812 | int ret = 0; 813 | bool callsub = (intf == info->control && info->subdriver && 814 | info->subdriver->resume); 815 | 816 | if (callsub) 817 | ret = info->subdriver->resume(intf); 818 | if (ret < 0) 819 | goto err; 820 | ret = usbnet_resume(intf); 821 | if (ret < 0 && callsub) 822 | info->subdriver->suspend(intf, PMSG_SUSPEND); 823 | err: 824 | return ret; 825 | } 826 | 827 | static const struct driver_info qmi_wwan_info = { 828 | .description = "WWAN/QMI device", 829 | .flags = FLAG_WWAN, 830 | .bind = qmi_wwan_bind, 831 | .unbind = qmi_wwan_unbind, 832 | .manage_power = qmi_wwan_manage_power, 833 | .rx_fixup = qmi_wwan_rx_fixup, 834 | }; 835 | 836 | static const struct driver_info qmi_wwan_info_quirk_dtr = { 837 | .description = "WWAN/QMI device", 838 | .flags = FLAG_WWAN, 839 | .bind = qmi_wwan_bind, 840 | .unbind = qmi_wwan_unbind, 841 | .manage_power = qmi_wwan_manage_power, 842 | .rx_fixup = qmi_wwan_rx_fixup, 843 | .data = QMI_WWAN_QUIRK_DTR, 844 | }; 845 | 846 | #define HUAWEI_VENDOR_ID 0x12D1 847 | 848 | /* map QMI/wwan function by a fixed interface number */ 849 | #define QMI_FIXED_INTF(vend, prod, num) \ 850 | USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \ 851 | .driver_info = (unsigned long)&qmi_wwan_info 852 | 853 | /* devices requiring "set DTR" quirk */ 854 | #define QMI_QUIRK_SET_DTR(vend, prod, num) \ 855 | USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \ 856 | .driver_info = (unsigned long)&qmi_wwan_info_quirk_dtr 857 | 858 | /* Gobi 1000 QMI/wwan interface number is 3 according to qcserial */ 859 | #define QMI_GOBI1K_DEVICE(vend, prod) \ 860 | QMI_FIXED_INTF(vend, prod, 3) 861 | 862 | /* Gobi 2000/3000 QMI/wwan interface number is 0 according to qcserial */ 863 | #define QMI_GOBI_DEVICE(vend, prod) \ 864 | QMI_FIXED_INTF(vend, prod, 0) 865 | 866 | static const struct usb_device_id products[] = { 867 | /* 1. CDC ECM like devices match on the control interface */ 868 | { /* Huawei E392, E398 and possibly others sharing both device id and more... */ 869 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 9), 870 | .driver_info = (unsigned long)&qmi_wwan_info, 871 | }, 872 | { /* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */ 873 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 57), 874 | .driver_info = (unsigned long)&qmi_wwan_info, 875 | }, 876 | { /* HUAWEI_INTERFACE_NDIS_CONTROL_QUALCOMM */ 877 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x69), 878 | .driver_info = (unsigned long)&qmi_wwan_info, 879 | }, 880 | { /* Motorola Mapphone devices with MDM6600 */ 881 | USB_VENDOR_AND_INTERFACE_INFO(0x22b8, USB_CLASS_VENDOR_SPEC, 0xfb, 0xff), 882 | .driver_info = (unsigned long)&qmi_wwan_info, 883 | }, 884 | 885 | /* 2. Combined interface devices matching on class+protocol */ 886 | { /* Huawei E367 and possibly others in "Windows mode" */ 887 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 7), 888 | .driver_info = (unsigned long)&qmi_wwan_info, 889 | }, 890 | { /* Huawei E392, E398 and possibly others in "Windows mode" */ 891 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 17), 892 | .driver_info = (unsigned long)&qmi_wwan_info, 893 | }, 894 | { /* HUAWEI_NDIS_SINGLE_INTERFACE_VDF */ 895 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x37), 896 | .driver_info = (unsigned long)&qmi_wwan_info, 897 | }, 898 | { /* HUAWEI_INTERFACE_NDIS_HW_QUALCOMM */ 899 | USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 0x01, 0x67), 900 | .driver_info = (unsigned long)&qmi_wwan_info, 901 | }, 902 | { /* Pantech UML290, P4200 and more */ 903 | USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf0, 0xff), 904 | .driver_info = (unsigned long)&qmi_wwan_info, 905 | }, 906 | { /* Pantech UML290 - newer firmware */ 907 | USB_VENDOR_AND_INTERFACE_INFO(0x106c, USB_CLASS_VENDOR_SPEC, 0xf1, 0xff), 908 | .driver_info = (unsigned long)&qmi_wwan_info, 909 | }, 910 | { /* Novatel USB551L and MC551 */ 911 | USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0xb001, 912 | USB_CLASS_COMM, 913 | USB_CDC_SUBCLASS_ETHERNET, 914 | USB_CDC_PROTO_NONE), 915 | .driver_info = (unsigned long)&qmi_wwan_info, 916 | }, 917 | { /* Novatel E362 */ 918 | USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0x9010, 919 | USB_CLASS_COMM, 920 | USB_CDC_SUBCLASS_ETHERNET, 921 | USB_CDC_PROTO_NONE), 922 | .driver_info = (unsigned long)&qmi_wwan_info, 923 | }, 924 | { /* Novatel Expedite E371 */ 925 | USB_DEVICE_AND_INTERFACE_INFO(0x1410, 0x9011, 926 | USB_CLASS_COMM, 927 | USB_CDC_SUBCLASS_ETHERNET, 928 | USB_CDC_PROTO_NONE), 929 | .driver_info = (unsigned long)&qmi_wwan_info, 930 | }, 931 | { /* Dell Wireless 5800 (Novatel E362) */ 932 | USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8195, 933 | USB_CLASS_COMM, 934 | USB_CDC_SUBCLASS_ETHERNET, 935 | USB_CDC_PROTO_NONE), 936 | .driver_info = (unsigned long)&qmi_wwan_info, 937 | }, 938 | { /* Dell Wireless 5800 V2 (Novatel E362) */ 939 | USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x8196, 940 | USB_CLASS_COMM, 941 | USB_CDC_SUBCLASS_ETHERNET, 942 | USB_CDC_PROTO_NONE), 943 | .driver_info = (unsigned long)&qmi_wwan_info, 944 | }, 945 | { /* Dell Wireless 5804 (Novatel E371) */ 946 | USB_DEVICE_AND_INTERFACE_INFO(0x413C, 0x819b, 947 | USB_CLASS_COMM, 948 | USB_CDC_SUBCLASS_ETHERNET, 949 | USB_CDC_PROTO_NONE), 950 | .driver_info = (unsigned long)&qmi_wwan_info, 951 | }, 952 | { /* ADU960S */ 953 | USB_DEVICE_AND_INTERFACE_INFO(0x16d5, 0x650a, 954 | USB_CLASS_COMM, 955 | USB_CDC_SUBCLASS_ETHERNET, 956 | USB_CDC_PROTO_NONE), 957 | .driver_info = (unsigned long)&qmi_wwan_info, 958 | }, 959 | { /* HP lt2523 (Novatel E371) */ 960 | USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x421d, 961 | USB_CLASS_COMM, 962 | USB_CDC_SUBCLASS_ETHERNET, 963 | USB_CDC_PROTO_NONE), 964 | .driver_info = (unsigned long)&qmi_wwan_info, 965 | }, 966 | { /* HP lt4112 LTE/HSPA+ Gobi 4G Module (Huawei me906e) */ 967 | USB_DEVICE_AND_INTERFACE_INFO(0x03f0, 0x581d, USB_CLASS_VENDOR_SPEC, 1, 7), 968 | .driver_info = (unsigned long)&qmi_wwan_info, 969 | }, 970 | 971 | /* 3. Combined interface devices matching on interface number */ 972 | {QMI_FIXED_INTF(0x0408, 0xea42, 4)}, /* Yota / Megafon M100-1 */ 973 | {QMI_FIXED_INTF(0x05c6, 0x6001, 3)}, /* 4G LTE usb-modem U901 */ 974 | {QMI_FIXED_INTF(0x05c6, 0x7000, 0)}, 975 | {QMI_FIXED_INTF(0x05c6, 0x7001, 1)}, 976 | {QMI_FIXED_INTF(0x05c6, 0x7002, 1)}, 977 | {QMI_FIXED_INTF(0x05c6, 0x7101, 1)}, 978 | {QMI_FIXED_INTF(0x05c6, 0x7101, 2)}, 979 | {QMI_FIXED_INTF(0x05c6, 0x7101, 3)}, 980 | {QMI_FIXED_INTF(0x05c6, 0x7102, 1)}, 981 | {QMI_FIXED_INTF(0x05c6, 0x7102, 2)}, 982 | {QMI_FIXED_INTF(0x05c6, 0x7102, 3)}, 983 | {QMI_FIXED_INTF(0x05c6, 0x8000, 7)}, 984 | {QMI_FIXED_INTF(0x05c6, 0x8001, 6)}, 985 | {QMI_FIXED_INTF(0x05c6, 0x9000, 4)}, 986 | {QMI_FIXED_INTF(0x05c6, 0x9003, 4)}, 987 | {QMI_FIXED_INTF(0x05c6, 0x9005, 2)}, 988 | {QMI_FIXED_INTF(0x05c6, 0x900a, 4)}, 989 | {QMI_FIXED_INTF(0x05c6, 0x900b, 2)}, 990 | {QMI_FIXED_INTF(0x05c6, 0x900c, 4)}, 991 | {QMI_FIXED_INTF(0x05c6, 0x900c, 5)}, 992 | {QMI_FIXED_INTF(0x05c6, 0x900c, 6)}, 993 | {QMI_FIXED_INTF(0x05c6, 0x900d, 5)}, 994 | {QMI_FIXED_INTF(0x05c6, 0x900f, 3)}, 995 | {QMI_FIXED_INTF(0x05c6, 0x900f, 4)}, 996 | {QMI_FIXED_INTF(0x05c6, 0x900f, 5)}, 997 | {QMI_FIXED_INTF(0x05c6, 0x9010, 4)}, 998 | {QMI_FIXED_INTF(0x05c6, 0x9010, 5)}, 999 | {QMI_FIXED_INTF(0x05c6, 0x9011, 3)}, 1000 | {QMI_FIXED_INTF(0x05c6, 0x9011, 4)}, 1001 | {QMI_FIXED_INTF(0x05c6, 0x9021, 1)}, 1002 | {QMI_FIXED_INTF(0x05c6, 0x9022, 2)}, 1003 | {QMI_FIXED_INTF(0x05c6, 0x9025, 4)}, /* Alcatel-sbell ASB TL131 TDD LTE (China Mobile) */ 1004 | {QMI_FIXED_INTF(0x05c6, 0x9026, 3)}, 1005 | {QMI_FIXED_INTF(0x05c6, 0x902e, 5)}, 1006 | {QMI_FIXED_INTF(0x05c6, 0x9031, 5)}, 1007 | {QMI_FIXED_INTF(0x05c6, 0x9032, 4)}, 1008 | {QMI_FIXED_INTF(0x05c6, 0x9033, 3)}, 1009 | {QMI_FIXED_INTF(0x05c6, 0x9033, 4)}, 1010 | {QMI_FIXED_INTF(0x05c6, 0x9033, 5)}, 1011 | {QMI_FIXED_INTF(0x05c6, 0x9033, 6)}, 1012 | {QMI_FIXED_INTF(0x05c6, 0x9034, 3)}, 1013 | {QMI_FIXED_INTF(0x05c6, 0x9034, 4)}, 1014 | {QMI_FIXED_INTF(0x05c6, 0x9034, 5)}, 1015 | {QMI_FIXED_INTF(0x05c6, 0x9034, 6)}, 1016 | {QMI_FIXED_INTF(0x05c6, 0x9034, 7)}, 1017 | {QMI_FIXED_INTF(0x05c6, 0x9035, 4)}, 1018 | {QMI_FIXED_INTF(0x05c6, 0x9036, 3)}, 1019 | {QMI_FIXED_INTF(0x05c6, 0x9037, 5)}, 1020 | {QMI_FIXED_INTF(0x05c6, 0x9038, 4)}, 1021 | {QMI_FIXED_INTF(0x05c6, 0x903b, 7)}, 1022 | {QMI_FIXED_INTF(0x05c6, 0x903c, 6)}, 1023 | {QMI_FIXED_INTF(0x05c6, 0x903d, 6)}, 1024 | {QMI_FIXED_INTF(0x05c6, 0x903e, 5)}, 1025 | {QMI_FIXED_INTF(0x05c6, 0x9043, 3)}, 1026 | {QMI_FIXED_INTF(0x05c6, 0x9046, 3)}, 1027 | {QMI_FIXED_INTF(0x05c6, 0x9046, 4)}, 1028 | {QMI_FIXED_INTF(0x05c6, 0x9046, 5)}, 1029 | {QMI_FIXED_INTF(0x05c6, 0x9047, 2)}, 1030 | {QMI_FIXED_INTF(0x05c6, 0x9047, 3)}, 1031 | {QMI_FIXED_INTF(0x05c6, 0x9047, 4)}, 1032 | {QMI_FIXED_INTF(0x05c6, 0x9048, 4)}, 1033 | {QMI_FIXED_INTF(0x05c6, 0x9048, 5)}, 1034 | {QMI_FIXED_INTF(0x05c6, 0x9048, 6)}, 1035 | {QMI_FIXED_INTF(0x05c6, 0x9048, 7)}, 1036 | {QMI_FIXED_INTF(0x05c6, 0x9048, 8)}, 1037 | {QMI_FIXED_INTF(0x05c6, 0x904c, 5)}, 1038 | {QMI_FIXED_INTF(0x05c6, 0x904c, 6)}, 1039 | {QMI_FIXED_INTF(0x05c6, 0x904c, 7)}, 1040 | {QMI_FIXED_INTF(0x05c6, 0x904c, 8)}, 1041 | {QMI_FIXED_INTF(0x05c6, 0x9050, 3)}, 1042 | {QMI_FIXED_INTF(0x05c6, 0x9052, 4)}, 1043 | {QMI_FIXED_INTF(0x05c6, 0x9053, 6)}, 1044 | {QMI_FIXED_INTF(0x05c6, 0x9053, 7)}, 1045 | {QMI_FIXED_INTF(0x05c6, 0x9054, 5)}, 1046 | {QMI_FIXED_INTF(0x05c6, 0x9054, 6)}, 1047 | {QMI_FIXED_INTF(0x05c6, 0x9055, 3)}, 1048 | {QMI_FIXED_INTF(0x05c6, 0x9055, 4)}, 1049 | {QMI_FIXED_INTF(0x05c6, 0x9055, 5)}, 1050 | {QMI_FIXED_INTF(0x05c6, 0x9055, 6)}, 1051 | {QMI_FIXED_INTF(0x05c6, 0x9055, 7)}, 1052 | {QMI_FIXED_INTF(0x05c6, 0x9056, 3)}, 1053 | {QMI_FIXED_INTF(0x05c6, 0x9062, 2)}, 1054 | {QMI_FIXED_INTF(0x05c6, 0x9062, 3)}, 1055 | {QMI_FIXED_INTF(0x05c6, 0x9062, 4)}, 1056 | {QMI_FIXED_INTF(0x05c6, 0x9062, 5)}, 1057 | {QMI_FIXED_INTF(0x05c6, 0x9062, 6)}, 1058 | {QMI_FIXED_INTF(0x05c6, 0x9062, 7)}, 1059 | {QMI_FIXED_INTF(0x05c6, 0x9062, 8)}, 1060 | {QMI_FIXED_INTF(0x05c6, 0x9062, 9)}, 1061 | {QMI_FIXED_INTF(0x05c6, 0x9064, 3)}, 1062 | {QMI_FIXED_INTF(0x05c6, 0x9065, 6)}, 1063 | {QMI_FIXED_INTF(0x05c6, 0x9065, 7)}, 1064 | {QMI_FIXED_INTF(0x05c6, 0x9066, 5)}, 1065 | {QMI_FIXED_INTF(0x05c6, 0x9066, 6)}, 1066 | {QMI_FIXED_INTF(0x05c6, 0x9067, 1)}, 1067 | {QMI_FIXED_INTF(0x05c6, 0x9068, 2)}, 1068 | {QMI_FIXED_INTF(0x05c6, 0x9068, 3)}, 1069 | {QMI_FIXED_INTF(0x05c6, 0x9068, 4)}, 1070 | {QMI_FIXED_INTF(0x05c6, 0x9068, 5)}, 1071 | {QMI_FIXED_INTF(0x05c6, 0x9068, 6)}, 1072 | {QMI_FIXED_INTF(0x05c6, 0x9068, 7)}, 1073 | {QMI_FIXED_INTF(0x05c6, 0x9069, 5)}, 1074 | {QMI_FIXED_INTF(0x05c6, 0x9069, 6)}, 1075 | {QMI_FIXED_INTF(0x05c6, 0x9069, 7)}, 1076 | {QMI_FIXED_INTF(0x05c6, 0x9069, 8)}, 1077 | {QMI_FIXED_INTF(0x05c6, 0x9070, 4)}, 1078 | {QMI_FIXED_INTF(0x05c6, 0x9070, 5)}, 1079 | {QMI_FIXED_INTF(0x05c6, 0x9075, 5)}, 1080 | {QMI_FIXED_INTF(0x05c6, 0x9076, 4)}, 1081 | {QMI_FIXED_INTF(0x05c6, 0x9076, 5)}, 1082 | {QMI_FIXED_INTF(0x05c6, 0x9076, 6)}, 1083 | {QMI_FIXED_INTF(0x05c6, 0x9076, 7)}, 1084 | {QMI_FIXED_INTF(0x05c6, 0x9076, 8)}, 1085 | {QMI_FIXED_INTF(0x05c6, 0x9077, 3)}, 1086 | {QMI_FIXED_INTF(0x05c6, 0x9077, 4)}, 1087 | {QMI_FIXED_INTF(0x05c6, 0x9077, 5)}, 1088 | {QMI_FIXED_INTF(0x05c6, 0x9077, 6)}, 1089 | {QMI_FIXED_INTF(0x05c6, 0x9078, 3)}, 1090 | {QMI_FIXED_INTF(0x05c6, 0x9079, 4)}, 1091 | {QMI_FIXED_INTF(0x05c6, 0x9079, 5)}, 1092 | {QMI_FIXED_INTF(0x05c6, 0x9079, 6)}, 1093 | {QMI_FIXED_INTF(0x05c6, 0x9079, 7)}, 1094 | {QMI_FIXED_INTF(0x05c6, 0x9079, 8)}, 1095 | {QMI_FIXED_INTF(0x05c6, 0x9080, 5)}, 1096 | {QMI_FIXED_INTF(0x05c6, 0x9080, 6)}, 1097 | {QMI_FIXED_INTF(0x05c6, 0x9080, 7)}, 1098 | {QMI_FIXED_INTF(0x05c6, 0x9080, 8)}, 1099 | {QMI_FIXED_INTF(0x05c6, 0x9083, 3)}, 1100 | {QMI_FIXED_INTF(0x05c6, 0x9084, 4)}, 1101 | {QMI_FIXED_INTF(0x05c6, 0x920d, 0)}, 1102 | {QMI_FIXED_INTF(0x05c6, 0x920d, 5)}, 1103 | {QMI_QUIRK_SET_DTR(0x05c6, 0x9625, 4)}, /* YUGA CLM920-NC5 */ 1104 | {QMI_FIXED_INTF(0x0846, 0x68a2, 8)}, 1105 | {QMI_FIXED_INTF(0x12d1, 0x140c, 1)}, /* Huawei E173 */ 1106 | {QMI_FIXED_INTF(0x12d1, 0x14ac, 1)}, /* Huawei E1820 */ 1107 | {QMI_FIXED_INTF(0x16d8, 0x6003, 0)}, /* CMOTech 6003 */ 1108 | {QMI_FIXED_INTF(0x16d8, 0x6007, 0)}, /* CMOTech CHE-628S */ 1109 | {QMI_FIXED_INTF(0x16d8, 0x6008, 0)}, /* CMOTech CMU-301 */ 1110 | {QMI_FIXED_INTF(0x16d8, 0x6280, 0)}, /* CMOTech CHU-628 */ 1111 | {QMI_FIXED_INTF(0x16d8, 0x7001, 0)}, /* CMOTech CHU-720S */ 1112 | {QMI_FIXED_INTF(0x16d8, 0x7002, 0)}, /* CMOTech 7002 */ 1113 | {QMI_FIXED_INTF(0x16d8, 0x7003, 4)}, /* CMOTech CHU-629K */ 1114 | {QMI_FIXED_INTF(0x16d8, 0x7004, 3)}, /* CMOTech 7004 */ 1115 | {QMI_FIXED_INTF(0x16d8, 0x7006, 5)}, /* CMOTech CGU-629 */ 1116 | {QMI_FIXED_INTF(0x16d8, 0x700a, 4)}, /* CMOTech CHU-629S */ 1117 | {QMI_FIXED_INTF(0x16d8, 0x7211, 0)}, /* CMOTech CHU-720I */ 1118 | {QMI_FIXED_INTF(0x16d8, 0x7212, 0)}, /* CMOTech 7212 */ 1119 | {QMI_FIXED_INTF(0x16d8, 0x7213, 0)}, /* CMOTech 7213 */ 1120 | {QMI_FIXED_INTF(0x16d8, 0x7251, 1)}, /* CMOTech 7251 */ 1121 | {QMI_FIXED_INTF(0x16d8, 0x7252, 1)}, /* CMOTech 7252 */ 1122 | {QMI_FIXED_INTF(0x16d8, 0x7253, 1)}, /* CMOTech 7253 */ 1123 | {QMI_FIXED_INTF(0x19d2, 0x0002, 1)}, 1124 | {QMI_FIXED_INTF(0x19d2, 0x0012, 1)}, 1125 | {QMI_FIXED_INTF(0x19d2, 0x0017, 3)}, 1126 | {QMI_FIXED_INTF(0x19d2, 0x0019, 3)}, /* ONDA MT689DC */ 1127 | {QMI_FIXED_INTF(0x19d2, 0x0021, 4)}, 1128 | {QMI_FIXED_INTF(0x19d2, 0x0025, 1)}, 1129 | {QMI_FIXED_INTF(0x19d2, 0x0031, 4)}, 1130 | {QMI_FIXED_INTF(0x19d2, 0x0042, 4)}, 1131 | {QMI_FIXED_INTF(0x19d2, 0x0049, 5)}, 1132 | {QMI_FIXED_INTF(0x19d2, 0x0052, 4)}, 1133 | {QMI_FIXED_INTF(0x19d2, 0x0055, 1)}, /* ZTE (Vodafone) K3520-Z */ 1134 | {QMI_FIXED_INTF(0x19d2, 0x0058, 4)}, 1135 | {QMI_FIXED_INTF(0x19d2, 0x0063, 4)}, /* ZTE (Vodafone) K3565-Z */ 1136 | {QMI_FIXED_INTF(0x19d2, 0x0104, 4)}, /* ZTE (Vodafone) K4505-Z */ 1137 | {QMI_FIXED_INTF(0x19d2, 0x0113, 5)}, 1138 | {QMI_FIXED_INTF(0x19d2, 0x0118, 5)}, 1139 | {QMI_FIXED_INTF(0x19d2, 0x0121, 5)}, 1140 | {QMI_FIXED_INTF(0x19d2, 0x0123, 4)}, 1141 | {QMI_FIXED_INTF(0x19d2, 0x0124, 5)}, 1142 | {QMI_FIXED_INTF(0x19d2, 0x0125, 6)}, 1143 | {QMI_FIXED_INTF(0x19d2, 0x0126, 5)}, 1144 | {QMI_FIXED_INTF(0x19d2, 0x0130, 1)}, 1145 | {QMI_FIXED_INTF(0x19d2, 0x0133, 3)}, 1146 | {QMI_FIXED_INTF(0x19d2, 0x0141, 5)}, 1147 | {QMI_FIXED_INTF(0x19d2, 0x0157, 5)}, /* ZTE MF683 */ 1148 | {QMI_FIXED_INTF(0x19d2, 0x0158, 3)}, 1149 | {QMI_FIXED_INTF(0x19d2, 0x0167, 4)}, /* ZTE MF820D */ 1150 | {QMI_FIXED_INTF(0x19d2, 0x0168, 4)}, 1151 | {QMI_FIXED_INTF(0x19d2, 0x0176, 3)}, 1152 | {QMI_FIXED_INTF(0x19d2, 0x0178, 3)}, 1153 | {QMI_FIXED_INTF(0x19d2, 0x0191, 4)}, /* ZTE EuFi890 */ 1154 | {QMI_FIXED_INTF(0x19d2, 0x0199, 1)}, /* ZTE MF820S */ 1155 | {QMI_FIXED_INTF(0x19d2, 0x0200, 1)}, 1156 | {QMI_FIXED_INTF(0x19d2, 0x0257, 3)}, /* ZTE MF821 */ 1157 | {QMI_FIXED_INTF(0x19d2, 0x0265, 4)}, /* ONDA MT8205 4G LTE */ 1158 | {QMI_FIXED_INTF(0x19d2, 0x0284, 4)}, /* ZTE MF880 */ 1159 | {QMI_FIXED_INTF(0x19d2, 0x0326, 4)}, /* ZTE MF821D */ 1160 | {QMI_FIXED_INTF(0x19d2, 0x0412, 4)}, /* Telewell TW-LTE 4G */ 1161 | {QMI_FIXED_INTF(0x19d2, 0x1008, 4)}, /* ZTE (Vodafone) K3570-Z */ 1162 | {QMI_FIXED_INTF(0x19d2, 0x1010, 4)}, /* ZTE (Vodafone) K3571-Z */ 1163 | {QMI_FIXED_INTF(0x19d2, 0x1012, 4)}, 1164 | {QMI_FIXED_INTF(0x19d2, 0x1018, 3)}, /* ZTE (Vodafone) K5006-Z */ 1165 | {QMI_FIXED_INTF(0x19d2, 0x1021, 2)}, 1166 | {QMI_FIXED_INTF(0x19d2, 0x1245, 4)}, 1167 | {QMI_FIXED_INTF(0x19d2, 0x1247, 4)}, 1168 | {QMI_FIXED_INTF(0x19d2, 0x1252, 4)}, 1169 | {QMI_FIXED_INTF(0x19d2, 0x1254, 4)}, 1170 | {QMI_FIXED_INTF(0x19d2, 0x1255, 3)}, 1171 | {QMI_FIXED_INTF(0x19d2, 0x1255, 4)}, 1172 | {QMI_FIXED_INTF(0x19d2, 0x1256, 4)}, 1173 | {QMI_FIXED_INTF(0x19d2, 0x1270, 5)}, /* ZTE MF667 */ 1174 | {QMI_FIXED_INTF(0x19d2, 0x1401, 2)}, 1175 | {QMI_FIXED_INTF(0x19d2, 0x1402, 2)}, /* ZTE MF60 */ 1176 | {QMI_FIXED_INTF(0x19d2, 0x1424, 2)}, 1177 | {QMI_FIXED_INTF(0x19d2, 0x1425, 2)}, 1178 | {QMI_FIXED_INTF(0x19d2, 0x1426, 2)}, /* ZTE MF91 */ 1179 | {QMI_FIXED_INTF(0x19d2, 0x1428, 2)}, /* Telewell TW-LTE 4G v2 */ 1180 | {QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */ 1181 | {QMI_FIXED_INTF(0x2001, 0x7e19, 4)}, /* D-Link DWM-221 B1 */ 1182 | {QMI_FIXED_INTF(0x2001, 0x7e35, 4)}, /* D-Link DWM-222 */ 1183 | {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */ 1184 | {QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */ 1185 | {QMI_FIXED_INTF(0x1199, 0x68a2, 8)}, /* Sierra Wireless MC7710 in QMI mode */ 1186 | {QMI_FIXED_INTF(0x1199, 0x68a2, 19)}, /* Sierra Wireless MC7710 in QMI mode */ 1187 | {QMI_FIXED_INTF(0x1199, 0x68c0, 8)}, /* Sierra Wireless MC7304/MC7354 */ 1188 | {QMI_FIXED_INTF(0x1199, 0x68c0, 10)}, /* Sierra Wireless MC7304/MC7354 */ 1189 | {QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */ 1190 | {QMI_FIXED_INTF(0x1199, 0x901f, 8)}, /* Sierra Wireless EM7355 */ 1191 | {QMI_FIXED_INTF(0x1199, 0x9041, 8)}, /* Sierra Wireless MC7305/MC7355 */ 1192 | {QMI_FIXED_INTF(0x1199, 0x9041, 10)}, /* Sierra Wireless MC7305/MC7355 */ 1193 | {QMI_FIXED_INTF(0x1199, 0x9051, 8)}, /* Netgear AirCard 340U */ 1194 | {QMI_FIXED_INTF(0x1199, 0x9053, 8)}, /* Sierra Wireless Modem */ 1195 | {QMI_FIXED_INTF(0x1199, 0x9054, 8)}, /* Sierra Wireless Modem */ 1196 | {QMI_FIXED_INTF(0x1199, 0x9055, 8)}, /* Netgear AirCard 341U */ 1197 | {QMI_FIXED_INTF(0x1199, 0x9056, 8)}, /* Sierra Wireless Modem */ 1198 | {QMI_FIXED_INTF(0x1199, 0x9057, 8)}, 1199 | {QMI_FIXED_INTF(0x1199, 0x9061, 8)}, /* Sierra Wireless Modem */ 1200 | {QMI_FIXED_INTF(0x1199, 0x9063, 8)}, /* Sierra Wireless EM7305 */ 1201 | {QMI_FIXED_INTF(0x1199, 0x9063, 10)}, /* Sierra Wireless EM7305 */ 1202 | {QMI_FIXED_INTF(0x1199, 0x9071, 8)}, /* Sierra Wireless MC74xx */ 1203 | {QMI_FIXED_INTF(0x1199, 0x9071, 10)}, /* Sierra Wireless MC74xx */ 1204 | {QMI_FIXED_INTF(0x1199, 0x9079, 8)}, /* Sierra Wireless EM74xx */ 1205 | {QMI_FIXED_INTF(0x1199, 0x9079, 10)}, /* Sierra Wireless EM74xx */ 1206 | {QMI_FIXED_INTF(0x1199, 0x907b, 8)}, /* Sierra Wireless EM74xx */ 1207 | {QMI_FIXED_INTF(0x1199, 0x907b, 10)}, /* Sierra Wireless EM74xx */ 1208 | {QMI_FIXED_INTF(0x1199, 0x9091, 8)}, /* Sierra Wireless EM7565 */ 1209 | {QMI_FIXED_INTF(0x1bbb, 0x011e, 4)}, /* Telekom Speedstick LTE II (Alcatel One Touch L100V LTE) */ 1210 | {QMI_FIXED_INTF(0x1bbb, 0x0203, 2)}, /* Alcatel L800MA */ 1211 | {QMI_FIXED_INTF(0x2357, 0x0201, 4)}, /* TP-LINK HSUPA Modem MA180 */ 1212 | {QMI_FIXED_INTF(0x2357, 0x9000, 4)}, /* TP-LINK MA260 */ 1213 | {QMI_QUIRK_SET_DTR(0x1bc7, 0x1040, 2)}, /* Telit LE922A */ 1214 | {QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */ 1215 | {QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */ 1216 | {QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */ 1217 | {QMI_QUIRK_SET_DTR(0x1bc7, 0x1201, 2)}, /* Telit LE920, LE920A4 */ 1218 | {QMI_FIXED_INTF(0x1c9e, 0x9801, 3)}, /* Telewell TW-3G HSPA+ */ 1219 | {QMI_FIXED_INTF(0x1c9e, 0x9803, 4)}, /* Telewell TW-3G HSPA+ */ 1220 | {QMI_FIXED_INTF(0x1c9e, 0x9b01, 3)}, /* XS Stick W100-2 from 4G Systems */ 1221 | {QMI_FIXED_INTF(0x0b3c, 0xc000, 4)}, /* Olivetti Olicard 100 */ 1222 | {QMI_FIXED_INTF(0x0b3c, 0xc001, 4)}, /* Olivetti Olicard 120 */ 1223 | {QMI_FIXED_INTF(0x0b3c, 0xc002, 4)}, /* Olivetti Olicard 140 */ 1224 | {QMI_FIXED_INTF(0x0b3c, 0xc004, 6)}, /* Olivetti Olicard 155 */ 1225 | {QMI_FIXED_INTF(0x0b3c, 0xc005, 6)}, /* Olivetti Olicard 200 */ 1226 | {QMI_FIXED_INTF(0x0b3c, 0xc00a, 6)}, /* Olivetti Olicard 160 */ 1227 | {QMI_FIXED_INTF(0x0b3c, 0xc00b, 4)}, /* Olivetti Olicard 500 */ 1228 | {QMI_FIXED_INTF(0x1e2d, 0x0060, 4)}, /* Cinterion PLxx */ 1229 | {QMI_FIXED_INTF(0x1e2d, 0x0053, 4)}, /* Cinterion PHxx,PXxx */ 1230 | {QMI_FIXED_INTF(0x1e2d, 0x0082, 4)}, /* Cinterion PHxx,PXxx (2 RmNet) */ 1231 | {QMI_FIXED_INTF(0x1e2d, 0x0082, 5)}, /* Cinterion PHxx,PXxx (2 RmNet) */ 1232 | {QMI_FIXED_INTF(0x1e2d, 0x0083, 4)}, /* Cinterion PHxx,PXxx (1 RmNet + USB Audio)*/ 1233 | {QMI_FIXED_INTF(0x413c, 0x81a2, 8)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */ 1234 | {QMI_FIXED_INTF(0x413c, 0x81a3, 8)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */ 1235 | {QMI_FIXED_INTF(0x413c, 0x81a4, 8)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */ 1236 | {QMI_FIXED_INTF(0x413c, 0x81a8, 8)}, /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card */ 1237 | {QMI_FIXED_INTF(0x413c, 0x81a9, 8)}, /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */ 1238 | {QMI_FIXED_INTF(0x413c, 0x81b1, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card */ 1239 | {QMI_FIXED_INTF(0x413c, 0x81b3, 8)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */ 1240 | {QMI_FIXED_INTF(0x413c, 0x81b6, 8)}, /* Dell Wireless 5811e */ 1241 | {QMI_FIXED_INTF(0x413c, 0x81b6, 10)}, /* Dell Wireless 5811e */ 1242 | {QMI_FIXED_INTF(0x03f0, 0x4e1d, 8)}, /* HP lt4111 LTE/EV-DO/HSPA+ Gobi 4G Module */ 1243 | {QMI_FIXED_INTF(0x22de, 0x9061, 3)}, /* WeTelecom WPD-600N */ 1244 | {QMI_FIXED_INTF(0x1e0e, 0x9001, 5)}, /* SIMCom 7230E */ 1245 | {QMI_QUIRK_SET_DTR(0x2c7c, 0x0125, 4)}, /* Quectel EC25, EC20 R2.0 Mini PCIe */ 1246 | {QMI_QUIRK_SET_DTR(0x2c7c, 0x0121, 4)}, /* Quectel EC21 Mini PCIe */ 1247 | {QMI_FIXED_INTF(0x2c7c, 0x0296, 4)}, /* Quectel BG96 */ 1248 | 1249 | /* 4. Gobi 1000 devices */ 1250 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */ 1251 | {QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)}, /* HP un2400 Gobi Modem Device */ 1252 | {QMI_GOBI1K_DEVICE(0x04da, 0x250d)}, /* Panasonic Gobi Modem device */ 1253 | {QMI_GOBI1K_DEVICE(0x413c, 0x8172)}, /* Dell Gobi Modem device */ 1254 | {QMI_GOBI1K_DEVICE(0x1410, 0xa001)}, /* Novatel/Verizon USB-1000 */ 1255 | {QMI_GOBI1K_DEVICE(0x1410, 0xa002)}, /* Novatel Gobi Modem device */ 1256 | {QMI_GOBI1K_DEVICE(0x1410, 0xa003)}, /* Novatel Gobi Modem device */ 1257 | {QMI_GOBI1K_DEVICE(0x1410, 0xa004)}, /* Novatel Gobi Modem device */ 1258 | {QMI_GOBI1K_DEVICE(0x1410, 0xa005)}, /* Novatel Gobi Modem device */ 1259 | {QMI_GOBI1K_DEVICE(0x1410, 0xa006)}, /* Novatel Gobi Modem device */ 1260 | {QMI_GOBI1K_DEVICE(0x1410, 0xa007)}, /* Novatel Gobi Modem device */ 1261 | {QMI_GOBI1K_DEVICE(0x0b05, 0x1776)}, /* Asus Gobi Modem device */ 1262 | {QMI_GOBI1K_DEVICE(0x19d2, 0xfff3)}, /* ONDA Gobi Modem device */ 1263 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9001)}, /* Generic Gobi Modem device */ 1264 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9002)}, /* Generic Gobi Modem device */ 1265 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9202)}, /* Generic Gobi Modem device */ 1266 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9203)}, /* Generic Gobi Modem device */ 1267 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9222)}, /* Generic Gobi Modem device */ 1268 | {QMI_GOBI1K_DEVICE(0x05c6, 0x9009)}, /* Generic Gobi Modem device */ 1269 | 1270 | /* 5. Gobi 2000 and 3000 devices */ 1271 | {QMI_GOBI_DEVICE(0x413c, 0x8186)}, /* Dell Gobi 2000 Modem device (N0218, VU936) */ 1272 | {QMI_GOBI_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */ 1273 | {QMI_GOBI_DEVICE(0x05c6, 0x920b)}, /* Generic Gobi 2000 Modem device */ 1274 | {QMI_GOBI_DEVICE(0x05c6, 0x9225)}, /* Sony Gobi 2000 Modem device (N0279, VU730) */ 1275 | {QMI_GOBI_DEVICE(0x05c6, 0x9245)}, /* Samsung Gobi 2000 Modem device (VL176) */ 1276 | {QMI_GOBI_DEVICE(0x03f0, 0x251d)}, /* HP Gobi 2000 Modem device (VP412) */ 1277 | /* {QMI_GOBI_DEVICE(0x05c6, 0x9215)}, /* Acer Gobi 2000 Modem device (VP413) */ 1278 | {QMI_FIXED_INTF(0x05c6, 0x9215, 4)}, /* Quectel EC20 Mini PCIe */ 1279 | {QMI_GOBI_DEVICE(0x05c6, 0x9265)}, /* Asus Gobi 2000 Modem device (VR305) */ 1280 | {QMI_GOBI_DEVICE(0x05c6, 0x9235)}, /* Top Global Gobi 2000 Modem device (VR306) */ 1281 | {QMI_GOBI_DEVICE(0x05c6, 0x9275)}, /* iRex Technologies Gobi 2000 Modem device (VR307) */ 1282 | {QMI_GOBI_DEVICE(0x0af0, 0x8120)}, /* Option GTM681W */ 1283 | {QMI_GOBI_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */ 1284 | {QMI_GOBI_DEVICE(0x1199, 0x68a9)}, /* Sierra Wireless Modem */ 1285 | {QMI_GOBI_DEVICE(0x1199, 0x9001)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1286 | {QMI_GOBI_DEVICE(0x1199, 0x9002)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1287 | {QMI_GOBI_DEVICE(0x1199, 0x9003)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1288 | {QMI_GOBI_DEVICE(0x1199, 0x9004)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1289 | {QMI_GOBI_DEVICE(0x1199, 0x9005)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1290 | {QMI_GOBI_DEVICE(0x1199, 0x9006)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1291 | {QMI_GOBI_DEVICE(0x1199, 0x9007)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1292 | {QMI_GOBI_DEVICE(0x1199, 0x9008)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1293 | {QMI_GOBI_DEVICE(0x1199, 0x9009)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1294 | {QMI_GOBI_DEVICE(0x1199, 0x900a)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 1295 | {QMI_GOBI_DEVICE(0x1199, 0x9011)}, /* Sierra Wireless Gobi 2000 Modem device (MC8305) */ 1296 | {QMI_GOBI_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */ 1297 | {QMI_GOBI_DEVICE(0x05c6, 0x9205)}, /* Gobi 2000 Modem device */ 1298 | {QMI_GOBI_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */ 1299 | {QMI_GOBI_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Mobile Broadband Module */ 1300 | {QMI_GOBI_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */ 1301 | {QMI_GOBI_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */ 1302 | {QMI_GOBI_DEVICE(0x1199, 0x901b)}, /* Sierra Wireless MC7770 */ 1303 | {QMI_GOBI_DEVICE(0x12d1, 0x14f1)}, /* Sony Gobi 3000 Composite */ 1304 | {QMI_GOBI_DEVICE(0x1410, 0xa021)}, /* Foxconn Gobi 3000 Modem device (Novatel E396) */ 1305 | 1306 | { } /* END */ 1307 | }; 1308 | MODULE_DEVICE_TABLE(usb, products); 1309 | 1310 | static bool quectel_ec20_detected(struct usb_interface *intf) 1311 | { 1312 | struct usb_device *dev = interface_to_usbdev(intf); 1313 | 1314 | if (dev->actconfig && 1315 | le16_to_cpu(dev->descriptor.idVendor) == 0x05c6 && 1316 | le16_to_cpu(dev->descriptor.idProduct) == 0x9215 && 1317 | dev->actconfig->desc.bNumInterfaces == 5) 1318 | return true; 1319 | 1320 | return false; 1321 | } 1322 | 1323 | static int qmi_wwan_probe(struct usb_interface *intf, 1324 | const struct usb_device_id *prod) 1325 | { 1326 | struct usb_device_id *id = (struct usb_device_id *)prod; 1327 | struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc; 1328 | 1329 | /* Workaround to enable dynamic IDs. This disables usbnet 1330 | * blacklisting functionality. Which, if required, can be 1331 | * reimplemented here by using a magic "blacklist" value 1332 | * instead of 0 in the static device id table 1333 | */ 1334 | if (!id->driver_info) { 1335 | dev_dbg(&intf->dev, "setting defaults for dynamic device id\n"); 1336 | id->driver_info = (unsigned long)&qmi_wwan_info; 1337 | } 1338 | 1339 | /* Quectel EC20 quirk where we've QMI on interface 4 instead of 0 */ 1340 | if (quectel_ec20_detected(intf) && desc->bInterfaceNumber == 0) { 1341 | dev_dbg(&intf->dev, "Quectel EC20 quirk, skipping interface 0\n"); 1342 | return -ENODEV; 1343 | } 1344 | 1345 | return usbnet_probe(intf, id); 1346 | } 1347 | 1348 | static void qmi_wwan_disconnect(struct usb_interface *intf) 1349 | { 1350 | struct usbnet *dev = usb_get_intfdata(intf); 1351 | struct qmi_wwan_state *info; 1352 | struct list_head *iter; 1353 | struct net_device *ldev; 1354 | 1355 | /* called twice if separate control and data intf */ 1356 | if (!dev) 1357 | return; 1358 | info = (void *)&dev->data; 1359 | if (info->flags & QMI_WWAN_FLAG_MUX) { 1360 | if (!rtnl_trylock()) { 1361 | restart_syscall(); 1362 | return; 1363 | } 1364 | rcu_read_lock(); 1365 | netdev_for_each_upper_dev_rcu(dev->net, ldev, iter) 1366 | qmimux_unregister_device(ldev); 1367 | rcu_read_unlock(); 1368 | rtnl_unlock(); 1369 | info->flags &= ~QMI_WWAN_FLAG_MUX; 1370 | } 1371 | usbnet_disconnect(intf); 1372 | } 1373 | 1374 | static struct usb_driver qmi_wwan_driver = { 1375 | .name = "qmi_wwan", 1376 | .id_table = products, 1377 | .probe = qmi_wwan_probe, 1378 | .disconnect = qmi_wwan_disconnect, 1379 | .suspend = qmi_wwan_suspend, 1380 | .resume = qmi_wwan_resume, 1381 | .reset_resume = qmi_wwan_resume, 1382 | .supports_autosuspend = 1, 1383 | .disable_hub_initiated_lpm = 1, 1384 | }; 1385 | 1386 | module_usb_driver(qmi_wwan_driver); 1387 | 1388 | MODULE_AUTHOR("Bjørn Mork "); 1389 | MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver"); 1390 | MODULE_LICENSE("GPL"); 1391 | -------------------------------------------------------------------------------- /drivers/net/usb/usbnet.c: -------------------------------------------------------------------------------- 1 | /* 2 | * USB Network driver infrastructure 3 | * Copyright (C) 2000-2005 by David Brownell 4 | * Copyright (C) 2003-2005 David Hollis 5 | * 6 | * This program is free software; you can redistribute it and/or modify 7 | * it under the terms of the GNU General Public License as published by 8 | * the Free Software Foundation; either version 2 of the License, or 9 | * (at your option) any later version. 10 | * 11 | * This program is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | * GNU General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU General Public License 17 | * along with this program; if not, see . 18 | */ 19 | 20 | /* 21 | * This is a generic "USB networking" framework that works with several 22 | * kinds of full and high speed networking devices: host-to-host cables, 23 | * smart usb peripherals, and actual Ethernet adapters. 24 | * 25 | * These devices usually differ in terms of control protocols (if they 26 | * even have one!) and sometimes they define new framing to wrap or batch 27 | * Ethernet packets. Otherwise, they talk to USB pretty much the same, 28 | * so interface (un)binding, endpoint I/O queues, fault handling, and other 29 | * issues can usefully be addressed by this framework. 30 | */ 31 | 32 | // #define DEBUG // error path messages, extra info 33 | // #define VERBOSE // more; success messages 34 | 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | #include 46 | #include 47 | #include 48 | 49 | #define DRIVER_VERSION "22-Aug-2005" 50 | 51 | 52 | /*-------------------------------------------------------------------------*/ 53 | 54 | /* 55 | * Nineteen USB 1.1 max size bulk transactions per frame (ms), max. 56 | * Several dozen bytes of IPv4 data can fit in two such transactions. 57 | * One maximum size Ethernet packet takes twenty four of them. 58 | * For high speed, each frame comfortably fits almost 36 max size 59 | * Ethernet packets (so queues should be bigger). 60 | * 61 | * The goal is to let the USB host controller be busy for 5msec or 62 | * more before an irq is required, under load. Jumbograms change 63 | * the equation. 64 | */ 65 | #define MAX_QUEUE_MEMORY (60 * 1518) 66 | #define RX_QLEN(dev) ((dev)->rx_qlen) 67 | #define TX_QLEN(dev) ((dev)->tx_qlen) 68 | 69 | // reawaken network queue this soon after stopping; else watchdog barks 70 | #define TX_TIMEOUT_JIFFIES (5*HZ) 71 | 72 | /* throttle rx/tx briefly after some faults, so hub_wq might disconnect() 73 | * us (it polls at HZ/4 usually) before we report too many false errors. 74 | */ 75 | #define THROTTLE_JIFFIES (HZ/8) 76 | 77 | // between wakeups 78 | #define UNLINK_TIMEOUT_MS 3 79 | 80 | /*-------------------------------------------------------------------------*/ 81 | 82 | // randomly generated ethernet address 83 | static u8 node_id [ETH_ALEN]; 84 | 85 | /* use ethtool to change the level for any given device */ 86 | static int msg_level = -1; 87 | module_param (msg_level, int, 0); 88 | MODULE_PARM_DESC (msg_level, "Override default message level"); 89 | 90 | /*-------------------------------------------------------------------------*/ 91 | 92 | /* handles CDC Ethernet and many other network "bulk data" interfaces */ 93 | int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf) 94 | { 95 | int tmp; 96 | struct usb_host_interface *alt = NULL; 97 | struct usb_host_endpoint *in = NULL, *out = NULL; 98 | struct usb_host_endpoint *status = NULL; 99 | 100 | for (tmp = 0; tmp < intf->num_altsetting; tmp++) { 101 | unsigned ep; 102 | 103 | in = out = status = NULL; 104 | alt = intf->altsetting + tmp; 105 | 106 | /* take the first altsetting with in-bulk + out-bulk; 107 | * remember any status endpoint, just in case; 108 | * ignore other endpoints and altsettings. 109 | */ 110 | for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) { 111 | struct usb_host_endpoint *e; 112 | int intr = 0; 113 | 114 | e = alt->endpoint + ep; 115 | switch (e->desc.bmAttributes) { 116 | case USB_ENDPOINT_XFER_INT: 117 | if (!usb_endpoint_dir_in(&e->desc)) 118 | continue; 119 | intr = 1; 120 | /* FALLTHROUGH */ 121 | case USB_ENDPOINT_XFER_BULK: 122 | break; 123 | default: 124 | continue; 125 | } 126 | if (usb_endpoint_dir_in(&e->desc)) { 127 | if (!intr && !in) 128 | in = e; 129 | else if (intr && !status) 130 | status = e; 131 | } else { 132 | if (!out) 133 | out = e; 134 | } 135 | } 136 | if (in && out) 137 | break; 138 | } 139 | if (!alt || !in || !out) 140 | return -EINVAL; 141 | 142 | if (alt->desc.bAlternateSetting != 0 || 143 | !(dev->driver_info->flags & FLAG_NO_SETINT)) { 144 | tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber, 145 | alt->desc.bAlternateSetting); 146 | if (tmp < 0) 147 | return tmp; 148 | } 149 | 150 | dev->in = usb_rcvbulkpipe (dev->udev, 151 | in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 152 | dev->out = usb_sndbulkpipe (dev->udev, 153 | out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 154 | dev->status = status; 155 | return 0; 156 | } 157 | EXPORT_SYMBOL_GPL(usbnet_get_endpoints); 158 | 159 | int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress) 160 | { 161 | int tmp = -1, ret; 162 | unsigned char buf [13]; 163 | 164 | ret = usb_string(dev->udev, iMACAddress, buf, sizeof buf); 165 | if (ret == 12) 166 | tmp = hex2bin(dev->net->dev_addr, buf, 6); 167 | if (tmp < 0) { 168 | dev_dbg(&dev->udev->dev, 169 | "bad MAC string %d fetch, %d\n", iMACAddress, tmp); 170 | if (ret >= 0) 171 | ret = -EINVAL; 172 | return ret; 173 | } 174 | return 0; 175 | } 176 | EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr); 177 | 178 | static void intr_complete (struct urb *urb) 179 | { 180 | struct usbnet *dev = urb->context; 181 | int status = urb->status; 182 | 183 | switch (status) { 184 | /* success */ 185 | case 0: 186 | dev->driver_info->status(dev, urb); 187 | break; 188 | 189 | /* software-driven interface shutdown */ 190 | case -ENOENT: /* urb killed */ 191 | case -ESHUTDOWN: /* hardware gone */ 192 | netif_dbg(dev, ifdown, dev->net, 193 | "intr shutdown, code %d\n", status); 194 | return; 195 | 196 | /* NOTE: not throttling like RX/TX, since this endpoint 197 | * already polls infrequently 198 | */ 199 | default: 200 | netdev_dbg(dev->net, "intr status %d\n", status); 201 | break; 202 | } 203 | 204 | status = usb_submit_urb (urb, GFP_ATOMIC); 205 | if (status != 0) 206 | netif_err(dev, timer, dev->net, 207 | "intr resubmit --> %d\n", status); 208 | } 209 | 210 | static int init_status (struct usbnet *dev, struct usb_interface *intf) 211 | { 212 | char *buf = NULL; 213 | unsigned pipe = 0; 214 | unsigned maxp; 215 | unsigned period; 216 | 217 | if (!dev->driver_info->status) 218 | return 0; 219 | 220 | pipe = usb_rcvintpipe (dev->udev, 221 | dev->status->desc.bEndpointAddress 222 | & USB_ENDPOINT_NUMBER_MASK); 223 | maxp = usb_maxpacket (dev->udev, pipe, 0); 224 | 225 | /* avoid 1 msec chatter: min 8 msec poll rate */ 226 | period = max ((int) dev->status->desc.bInterval, 227 | (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3); 228 | 229 | buf = kmalloc (maxp, GFP_KERNEL); 230 | if (buf) { 231 | dev->interrupt = usb_alloc_urb (0, GFP_KERNEL); 232 | if (!dev->interrupt) { 233 | kfree (buf); 234 | return -ENOMEM; 235 | } else { 236 | usb_fill_int_urb(dev->interrupt, dev->udev, pipe, 237 | buf, maxp, intr_complete, dev, period); 238 | dev->interrupt->transfer_flags |= URB_FREE_BUFFER; 239 | dev_dbg(&intf->dev, 240 | "status ep%din, %d bytes period %d\n", 241 | usb_pipeendpoint(pipe), maxp, period); 242 | } 243 | } 244 | return 0; 245 | } 246 | 247 | /* Submit the interrupt URB if not previously submitted, increasing refcount */ 248 | int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags) 249 | { 250 | int ret = 0; 251 | 252 | WARN_ON_ONCE(dev->interrupt == NULL); 253 | if (dev->interrupt) { 254 | mutex_lock(&dev->interrupt_mutex); 255 | 256 | if (++dev->interrupt_count == 1) 257 | ret = usb_submit_urb(dev->interrupt, mem_flags); 258 | 259 | dev_dbg(&dev->udev->dev, "incremented interrupt URB count to %d\n", 260 | dev->interrupt_count); 261 | mutex_unlock(&dev->interrupt_mutex); 262 | } 263 | return ret; 264 | } 265 | EXPORT_SYMBOL_GPL(usbnet_status_start); 266 | 267 | /* For resume; submit interrupt URB if previously submitted */ 268 | static int __usbnet_status_start_force(struct usbnet *dev, gfp_t mem_flags) 269 | { 270 | int ret = 0; 271 | 272 | mutex_lock(&dev->interrupt_mutex); 273 | if (dev->interrupt_count) { 274 | ret = usb_submit_urb(dev->interrupt, mem_flags); 275 | dev_dbg(&dev->udev->dev, 276 | "submitted interrupt URB for resume\n"); 277 | } 278 | mutex_unlock(&dev->interrupt_mutex); 279 | return ret; 280 | } 281 | 282 | /* Kill the interrupt URB if all submitters want it killed */ 283 | void usbnet_status_stop(struct usbnet *dev) 284 | { 285 | if (dev->interrupt) { 286 | mutex_lock(&dev->interrupt_mutex); 287 | WARN_ON(dev->interrupt_count == 0); 288 | 289 | if (dev->interrupt_count && --dev->interrupt_count == 0) 290 | usb_kill_urb(dev->interrupt); 291 | 292 | dev_dbg(&dev->udev->dev, 293 | "decremented interrupt URB count to %d\n", 294 | dev->interrupt_count); 295 | mutex_unlock(&dev->interrupt_mutex); 296 | } 297 | } 298 | EXPORT_SYMBOL_GPL(usbnet_status_stop); 299 | 300 | /* For suspend; always kill interrupt URB */ 301 | static void __usbnet_status_stop_force(struct usbnet *dev) 302 | { 303 | if (dev->interrupt) { 304 | mutex_lock(&dev->interrupt_mutex); 305 | usb_kill_urb(dev->interrupt); 306 | dev_dbg(&dev->udev->dev, "killed interrupt URB for suspend\n"); 307 | mutex_unlock(&dev->interrupt_mutex); 308 | } 309 | } 310 | 311 | /* Passes this packet up the stack, updating its accounting. 312 | * Some link protocols batch packets, so their rx_fixup paths 313 | * can return clones as well as just modify the original skb. 314 | */ 315 | void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb) 316 | { 317 | struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64); 318 | int status; 319 | 320 | if (test_bit(EVENT_RX_PAUSED, &dev->flags)) { 321 | skb_queue_tail(&dev->rxq_pause, skb); 322 | return; 323 | } 324 | 325 | /* only update if unset to allow minidriver rx_fixup override */ 326 | if (skb->protocol == 0) 327 | skb->protocol = eth_type_trans (skb, dev->net); 328 | 329 | u64_stats_update_begin(&stats64->syncp); 330 | stats64->rx_packets++; 331 | stats64->rx_bytes += skb->len; 332 | u64_stats_update_end(&stats64->syncp); 333 | 334 | netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n", 335 | skb->len + sizeof (struct ethhdr), skb->protocol); 336 | memset (skb->cb, 0, sizeof (struct skb_data)); 337 | 338 | if (skb_defer_rx_timestamp(skb)) 339 | return; 340 | 341 | status = netif_rx (skb); 342 | if (status != NET_RX_SUCCESS) 343 | netif_dbg(dev, rx_err, dev->net, 344 | "netif_rx status %d\n", status); 345 | } 346 | EXPORT_SYMBOL_GPL(usbnet_skb_return); 347 | 348 | /* must be called if hard_mtu or rx_urb_size changed */ 349 | void usbnet_update_max_qlen(struct usbnet *dev) 350 | { 351 | enum usb_device_speed speed = dev->udev->speed; 352 | 353 | switch (speed) { 354 | case USB_SPEED_HIGH: 355 | dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size; 356 | dev->tx_qlen = MAX_QUEUE_MEMORY / dev->hard_mtu; 357 | break; 358 | case USB_SPEED_SUPER: 359 | case USB_SPEED_SUPER_PLUS: 360 | /* 361 | * Not take default 5ms qlen for super speed HC to 362 | * save memory, and iperf tests show 2.5ms qlen can 363 | * work well 364 | */ 365 | dev->rx_qlen = 5 * MAX_QUEUE_MEMORY / dev->rx_urb_size; 366 | dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu; 367 | break; 368 | default: 369 | dev->rx_qlen = dev->tx_qlen = 4; 370 | } 371 | } 372 | EXPORT_SYMBOL_GPL(usbnet_update_max_qlen); 373 | 374 | 375 | /*------------------------------------------------------------------------- 376 | * 377 | * Network Device Driver (peer link to "Host Device", from USB host) 378 | * 379 | *-------------------------------------------------------------------------*/ 380 | 381 | int usbnet_change_mtu (struct net_device *net, int new_mtu) 382 | { 383 | struct usbnet *dev = netdev_priv(net); 384 | int ll_mtu = new_mtu + net->hard_header_len; 385 | int old_hard_mtu = dev->hard_mtu; 386 | int old_rx_urb_size = dev->rx_urb_size; 387 | 388 | // no second zero-length packet read wanted after mtu-sized packets 389 | if ((ll_mtu % dev->maxpacket) == 0) 390 | return -EDOM; 391 | net->mtu = new_mtu; 392 | 393 | dev->hard_mtu = net->mtu + net->hard_header_len; 394 | if (dev->rx_urb_size == old_hard_mtu) { 395 | dev->rx_urb_size = dev->hard_mtu; 396 | if (dev->rx_urb_size > old_rx_urb_size) { 397 | usbnet_pause_rx(dev); 398 | usbnet_unlink_rx_urbs(dev); 399 | usbnet_resume_rx(dev); 400 | } 401 | } 402 | 403 | /* max qlen depend on hard_mtu and rx_urb_size */ 404 | usbnet_update_max_qlen(dev); 405 | 406 | return 0; 407 | } 408 | EXPORT_SYMBOL_GPL(usbnet_change_mtu); 409 | 410 | /* The caller must hold list->lock */ 411 | static void __usbnet_queue_skb(struct sk_buff_head *list, 412 | struct sk_buff *newsk, enum skb_state state) 413 | { 414 | struct skb_data *entry = (struct skb_data *) newsk->cb; 415 | 416 | __skb_queue_tail(list, newsk); 417 | entry->state = state; 418 | } 419 | 420 | /*-------------------------------------------------------------------------*/ 421 | 422 | /* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from 423 | * completion callbacks. 2.5 should have fixed those bugs... 424 | */ 425 | 426 | static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb, 427 | struct sk_buff_head *list, enum skb_state state) 428 | { 429 | unsigned long flags; 430 | enum skb_state old_state; 431 | struct skb_data *entry = (struct skb_data *) skb->cb; 432 | 433 | spin_lock_irqsave(&list->lock, flags); 434 | old_state = entry->state; 435 | entry->state = state; 436 | __skb_unlink(skb, list); 437 | 438 | /* defer_bh() is never called with list == &dev->done. 439 | * spin_lock_nested() tells lockdep that it is OK to take 440 | * dev->done.lock here with list->lock held. 441 | */ 442 | spin_lock_nested(&dev->done.lock, SINGLE_DEPTH_NESTING); 443 | 444 | __skb_queue_tail(&dev->done, skb); 445 | if (dev->done.qlen == 1) 446 | tasklet_schedule(&dev->bh); 447 | spin_unlock(&dev->done.lock); 448 | spin_unlock_irqrestore(&list->lock, flags); 449 | return old_state; 450 | } 451 | 452 | /* some work can't be done in tasklets, so we use keventd 453 | * 454 | * NOTE: annoying asymmetry: if it's active, schedule_work() fails, 455 | * but tasklet_schedule() doesn't. hope the failure is rare. 456 | */ 457 | void usbnet_defer_kevent (struct usbnet *dev, int work) 458 | { 459 | set_bit (work, &dev->flags); 460 | if (!schedule_work (&dev->kevent)) 461 | netdev_dbg(dev->net, "kevent %d may have been dropped\n", work); 462 | else 463 | netdev_dbg(dev->net, "kevent %d scheduled\n", work); 464 | } 465 | EXPORT_SYMBOL_GPL(usbnet_defer_kevent); 466 | 467 | /*-------------------------------------------------------------------------*/ 468 | 469 | static void rx_complete (struct urb *urb); 470 | 471 | static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags) 472 | { 473 | struct sk_buff *skb; 474 | struct skb_data *entry; 475 | int retval = 0; 476 | unsigned long lockflags; 477 | size_t size = dev->rx_urb_size; 478 | 479 | /* prevent rx skb allocation when error ratio is high */ 480 | if (test_bit(EVENT_RX_KILL, &dev->flags)) { 481 | usb_free_urb(urb); 482 | return -ENOLINK; 483 | } 484 | 485 | if (test_bit(EVENT_NO_IP_ALIGN, &dev->flags)) 486 | skb = __netdev_alloc_skb(dev->net, size, flags); 487 | else 488 | skb = __netdev_alloc_skb_ip_align(dev->net, size, flags); 489 | if (!skb) { 490 | netif_dbg(dev, rx_err, dev->net, "no rx skb\n"); 491 | usbnet_defer_kevent (dev, EVENT_RX_MEMORY); 492 | usb_free_urb (urb); 493 | return -ENOMEM; 494 | } 495 | 496 | entry = (struct skb_data *) skb->cb; 497 | entry->urb = urb; 498 | entry->dev = dev; 499 | entry->length = 0; 500 | 501 | usb_fill_bulk_urb (urb, dev->udev, dev->in, 502 | skb->data, size, rx_complete, skb); 503 | 504 | spin_lock_irqsave (&dev->rxq.lock, lockflags); 505 | 506 | if (netif_running (dev->net) && 507 | netif_device_present (dev->net) && 508 | !test_bit (EVENT_RX_HALT, &dev->flags) && 509 | !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) { 510 | switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) { 511 | case -EPIPE: 512 | usbnet_defer_kevent (dev, EVENT_RX_HALT); 513 | break; 514 | case -ENOMEM: 515 | usbnet_defer_kevent (dev, EVENT_RX_MEMORY); 516 | break; 517 | case -ENODEV: 518 | netif_dbg(dev, ifdown, dev->net, "device gone\n"); 519 | netif_device_detach (dev->net); 520 | break; 521 | case -EHOSTUNREACH: 522 | retval = -ENOLINK; 523 | break; 524 | default: 525 | netif_dbg(dev, rx_err, dev->net, 526 | "rx submit, %d\n", retval); 527 | tasklet_schedule (&dev->bh); 528 | break; 529 | case 0: 530 | __usbnet_queue_skb(&dev->rxq, skb, rx_start); 531 | } 532 | } else { 533 | netif_dbg(dev, ifdown, dev->net, "rx: stopped\n"); 534 | retval = -ENOLINK; 535 | } 536 | spin_unlock_irqrestore (&dev->rxq.lock, lockflags); 537 | if (retval) { 538 | dev_kfree_skb_any (skb); 539 | usb_free_urb (urb); 540 | } 541 | return retval; 542 | } 543 | 544 | 545 | /*-------------------------------------------------------------------------*/ 546 | 547 | static inline void rx_process (struct usbnet *dev, struct sk_buff *skb) 548 | { 549 | if (dev->driver_info->rx_fixup && 550 | !dev->driver_info->rx_fixup (dev, skb)) { 551 | /* With RX_ASSEMBLE, rx_fixup() must update counters */ 552 | if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE)) 553 | dev->net->stats.rx_errors++; 554 | goto done; 555 | } 556 | // else network stack removes extra byte if we forced a short packet 557 | 558 | /* all data was already cloned from skb inside the driver */ 559 | if (dev->driver_info->flags & FLAG_MULTI_PACKET) 560 | goto done; 561 | 562 | if (skb->len < ETH_HLEN) { 563 | dev->net->stats.rx_errors++; 564 | dev->net->stats.rx_length_errors++; 565 | netif_dbg(dev, rx_err, dev->net, "rx length %d\n", skb->len); 566 | } else { 567 | usbnet_skb_return(dev, skb); 568 | return; 569 | } 570 | 571 | done: 572 | skb_queue_tail(&dev->done, skb); 573 | } 574 | 575 | /*-------------------------------------------------------------------------*/ 576 | 577 | static void rx_complete (struct urb *urb) 578 | { 579 | struct sk_buff *skb = (struct sk_buff *) urb->context; 580 | struct skb_data *entry = (struct skb_data *) skb->cb; 581 | struct usbnet *dev = entry->dev; 582 | int urb_status = urb->status; 583 | enum skb_state state; 584 | 585 | skb_put (skb, urb->actual_length); 586 | state = rx_done; 587 | entry->urb = NULL; 588 | 589 | switch (urb_status) { 590 | /* success */ 591 | case 0: 592 | break; 593 | 594 | /* stalls need manual reset. this is rare ... except that 595 | * when going through USB 2.0 TTs, unplug appears this way. 596 | * we avoid the highspeed version of the ETIMEDOUT/EILSEQ 597 | * storm, recovering as needed. 598 | */ 599 | case -EPIPE: 600 | dev->net->stats.rx_errors++; 601 | usbnet_defer_kevent (dev, EVENT_RX_HALT); 602 | // FALLTHROUGH 603 | 604 | /* software-driven interface shutdown */ 605 | case -ECONNRESET: /* async unlink */ 606 | case -ESHUTDOWN: /* hardware gone */ 607 | netif_dbg(dev, ifdown, dev->net, 608 | "rx shutdown, code %d\n", urb_status); 609 | goto block; 610 | 611 | /* we get controller i/o faults during hub_wq disconnect() delays. 612 | * throttle down resubmits, to avoid log floods; just temporarily, 613 | * so we still recover when the fault isn't a hub_wq delay. 614 | */ 615 | case -EPROTO: 616 | case -ETIME: 617 | case -EILSEQ: 618 | dev->net->stats.rx_errors++; 619 | if (!timer_pending (&dev->delay)) { 620 | mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES); 621 | netif_dbg(dev, link, dev->net, 622 | "rx throttle %d\n", urb_status); 623 | } 624 | block: 625 | state = rx_cleanup; 626 | entry->urb = urb; 627 | urb = NULL; 628 | break; 629 | 630 | /* data overrun ... flush fifo? */ 631 | case -EOVERFLOW: 632 | dev->net->stats.rx_over_errors++; 633 | // FALLTHROUGH 634 | 635 | default: 636 | state = rx_cleanup; 637 | dev->net->stats.rx_errors++; 638 | netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status); 639 | break; 640 | } 641 | 642 | /* stop rx if packet error rate is high */ 643 | if (++dev->pkt_cnt > 30) { 644 | dev->pkt_cnt = 0; 645 | dev->pkt_err = 0; 646 | } else { 647 | if (state == rx_cleanup) 648 | dev->pkt_err++; 649 | if (dev->pkt_err > 20) 650 | set_bit(EVENT_RX_KILL, &dev->flags); 651 | } 652 | 653 | state = defer_bh(dev, skb, &dev->rxq, state); 654 | 655 | if (urb) { 656 | if (netif_running (dev->net) && 657 | !test_bit (EVENT_RX_HALT, &dev->flags) && 658 | state != unlink_start) { 659 | rx_submit (dev, urb, GFP_ATOMIC); 660 | usb_mark_last_busy(dev->udev); 661 | return; 662 | } 663 | usb_free_urb (urb); 664 | } 665 | netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n"); 666 | } 667 | 668 | /*-------------------------------------------------------------------------*/ 669 | void usbnet_pause_rx(struct usbnet *dev) 670 | { 671 | set_bit(EVENT_RX_PAUSED, &dev->flags); 672 | 673 | netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n"); 674 | } 675 | EXPORT_SYMBOL_GPL(usbnet_pause_rx); 676 | 677 | void usbnet_resume_rx(struct usbnet *dev) 678 | { 679 | struct sk_buff *skb; 680 | int num = 0; 681 | 682 | clear_bit(EVENT_RX_PAUSED, &dev->flags); 683 | 684 | while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) { 685 | usbnet_skb_return(dev, skb); 686 | num++; 687 | } 688 | 689 | tasklet_schedule(&dev->bh); 690 | 691 | netif_dbg(dev, rx_status, dev->net, 692 | "paused rx queue disabled, %d skbs requeued\n", num); 693 | } 694 | EXPORT_SYMBOL_GPL(usbnet_resume_rx); 695 | 696 | void usbnet_purge_paused_rxq(struct usbnet *dev) 697 | { 698 | skb_queue_purge(&dev->rxq_pause); 699 | } 700 | EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq); 701 | 702 | /*-------------------------------------------------------------------------*/ 703 | 704 | // unlink pending rx/tx; completion handlers do all other cleanup 705 | 706 | static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q) 707 | { 708 | unsigned long flags; 709 | struct sk_buff *skb; 710 | int count = 0; 711 | 712 | spin_lock_irqsave (&q->lock, flags); 713 | while (!skb_queue_empty(q)) { 714 | struct skb_data *entry; 715 | struct urb *urb; 716 | int retval; 717 | 718 | skb_queue_walk(q, skb) { 719 | entry = (struct skb_data *) skb->cb; 720 | if (entry->state != unlink_start) 721 | goto found; 722 | } 723 | break; 724 | found: 725 | entry->state = unlink_start; 726 | urb = entry->urb; 727 | 728 | /* 729 | * Get reference count of the URB to avoid it to be 730 | * freed during usb_unlink_urb, which may trigger 731 | * use-after-free problem inside usb_unlink_urb since 732 | * usb_unlink_urb is always racing with .complete 733 | * handler(include defer_bh). 734 | */ 735 | usb_get_urb(urb); 736 | spin_unlock_irqrestore(&q->lock, flags); 737 | // during some PM-driven resume scenarios, 738 | // these (async) unlinks complete immediately 739 | retval = usb_unlink_urb (urb); 740 | if (retval != -EINPROGRESS && retval != 0) 741 | netdev_dbg(dev->net, "unlink urb err, %d\n", retval); 742 | else 743 | count++; 744 | usb_put_urb(urb); 745 | spin_lock_irqsave(&q->lock, flags); 746 | } 747 | spin_unlock_irqrestore (&q->lock, flags); 748 | return count; 749 | } 750 | 751 | // Flush all pending rx urbs 752 | // minidrivers may need to do this when the MTU changes 753 | 754 | void usbnet_unlink_rx_urbs(struct usbnet *dev) 755 | { 756 | if (netif_running(dev->net)) { 757 | (void) unlink_urbs (dev, &dev->rxq); 758 | tasklet_schedule(&dev->bh); 759 | } 760 | } 761 | EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs); 762 | 763 | /*-------------------------------------------------------------------------*/ 764 | 765 | static void wait_skb_queue_empty(struct sk_buff_head *q) 766 | { 767 | unsigned long flags; 768 | 769 | spin_lock_irqsave(&q->lock, flags); 770 | while (!skb_queue_empty(q)) { 771 | spin_unlock_irqrestore(&q->lock, flags); 772 | schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS)); 773 | set_current_state(TASK_UNINTERRUPTIBLE); 774 | spin_lock_irqsave(&q->lock, flags); 775 | } 776 | spin_unlock_irqrestore(&q->lock, flags); 777 | } 778 | 779 | // precondition: never called in_interrupt 780 | static void usbnet_terminate_urbs(struct usbnet *dev) 781 | { 782 | DECLARE_WAITQUEUE(wait, current); 783 | int temp; 784 | 785 | /* ensure there are no more active urbs */ 786 | add_wait_queue(&dev->wait, &wait); 787 | set_current_state(TASK_UNINTERRUPTIBLE); 788 | temp = unlink_urbs(dev, &dev->txq) + 789 | unlink_urbs(dev, &dev->rxq); 790 | 791 | /* maybe wait for deletions to finish. */ 792 | wait_skb_queue_empty(&dev->rxq); 793 | wait_skb_queue_empty(&dev->txq); 794 | wait_skb_queue_empty(&dev->done); 795 | netif_dbg(dev, ifdown, dev->net, 796 | "waited for %d urb completions\n", temp); 797 | set_current_state(TASK_RUNNING); 798 | remove_wait_queue(&dev->wait, &wait); 799 | } 800 | 801 | int usbnet_stop (struct net_device *net) 802 | { 803 | struct usbnet *dev = netdev_priv(net); 804 | struct driver_info *info = dev->driver_info; 805 | int retval, pm, mpn; 806 | 807 | clear_bit(EVENT_DEV_OPEN, &dev->flags); 808 | netif_stop_queue (net); 809 | 810 | netif_info(dev, ifdown, dev->net, 811 | "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n", 812 | net->stats.rx_packets, net->stats.tx_packets, 813 | net->stats.rx_errors, net->stats.tx_errors); 814 | 815 | /* to not race resume */ 816 | pm = usb_autopm_get_interface(dev->intf); 817 | /* allow minidriver to stop correctly (wireless devices to turn off 818 | * radio etc) */ 819 | if (info->stop) { 820 | retval = info->stop(dev); 821 | if (retval < 0) 822 | netif_info(dev, ifdown, dev->net, 823 | "stop fail (%d) usbnet usb-%s-%s, %s\n", 824 | retval, 825 | dev->udev->bus->bus_name, dev->udev->devpath, 826 | info->description); 827 | } 828 | 829 | if (!(info->flags & FLAG_AVOID_UNLINK_URBS)) 830 | usbnet_terminate_urbs(dev); 831 | 832 | usbnet_status_stop(dev); 833 | 834 | usbnet_purge_paused_rxq(dev); 835 | 836 | mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, &dev->flags); 837 | 838 | /* deferred work (task, timer, softirq) must also stop. 839 | * can't flush_scheduled_work() until we drop rtnl (later), 840 | * else workers could deadlock; so make workers a NOP. 841 | */ 842 | dev->flags = 0; 843 | del_timer_sync (&dev->delay); 844 | tasklet_kill (&dev->bh); 845 | if (!pm) 846 | usb_autopm_put_interface(dev->intf); 847 | 848 | if (info->manage_power && mpn) 849 | info->manage_power(dev, 0); 850 | else 851 | usb_autopm_put_interface(dev->intf); 852 | 853 | return 0; 854 | } 855 | EXPORT_SYMBOL_GPL(usbnet_stop); 856 | 857 | /*-------------------------------------------------------------------------*/ 858 | 859 | // posts reads, and enables write queuing 860 | 861 | // precondition: never called in_interrupt 862 | 863 | int usbnet_open (struct net_device *net) 864 | { 865 | struct usbnet *dev = netdev_priv(net); 866 | int retval; 867 | struct driver_info *info = dev->driver_info; 868 | 869 | if ((retval = usb_autopm_get_interface(dev->intf)) < 0) { 870 | netif_info(dev, ifup, dev->net, 871 | "resumption fail (%d) usbnet usb-%s-%s, %s\n", 872 | retval, 873 | dev->udev->bus->bus_name, 874 | dev->udev->devpath, 875 | info->description); 876 | goto done_nopm; 877 | } 878 | 879 | // put into "known safe" state 880 | if (info->reset && (retval = info->reset (dev)) < 0) { 881 | netif_info(dev, ifup, dev->net, 882 | "open reset fail (%d) usbnet usb-%s-%s, %s\n", 883 | retval, 884 | dev->udev->bus->bus_name, 885 | dev->udev->devpath, 886 | info->description); 887 | goto done; 888 | } 889 | 890 | /* hard_mtu or rx_urb_size may change in reset() */ 891 | usbnet_update_max_qlen(dev); 892 | 893 | // insist peer be connected 894 | if (info->check_connect && (retval = info->check_connect (dev)) < 0) { 895 | netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval); 896 | goto done; 897 | } 898 | 899 | /* start any status interrupt transfer */ 900 | if (dev->interrupt) { 901 | retval = usbnet_status_start(dev, GFP_KERNEL); 902 | if (retval < 0) { 903 | netif_err(dev, ifup, dev->net, 904 | "intr submit %d\n", retval); 905 | goto done; 906 | } 907 | } 908 | 909 | set_bit(EVENT_DEV_OPEN, &dev->flags); 910 | netif_start_queue (net); 911 | netif_info(dev, ifup, dev->net, 912 | "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n", 913 | (int)RX_QLEN(dev), (int)TX_QLEN(dev), 914 | dev->net->mtu, 915 | (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" : 916 | (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" : 917 | (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" : 918 | (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" : 919 | (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" : 920 | "simple"); 921 | 922 | /* reset rx error state */ 923 | dev->pkt_cnt = 0; 924 | dev->pkt_err = 0; 925 | clear_bit(EVENT_RX_KILL, &dev->flags); 926 | 927 | // delay posting reads until we're fully open 928 | tasklet_schedule (&dev->bh); 929 | if (info->manage_power) { 930 | retval = info->manage_power(dev, 1); 931 | if (retval < 0) { 932 | retval = 0; 933 | set_bit(EVENT_NO_RUNTIME_PM, &dev->flags); 934 | } else { 935 | usb_autopm_put_interface(dev->intf); 936 | } 937 | } 938 | return retval; 939 | done: 940 | usb_autopm_put_interface(dev->intf); 941 | done_nopm: 942 | return retval; 943 | } 944 | EXPORT_SYMBOL_GPL(usbnet_open); 945 | 946 | /*-------------------------------------------------------------------------*/ 947 | 948 | /* ethtool methods; minidrivers may need to add some more, but 949 | * they'll probably want to use this base set. 950 | */ 951 | 952 | int usbnet_get_link_ksettings(struct net_device *net, 953 | struct ethtool_link_ksettings *cmd) 954 | { 955 | struct usbnet *dev = netdev_priv(net); 956 | 957 | if (!dev->mii.mdio_read) 958 | return -EOPNOTSUPP; 959 | 960 | mii_ethtool_get_link_ksettings(&dev->mii, cmd); 961 | 962 | return 0; 963 | } 964 | EXPORT_SYMBOL_GPL(usbnet_get_link_ksettings); 965 | 966 | int usbnet_set_link_ksettings(struct net_device *net, 967 | const struct ethtool_link_ksettings *cmd) 968 | { 969 | struct usbnet *dev = netdev_priv(net); 970 | int retval; 971 | 972 | if (!dev->mii.mdio_write) 973 | return -EOPNOTSUPP; 974 | 975 | retval = mii_ethtool_set_link_ksettings(&dev->mii, cmd); 976 | 977 | /* link speed/duplex might have changed */ 978 | if (dev->driver_info->link_reset) 979 | dev->driver_info->link_reset(dev); 980 | 981 | /* hard_mtu or rx_urb_size may change in link_reset() */ 982 | usbnet_update_max_qlen(dev); 983 | 984 | return retval; 985 | } 986 | EXPORT_SYMBOL_GPL(usbnet_set_link_ksettings); 987 | 988 | void usbnet_get_stats64(struct net_device *net, struct rtnl_link_stats64 *stats) 989 | { 990 | struct usbnet *dev = netdev_priv(net); 991 | unsigned int start; 992 | int cpu; 993 | 994 | netdev_stats_to_stats64(stats, &net->stats); 995 | 996 | for_each_possible_cpu(cpu) { 997 | struct pcpu_sw_netstats *stats64; 998 | u64 rx_packets, rx_bytes; 999 | u64 tx_packets, tx_bytes; 1000 | 1001 | stats64 = per_cpu_ptr(dev->stats64, cpu); 1002 | 1003 | do { 1004 | start = u64_stats_fetch_begin_irq(&stats64->syncp); 1005 | rx_packets = stats64->rx_packets; 1006 | rx_bytes = stats64->rx_bytes; 1007 | tx_packets = stats64->tx_packets; 1008 | tx_bytes = stats64->tx_bytes; 1009 | } while (u64_stats_fetch_retry_irq(&stats64->syncp, start)); 1010 | 1011 | stats->rx_packets += rx_packets; 1012 | stats->rx_bytes += rx_bytes; 1013 | stats->tx_packets += tx_packets; 1014 | stats->tx_bytes += tx_bytes; 1015 | } 1016 | } 1017 | EXPORT_SYMBOL_GPL(usbnet_get_stats64); 1018 | 1019 | u32 usbnet_get_link (struct net_device *net) 1020 | { 1021 | struct usbnet *dev = netdev_priv(net); 1022 | 1023 | /* If a check_connect is defined, return its result */ 1024 | if (dev->driver_info->check_connect) 1025 | return dev->driver_info->check_connect (dev) == 0; 1026 | 1027 | /* if the device has mii operations, use those */ 1028 | if (dev->mii.mdio_read) 1029 | return mii_link_ok(&dev->mii); 1030 | 1031 | /* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */ 1032 | return ethtool_op_get_link(net); 1033 | } 1034 | EXPORT_SYMBOL_GPL(usbnet_get_link); 1035 | 1036 | int usbnet_nway_reset(struct net_device *net) 1037 | { 1038 | struct usbnet *dev = netdev_priv(net); 1039 | 1040 | if (!dev->mii.mdio_write) 1041 | return -EOPNOTSUPP; 1042 | 1043 | return mii_nway_restart(&dev->mii); 1044 | } 1045 | EXPORT_SYMBOL_GPL(usbnet_nway_reset); 1046 | 1047 | void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info) 1048 | { 1049 | struct usbnet *dev = netdev_priv(net); 1050 | 1051 | strlcpy (info->driver, dev->driver_name, sizeof info->driver); 1052 | strlcpy (info->version, DRIVER_VERSION, sizeof info->version); 1053 | strlcpy (info->fw_version, dev->driver_info->description, 1054 | sizeof info->fw_version); 1055 | usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info); 1056 | } 1057 | EXPORT_SYMBOL_GPL(usbnet_get_drvinfo); 1058 | 1059 | u32 usbnet_get_msglevel (struct net_device *net) 1060 | { 1061 | struct usbnet *dev = netdev_priv(net); 1062 | 1063 | return dev->msg_enable; 1064 | } 1065 | EXPORT_SYMBOL_GPL(usbnet_get_msglevel); 1066 | 1067 | void usbnet_set_msglevel (struct net_device *net, u32 level) 1068 | { 1069 | struct usbnet *dev = netdev_priv(net); 1070 | 1071 | dev->msg_enable = level; 1072 | } 1073 | EXPORT_SYMBOL_GPL(usbnet_set_msglevel); 1074 | 1075 | /* drivers may override default ethtool_ops in their bind() routine */ 1076 | static const struct ethtool_ops usbnet_ethtool_ops = { 1077 | .get_link = usbnet_get_link, 1078 | .nway_reset = usbnet_nway_reset, 1079 | .get_drvinfo = usbnet_get_drvinfo, 1080 | .get_msglevel = usbnet_get_msglevel, 1081 | .set_msglevel = usbnet_set_msglevel, 1082 | .get_ts_info = ethtool_op_get_ts_info, 1083 | .get_link_ksettings = usbnet_get_link_ksettings, 1084 | .set_link_ksettings = usbnet_set_link_ksettings, 1085 | }; 1086 | 1087 | /*-------------------------------------------------------------------------*/ 1088 | 1089 | static void __handle_link_change(struct usbnet *dev) 1090 | { 1091 | if (!test_bit(EVENT_DEV_OPEN, &dev->flags)) 1092 | return; 1093 | 1094 | if (!netif_carrier_ok(dev->net)) { 1095 | /* kill URBs for reading packets to save bus bandwidth */ 1096 | unlink_urbs(dev, &dev->rxq); 1097 | 1098 | /* 1099 | * tx_timeout will unlink URBs for sending packets and 1100 | * tx queue is stopped by netcore after link becomes off 1101 | */ 1102 | } else { 1103 | /* submitting URBs for reading packets */ 1104 | tasklet_schedule(&dev->bh); 1105 | } 1106 | 1107 | /* hard_mtu or rx_urb_size may change during link change */ 1108 | usbnet_update_max_qlen(dev); 1109 | 1110 | clear_bit(EVENT_LINK_CHANGE, &dev->flags); 1111 | } 1112 | 1113 | static void usbnet_set_rx_mode(struct net_device *net) 1114 | { 1115 | struct usbnet *dev = netdev_priv(net); 1116 | 1117 | usbnet_defer_kevent(dev, EVENT_SET_RX_MODE); 1118 | } 1119 | 1120 | static void __handle_set_rx_mode(struct usbnet *dev) 1121 | { 1122 | if (dev->driver_info->set_rx_mode) 1123 | (dev->driver_info->set_rx_mode)(dev); 1124 | 1125 | clear_bit(EVENT_SET_RX_MODE, &dev->flags); 1126 | } 1127 | 1128 | /* work that cannot be done in interrupt context uses keventd. 1129 | * 1130 | * NOTE: with 2.5 we could do more of this using completion callbacks, 1131 | * especially now that control transfers can be queued. 1132 | */ 1133 | static void 1134 | usbnet_deferred_kevent (struct work_struct *work) 1135 | { 1136 | struct usbnet *dev = 1137 | container_of(work, struct usbnet, kevent); 1138 | int status; 1139 | 1140 | /* usb_clear_halt() needs a thread context */ 1141 | if (test_bit (EVENT_TX_HALT, &dev->flags)) { 1142 | unlink_urbs (dev, &dev->txq); 1143 | status = usb_autopm_get_interface(dev->intf); 1144 | if (status < 0) 1145 | goto fail_pipe; 1146 | status = usb_clear_halt (dev->udev, dev->out); 1147 | usb_autopm_put_interface(dev->intf); 1148 | if (status < 0 && 1149 | status != -EPIPE && 1150 | status != -ESHUTDOWN) { 1151 | if (netif_msg_tx_err (dev)) 1152 | fail_pipe: 1153 | netdev_err(dev->net, "can't clear tx halt, status %d\n", 1154 | status); 1155 | } else { 1156 | clear_bit (EVENT_TX_HALT, &dev->flags); 1157 | if (status != -ESHUTDOWN) 1158 | netif_wake_queue (dev->net); 1159 | } 1160 | } 1161 | if (test_bit (EVENT_RX_HALT, &dev->flags)) { 1162 | unlink_urbs (dev, &dev->rxq); 1163 | status = usb_autopm_get_interface(dev->intf); 1164 | if (status < 0) 1165 | goto fail_halt; 1166 | status = usb_clear_halt (dev->udev, dev->in); 1167 | usb_autopm_put_interface(dev->intf); 1168 | if (status < 0 && 1169 | status != -EPIPE && 1170 | status != -ESHUTDOWN) { 1171 | if (netif_msg_rx_err (dev)) 1172 | fail_halt: 1173 | netdev_err(dev->net, "can't clear rx halt, status %d\n", 1174 | status); 1175 | } else { 1176 | clear_bit (EVENT_RX_HALT, &dev->flags); 1177 | tasklet_schedule (&dev->bh); 1178 | } 1179 | } 1180 | 1181 | /* tasklet could resubmit itself forever if memory is tight */ 1182 | if (test_bit (EVENT_RX_MEMORY, &dev->flags)) { 1183 | struct urb *urb = NULL; 1184 | int resched = 1; 1185 | 1186 | if (netif_running (dev->net)) 1187 | urb = usb_alloc_urb (0, GFP_KERNEL); 1188 | else 1189 | clear_bit (EVENT_RX_MEMORY, &dev->flags); 1190 | if (urb != NULL) { 1191 | clear_bit (EVENT_RX_MEMORY, &dev->flags); 1192 | status = usb_autopm_get_interface(dev->intf); 1193 | if (status < 0) { 1194 | usb_free_urb(urb); 1195 | goto fail_lowmem; 1196 | } 1197 | if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK) 1198 | resched = 0; 1199 | usb_autopm_put_interface(dev->intf); 1200 | fail_lowmem: 1201 | if (resched) 1202 | tasklet_schedule (&dev->bh); 1203 | } 1204 | } 1205 | 1206 | if (test_bit (EVENT_LINK_RESET, &dev->flags)) { 1207 | struct driver_info *info = dev->driver_info; 1208 | int retval = 0; 1209 | 1210 | clear_bit (EVENT_LINK_RESET, &dev->flags); 1211 | status = usb_autopm_get_interface(dev->intf); 1212 | if (status < 0) 1213 | goto skip_reset; 1214 | if(info->link_reset && (retval = info->link_reset(dev)) < 0) { 1215 | usb_autopm_put_interface(dev->intf); 1216 | skip_reset: 1217 | netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n", 1218 | retval, 1219 | dev->udev->bus->bus_name, 1220 | dev->udev->devpath, 1221 | info->description); 1222 | } else { 1223 | usb_autopm_put_interface(dev->intf); 1224 | } 1225 | 1226 | /* handle link change from link resetting */ 1227 | __handle_link_change(dev); 1228 | } 1229 | 1230 | if (test_bit (EVENT_LINK_CHANGE, &dev->flags)) 1231 | __handle_link_change(dev); 1232 | 1233 | if (test_bit (EVENT_SET_RX_MODE, &dev->flags)) 1234 | __handle_set_rx_mode(dev); 1235 | 1236 | 1237 | if (dev->flags) 1238 | netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags); 1239 | } 1240 | 1241 | /*-------------------------------------------------------------------------*/ 1242 | 1243 | static void tx_complete (struct urb *urb) 1244 | { 1245 | struct sk_buff *skb = (struct sk_buff *) urb->context; 1246 | struct skb_data *entry = (struct skb_data *) skb->cb; 1247 | struct usbnet *dev = entry->dev; 1248 | 1249 | if (urb->status == 0) { 1250 | struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->stats64); 1251 | 1252 | u64_stats_update_begin(&stats64->syncp); 1253 | stats64->tx_packets += entry->packets; 1254 | stats64->tx_bytes += entry->length; 1255 | u64_stats_update_end(&stats64->syncp); 1256 | } else { 1257 | dev->net->stats.tx_errors++; 1258 | 1259 | switch (urb->status) { 1260 | case -EPIPE: 1261 | usbnet_defer_kevent (dev, EVENT_TX_HALT); 1262 | break; 1263 | 1264 | /* software-driven interface shutdown */ 1265 | case -ECONNRESET: // async unlink 1266 | case -ESHUTDOWN: // hardware gone 1267 | break; 1268 | 1269 | /* like rx, tx gets controller i/o faults during hub_wq 1270 | * delays and so it uses the same throttling mechanism. 1271 | */ 1272 | case -EPROTO: 1273 | case -ETIME: 1274 | case -EILSEQ: 1275 | usb_mark_last_busy(dev->udev); 1276 | if (!timer_pending (&dev->delay)) { 1277 | mod_timer (&dev->delay, 1278 | jiffies + THROTTLE_JIFFIES); 1279 | netif_dbg(dev, link, dev->net, 1280 | "tx throttle %d\n", urb->status); 1281 | } 1282 | netif_stop_queue (dev->net); 1283 | break; 1284 | default: 1285 | netif_dbg(dev, tx_err, dev->net, 1286 | "tx err %d\n", entry->urb->status); 1287 | break; 1288 | } 1289 | } 1290 | 1291 | usb_autopm_put_interface_async(dev->intf); 1292 | (void) defer_bh(dev, skb, &dev->txq, tx_done); 1293 | } 1294 | 1295 | /*-------------------------------------------------------------------------*/ 1296 | 1297 | void usbnet_tx_timeout (struct net_device *net) 1298 | { 1299 | struct usbnet *dev = netdev_priv(net); 1300 | 1301 | unlink_urbs (dev, &dev->txq); 1302 | tasklet_schedule (&dev->bh); 1303 | /* this needs to be handled individually because the generic layer 1304 | * doesn't know what is sufficient and could not restore private 1305 | * information if a remedy of an unconditional reset were used. 1306 | */ 1307 | if (dev->driver_info->recover) 1308 | (dev->driver_info->recover)(dev); 1309 | } 1310 | EXPORT_SYMBOL_GPL(usbnet_tx_timeout); 1311 | 1312 | /*-------------------------------------------------------------------------*/ 1313 | 1314 | static int build_dma_sg(const struct sk_buff *skb, struct urb *urb) 1315 | { 1316 | unsigned num_sgs, total_len = 0; 1317 | int i, s = 0; 1318 | 1319 | num_sgs = skb_shinfo(skb)->nr_frags + 1; 1320 | if (num_sgs == 1) 1321 | return 0; 1322 | 1323 | /* reserve one for zero packet */ 1324 | urb->sg = kmalloc((num_sgs + 1) * sizeof(struct scatterlist), 1325 | GFP_ATOMIC); 1326 | if (!urb->sg) 1327 | return -ENOMEM; 1328 | 1329 | urb->num_sgs = num_sgs; 1330 | sg_init_table(urb->sg, urb->num_sgs + 1); 1331 | 1332 | sg_set_buf(&urb->sg[s++], skb->data, skb_headlen(skb)); 1333 | total_len += skb_headlen(skb); 1334 | 1335 | for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 1336 | struct skb_frag_struct *f = &skb_shinfo(skb)->frags[i]; 1337 | 1338 | total_len += skb_frag_size(f); 1339 | sg_set_page(&urb->sg[i + s], f->page.p, f->size, 1340 | f->page_offset); 1341 | } 1342 | urb->transfer_buffer_length = total_len; 1343 | 1344 | return 1; 1345 | } 1346 | 1347 | netdev_tx_t usbnet_start_xmit (struct sk_buff *skb, 1348 | struct net_device *net) 1349 | { 1350 | struct usbnet *dev = netdev_priv(net); 1351 | unsigned int length; 1352 | struct urb *urb = NULL; 1353 | struct skb_data *entry; 1354 | struct driver_info *info = dev->driver_info; 1355 | unsigned long flags; 1356 | int retval; 1357 | 1358 | if (skb) 1359 | skb_tx_timestamp(skb); 1360 | 1361 | // some devices want funky USB-level framing, for 1362 | // win32 driver (usually) and/or hardware quirks 1363 | if (info->tx_fixup) { 1364 | skb = info->tx_fixup (dev, skb, GFP_ATOMIC); 1365 | if (!skb) { 1366 | /* packet collected; minidriver waiting for more */ 1367 | if (info->flags & FLAG_MULTI_PACKET) 1368 | goto not_drop; 1369 | netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n"); 1370 | goto drop; 1371 | } 1372 | } 1373 | 1374 | if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) { 1375 | netif_dbg(dev, tx_err, dev->net, "no urb\n"); 1376 | goto drop; 1377 | } 1378 | 1379 | entry = (struct skb_data *) skb->cb; 1380 | entry->urb = urb; 1381 | entry->dev = dev; 1382 | 1383 | usb_fill_bulk_urb (urb, dev->udev, dev->out, 1384 | skb->data, skb->len, tx_complete, skb); 1385 | if (dev->can_dma_sg) { 1386 | if (build_dma_sg(skb, urb) < 0) 1387 | goto drop; 1388 | } 1389 | length = urb->transfer_buffer_length; 1390 | 1391 | /* don't assume the hardware handles USB_ZERO_PACKET 1392 | * NOTE: strictly conforming cdc-ether devices should expect 1393 | * the ZLP here, but ignore the one-byte packet. 1394 | * NOTE2: CDC NCM specification is different from CDC ECM when 1395 | * handling ZLP/short packets, so cdc_ncm driver will make short 1396 | * packet itself if needed. 1397 | */ 1398 | if (length % dev->maxpacket == 0) { 1399 | if (!(info->flags & FLAG_SEND_ZLP)) { 1400 | if (!(info->flags & FLAG_MULTI_PACKET)) { 1401 | length++; 1402 | if (skb_tailroom(skb) && !urb->num_sgs) { 1403 | skb->data[skb->len] = 0; 1404 | __skb_put(skb, 1); 1405 | } else if (urb->num_sgs) 1406 | sg_set_buf(&urb->sg[urb->num_sgs++], 1407 | dev->padding_pkt, 1); 1408 | } 1409 | } else 1410 | urb->transfer_flags |= URB_ZERO_PACKET; 1411 | } 1412 | urb->transfer_buffer_length = length; 1413 | 1414 | if (info->flags & FLAG_MULTI_PACKET) { 1415 | /* Driver has set number of packets and a length delta. 1416 | * Calculate the complete length and ensure that it's 1417 | * positive. 1418 | */ 1419 | entry->length += length; 1420 | if (WARN_ON_ONCE(entry->length <= 0)) 1421 | entry->length = length; 1422 | } else { 1423 | usbnet_set_skb_tx_stats(skb, 1, length); 1424 | } 1425 | 1426 | spin_lock_irqsave(&dev->txq.lock, flags); 1427 | retval = usb_autopm_get_interface_async(dev->intf); 1428 | if (retval < 0) { 1429 | spin_unlock_irqrestore(&dev->txq.lock, flags); 1430 | goto drop; 1431 | } 1432 | 1433 | #ifdef CONFIG_PM 1434 | /* if this triggers the device is still a sleep */ 1435 | if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) { 1436 | /* transmission will be done in resume */ 1437 | usb_anchor_urb(urb, &dev->deferred); 1438 | /* no use to process more packets */ 1439 | netif_stop_queue(net); 1440 | usb_put_urb(urb); 1441 | spin_unlock_irqrestore(&dev->txq.lock, flags); 1442 | netdev_dbg(dev->net, "Delaying transmission for resumption\n"); 1443 | goto deferred; 1444 | } 1445 | #endif 1446 | 1447 | switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) { 1448 | case -EPIPE: 1449 | netif_stop_queue (net); 1450 | usbnet_defer_kevent (dev, EVENT_TX_HALT); 1451 | usb_autopm_put_interface_async(dev->intf); 1452 | break; 1453 | default: 1454 | usb_autopm_put_interface_async(dev->intf); 1455 | netif_dbg(dev, tx_err, dev->net, 1456 | "tx: submit urb err %d\n", retval); 1457 | break; 1458 | case 0: 1459 | netif_trans_update(net); 1460 | __usbnet_queue_skb(&dev->txq, skb, tx_start); 1461 | if (dev->txq.qlen >= TX_QLEN (dev)) 1462 | netif_stop_queue (net); 1463 | } 1464 | spin_unlock_irqrestore (&dev->txq.lock, flags); 1465 | 1466 | if (retval) { 1467 | netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval); 1468 | drop: 1469 | dev->net->stats.tx_dropped++; 1470 | not_drop: 1471 | if (skb) 1472 | dev_kfree_skb_any (skb); 1473 | if (urb) { 1474 | kfree(urb->sg); 1475 | usb_free_urb(urb); 1476 | } 1477 | } else 1478 | netif_dbg(dev, tx_queued, dev->net, 1479 | "> tx, len %u, type 0x%x\n", length, skb->protocol); 1480 | #ifdef CONFIG_PM 1481 | deferred: 1482 | #endif 1483 | return NETDEV_TX_OK; 1484 | } 1485 | EXPORT_SYMBOL_GPL(usbnet_start_xmit); 1486 | 1487 | static int rx_alloc_submit(struct usbnet *dev, gfp_t flags) 1488 | { 1489 | struct urb *urb; 1490 | int i; 1491 | int ret = 0; 1492 | 1493 | /* don't refill the queue all at once */ 1494 | for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) { 1495 | urb = usb_alloc_urb(0, flags); 1496 | if (urb != NULL) { 1497 | ret = rx_submit(dev, urb, flags); 1498 | if (ret) 1499 | goto err; 1500 | } else { 1501 | ret = -ENOMEM; 1502 | goto err; 1503 | } 1504 | } 1505 | err: 1506 | return ret; 1507 | } 1508 | 1509 | /*-------------------------------------------------------------------------*/ 1510 | 1511 | // tasklet (work deferred from completions, in_irq) or timer 1512 | 1513 | static void usbnet_bh (struct timer_list *t) 1514 | { 1515 | struct usbnet *dev = from_timer(dev, t, delay); 1516 | struct sk_buff *skb; 1517 | struct skb_data *entry; 1518 | 1519 | while ((skb = skb_dequeue (&dev->done))) { 1520 | entry = (struct skb_data *) skb->cb; 1521 | switch (entry->state) { 1522 | case rx_done: 1523 | entry->state = rx_cleanup; 1524 | rx_process (dev, skb); 1525 | continue; 1526 | case tx_done: 1527 | kfree(entry->urb->sg); 1528 | case rx_cleanup: 1529 | usb_free_urb (entry->urb); 1530 | dev_kfree_skb (skb); 1531 | continue; 1532 | default: 1533 | netdev_dbg(dev->net, "bogus skb state %d\n", entry->state); 1534 | } 1535 | } 1536 | 1537 | /* restart RX again after disabling due to high error rate */ 1538 | clear_bit(EVENT_RX_KILL, &dev->flags); 1539 | 1540 | /* waiting for all pending urbs to complete? 1541 | * only then can we forgo submitting anew 1542 | */ 1543 | if (waitqueue_active(&dev->wait)) { 1544 | if (dev->txq.qlen + dev->rxq.qlen + dev->done.qlen == 0) 1545 | wake_up_all(&dev->wait); 1546 | 1547 | // or are we maybe short a few urbs? 1548 | } else if (netif_running (dev->net) && 1549 | netif_device_present (dev->net) && 1550 | netif_carrier_ok(dev->net) && 1551 | !timer_pending(&dev->delay) && 1552 | !test_bit(EVENT_RX_PAUSED, &dev->flags) && 1553 | !test_bit(EVENT_RX_HALT, &dev->flags)) { 1554 | int temp = dev->rxq.qlen; 1555 | 1556 | if (temp < RX_QLEN(dev)) { 1557 | if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK) 1558 | return; 1559 | if (temp != dev->rxq.qlen) 1560 | netif_dbg(dev, link, dev->net, 1561 | "rxqlen %d --> %d\n", 1562 | temp, dev->rxq.qlen); 1563 | if (dev->rxq.qlen < RX_QLEN(dev)) 1564 | tasklet_schedule (&dev->bh); 1565 | } 1566 | if (dev->txq.qlen < TX_QLEN (dev)) 1567 | netif_wake_queue (dev->net); 1568 | } 1569 | } 1570 | 1571 | 1572 | /*------------------------------------------------------------------------- 1573 | * 1574 | * USB Device Driver support 1575 | * 1576 | *-------------------------------------------------------------------------*/ 1577 | 1578 | // precondition: never called in_interrupt 1579 | 1580 | void usbnet_disconnect (struct usb_interface *intf) 1581 | { 1582 | struct usbnet *dev; 1583 | struct usb_device *xdev; 1584 | struct net_device *net; 1585 | 1586 | dev = usb_get_intfdata(intf); 1587 | usb_set_intfdata(intf, NULL); 1588 | if (!dev) 1589 | return; 1590 | 1591 | xdev = interface_to_usbdev (intf); 1592 | 1593 | netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n", 1594 | intf->dev.driver->name, 1595 | xdev->bus->bus_name, xdev->devpath, 1596 | dev->driver_info->description); 1597 | 1598 | net = dev->net; 1599 | unregister_netdev (net); 1600 | 1601 | cancel_work_sync(&dev->kevent); 1602 | 1603 | usb_scuttle_anchored_urbs(&dev->deferred); 1604 | 1605 | if (dev->driver_info->unbind) 1606 | dev->driver_info->unbind (dev, intf); 1607 | 1608 | usb_kill_urb(dev->interrupt); 1609 | usb_free_urb(dev->interrupt); 1610 | kfree(dev->padding_pkt); 1611 | 1612 | free_percpu(dev->stats64); 1613 | free_netdev(net); 1614 | } 1615 | EXPORT_SYMBOL_GPL(usbnet_disconnect); 1616 | 1617 | static const struct net_device_ops usbnet_netdev_ops = { 1618 | .ndo_open = usbnet_open, 1619 | .ndo_stop = usbnet_stop, 1620 | .ndo_start_xmit = usbnet_start_xmit, 1621 | .ndo_tx_timeout = usbnet_tx_timeout, 1622 | .ndo_set_rx_mode = usbnet_set_rx_mode, 1623 | .ndo_change_mtu = usbnet_change_mtu, 1624 | .ndo_get_stats64 = usbnet_get_stats64, 1625 | .ndo_set_mac_address = eth_mac_addr, 1626 | .ndo_validate_addr = eth_validate_addr, 1627 | }; 1628 | 1629 | /*-------------------------------------------------------------------------*/ 1630 | 1631 | // precondition: never called in_interrupt 1632 | 1633 | static struct device_type wlan_type = { 1634 | .name = "wlan", 1635 | }; 1636 | 1637 | static struct device_type wwan_type = { 1638 | .name = "wwan", 1639 | }; 1640 | 1641 | int 1642 | usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod) 1643 | { 1644 | struct usbnet *dev; 1645 | struct net_device *net; 1646 | struct usb_host_interface *interface; 1647 | struct driver_info *info; 1648 | struct usb_device *xdev; 1649 | int status; 1650 | const char *name; 1651 | struct usb_driver *driver = to_usb_driver(udev->dev.driver); 1652 | 1653 | /* usbnet already took usb runtime pm, so have to enable the feature 1654 | * for usb interface, otherwise usb_autopm_get_interface may return 1655 | * failure if RUNTIME_PM is enabled. 1656 | */ 1657 | if (!driver->supports_autosuspend) { 1658 | driver->supports_autosuspend = 1; 1659 | pm_runtime_enable(&udev->dev); 1660 | } 1661 | 1662 | name = udev->dev.driver->name; 1663 | info = (struct driver_info *) prod->driver_info; 1664 | if (!info) { 1665 | dev_dbg (&udev->dev, "blacklisted by %s\n", name); 1666 | return -ENODEV; 1667 | } 1668 | xdev = interface_to_usbdev (udev); 1669 | interface = udev->cur_altsetting; 1670 | 1671 | status = -ENOMEM; 1672 | 1673 | // set up our own records 1674 | net = alloc_etherdev(sizeof(*dev)); 1675 | if (!net) 1676 | goto out; 1677 | 1678 | /* netdev_printk() needs this so do it as early as possible */ 1679 | SET_NETDEV_DEV(net, &udev->dev); 1680 | 1681 | dev = netdev_priv(net); 1682 | dev->udev = xdev; 1683 | dev->intf = udev; 1684 | dev->driver_info = info; 1685 | dev->driver_name = name; 1686 | 1687 | dev->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 1688 | if (!dev->stats64) 1689 | goto out0; 1690 | 1691 | dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV 1692 | | NETIF_MSG_PROBE | NETIF_MSG_LINK); 1693 | init_waitqueue_head(&dev->wait); 1694 | skb_queue_head_init (&dev->rxq); 1695 | skb_queue_head_init (&dev->txq); 1696 | skb_queue_head_init (&dev->done); 1697 | skb_queue_head_init(&dev->rxq_pause); 1698 | dev->bh.func = (void (*)(unsigned long))usbnet_bh; 1699 | dev->bh.data = (unsigned long)&dev->delay; 1700 | INIT_WORK (&dev->kevent, usbnet_deferred_kevent); 1701 | init_usb_anchor(&dev->deferred); 1702 | timer_setup(&dev->delay, usbnet_bh, 0); 1703 | mutex_init (&dev->phy_mutex); 1704 | mutex_init(&dev->interrupt_mutex); 1705 | dev->interrupt_count = 0; 1706 | 1707 | dev->net = net; 1708 | strcpy (net->name, "usb%d"); 1709 | memcpy (net->dev_addr, node_id, sizeof node_id); 1710 | 1711 | /* rx and tx sides can use different message sizes; 1712 | * bind() should set rx_urb_size in that case. 1713 | */ 1714 | dev->hard_mtu = net->mtu + net->hard_header_len; 1715 | net->min_mtu = 0; 1716 | net->max_mtu = ETH_MAX_MTU; 1717 | 1718 | net->netdev_ops = &usbnet_netdev_ops; 1719 | net->watchdog_timeo = TX_TIMEOUT_JIFFIES; 1720 | net->ethtool_ops = &usbnet_ethtool_ops; 1721 | 1722 | // allow device-specific bind/init procedures 1723 | // NOTE net->name still not usable ... 1724 | if (info->bind) { 1725 | status = info->bind (dev, udev); 1726 | if (status < 0) 1727 | goto out1; 1728 | 1729 | // heuristic: "usb%d" for links we know are two-host, 1730 | // else "eth%d" when there's reasonable doubt. userspace 1731 | // can rename the link if it knows better. 1732 | if ((dev->driver_info->flags & FLAG_ETHER) != 0 && 1733 | ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 || 1734 | (net->dev_addr [0] & 0x02) == 0)) 1735 | strcpy (net->name, "eth%d"); 1736 | /* WLAN devices should always be named "wlan%d" */ 1737 | if ((dev->driver_info->flags & FLAG_WLAN) != 0) 1738 | strcpy(net->name, "wlan%d"); 1739 | /* WWAN devices should always be named "wwan%d" */ 1740 | if ((dev->driver_info->flags & FLAG_WWAN) != 0) 1741 | strcpy(net->name, "wwan%d"); 1742 | 1743 | /* devices that cannot do ARP */ 1744 | if ((dev->driver_info->flags & FLAG_NOARP) != 0) 1745 | net->flags |= IFF_NOARP; 1746 | 1747 | /* maybe the remote can't receive an Ethernet MTU */ 1748 | if (net->mtu > (dev->hard_mtu - net->hard_header_len)) 1749 | net->mtu = dev->hard_mtu - net->hard_header_len; 1750 | } else if (!info->in || !info->out) 1751 | status = usbnet_get_endpoints (dev, udev); 1752 | else { 1753 | dev->in = usb_rcvbulkpipe (xdev, info->in); 1754 | dev->out = usb_sndbulkpipe (xdev, info->out); 1755 | if (!(info->flags & FLAG_NO_SETINT)) 1756 | status = usb_set_interface (xdev, 1757 | interface->desc.bInterfaceNumber, 1758 | interface->desc.bAlternateSetting); 1759 | else 1760 | status = 0; 1761 | 1762 | } 1763 | if (status >= 0 && dev->status) 1764 | status = init_status (dev, udev); 1765 | if (status < 0) 1766 | goto out3; 1767 | 1768 | if (!dev->rx_urb_size) 1769 | dev->rx_urb_size = dev->hard_mtu; 1770 | dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1); 1771 | 1772 | /* let userspace know we have a random address */ 1773 | if (ether_addr_equal(net->dev_addr, node_id)) 1774 | net->addr_assign_type = NET_ADDR_RANDOM; 1775 | 1776 | if ((dev->driver_info->flags & FLAG_WLAN) != 0) 1777 | SET_NETDEV_DEVTYPE(net, &wlan_type); 1778 | if ((dev->driver_info->flags & FLAG_WWAN) != 0) 1779 | SET_NETDEV_DEVTYPE(net, &wwan_type); 1780 | 1781 | /* initialize max rx_qlen and tx_qlen */ 1782 | usbnet_update_max_qlen(dev); 1783 | 1784 | if (dev->can_dma_sg && !(info->flags & FLAG_SEND_ZLP) && 1785 | !(info->flags & FLAG_MULTI_PACKET)) { 1786 | dev->padding_pkt = kzalloc(1, GFP_KERNEL); 1787 | if (!dev->padding_pkt) { 1788 | status = -ENOMEM; 1789 | goto out4; 1790 | } 1791 | } 1792 | 1793 | status = register_netdev (net); 1794 | if (status) 1795 | goto out5; 1796 | netif_info(dev, probe, dev->net, 1797 | "register '%s' at usb-%s-%s, %s, %pM\n", 1798 | udev->dev.driver->name, 1799 | xdev->bus->bus_name, xdev->devpath, 1800 | dev->driver_info->description, 1801 | net->dev_addr); 1802 | 1803 | // ok, it's ready to go. 1804 | usb_set_intfdata (udev, dev); 1805 | 1806 | netif_device_attach (net); 1807 | 1808 | if (dev->driver_info->flags & FLAG_LINK_INTR) 1809 | usbnet_link_change(dev, 0, 0); 1810 | 1811 | return 0; 1812 | 1813 | out5: 1814 | kfree(dev->padding_pkt); 1815 | out4: 1816 | usb_free_urb(dev->interrupt); 1817 | out3: 1818 | if (info->unbind) 1819 | info->unbind (dev, udev); 1820 | out1: 1821 | /* subdrivers must undo all they did in bind() if they 1822 | * fail it, but we may fail later and a deferred kevent 1823 | * may trigger an error resubmitting itself and, worse, 1824 | * schedule a timer. So we kill it all just in case. 1825 | */ 1826 | cancel_work_sync(&dev->kevent); 1827 | del_timer_sync(&dev->delay); 1828 | free_percpu(dev->stats64); 1829 | out0: 1830 | free_netdev(net); 1831 | out: 1832 | return status; 1833 | } 1834 | EXPORT_SYMBOL_GPL(usbnet_probe); 1835 | 1836 | /*-------------------------------------------------------------------------*/ 1837 | 1838 | /* 1839 | * suspend the whole driver as soon as the first interface is suspended 1840 | * resume only when the last interface is resumed 1841 | */ 1842 | 1843 | int usbnet_suspend (struct usb_interface *intf, pm_message_t message) 1844 | { 1845 | struct usbnet *dev = usb_get_intfdata(intf); 1846 | 1847 | if (!dev->suspend_count++) { 1848 | spin_lock_irq(&dev->txq.lock); 1849 | /* don't autosuspend while transmitting */ 1850 | if (dev->txq.qlen && PMSG_IS_AUTO(message)) { 1851 | dev->suspend_count--; 1852 | spin_unlock_irq(&dev->txq.lock); 1853 | return -EBUSY; 1854 | } else { 1855 | set_bit(EVENT_DEV_ASLEEP, &dev->flags); 1856 | spin_unlock_irq(&dev->txq.lock); 1857 | } 1858 | /* 1859 | * accelerate emptying of the rx and queues, to avoid 1860 | * having everything error out. 1861 | */ 1862 | netif_device_detach (dev->net); 1863 | usbnet_terminate_urbs(dev); 1864 | __usbnet_status_stop_force(dev); 1865 | 1866 | /* 1867 | * reattach so runtime management can use and 1868 | * wake the device 1869 | */ 1870 | netif_device_attach (dev->net); 1871 | } 1872 | return 0; 1873 | } 1874 | EXPORT_SYMBOL_GPL(usbnet_suspend); 1875 | 1876 | int usbnet_resume (struct usb_interface *intf) 1877 | { 1878 | struct usbnet *dev = usb_get_intfdata(intf); 1879 | struct sk_buff *skb; 1880 | struct urb *res; 1881 | int retval; 1882 | 1883 | if (!--dev->suspend_count) { 1884 | /* resume interrupt URB if it was previously submitted */ 1885 | __usbnet_status_start_force(dev, GFP_NOIO); 1886 | 1887 | spin_lock_irq(&dev->txq.lock); 1888 | while ((res = usb_get_from_anchor(&dev->deferred))) { 1889 | 1890 | skb = (struct sk_buff *)res->context; 1891 | retval = usb_submit_urb(res, GFP_ATOMIC); 1892 | if (retval < 0) { 1893 | dev_kfree_skb_any(skb); 1894 | kfree(res->sg); 1895 | usb_free_urb(res); 1896 | usb_autopm_put_interface_async(dev->intf); 1897 | } else { 1898 | netif_trans_update(dev->net); 1899 | __skb_queue_tail(&dev->txq, skb); 1900 | } 1901 | } 1902 | 1903 | smp_mb(); 1904 | clear_bit(EVENT_DEV_ASLEEP, &dev->flags); 1905 | spin_unlock_irq(&dev->txq.lock); 1906 | 1907 | if (test_bit(EVENT_DEV_OPEN, &dev->flags)) { 1908 | /* handle remote wakeup ASAP 1909 | * we cannot race against stop 1910 | */ 1911 | if (netif_device_present(dev->net) && 1912 | !timer_pending(&dev->delay) && 1913 | !test_bit(EVENT_RX_HALT, &dev->flags)) 1914 | rx_alloc_submit(dev, GFP_NOIO); 1915 | 1916 | if (!(dev->txq.qlen >= TX_QLEN(dev))) 1917 | netif_tx_wake_all_queues(dev->net); 1918 | tasklet_schedule (&dev->bh); 1919 | } 1920 | } 1921 | 1922 | if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags)) 1923 | usb_autopm_get_interface_no_resume(intf); 1924 | 1925 | return 0; 1926 | } 1927 | EXPORT_SYMBOL_GPL(usbnet_resume); 1928 | 1929 | /* 1930 | * Either a subdriver implements manage_power, then it is assumed to always 1931 | * be ready to be suspended or it reports the readiness to be suspended 1932 | * explicitly 1933 | */ 1934 | void usbnet_device_suggests_idle(struct usbnet *dev) 1935 | { 1936 | if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE, &dev->flags)) { 1937 | dev->intf->needs_remote_wakeup = 1; 1938 | usb_autopm_put_interface_async(dev->intf); 1939 | } 1940 | } 1941 | EXPORT_SYMBOL(usbnet_device_suggests_idle); 1942 | 1943 | /* 1944 | * For devices that can do without special commands 1945 | */ 1946 | int usbnet_manage_power(struct usbnet *dev, int on) 1947 | { 1948 | dev->intf->needs_remote_wakeup = on; 1949 | return 0; 1950 | } 1951 | EXPORT_SYMBOL(usbnet_manage_power); 1952 | 1953 | void usbnet_link_change(struct usbnet *dev, bool link, bool need_reset) 1954 | { 1955 | /* update link after link is reseted */ 1956 | if (link && !need_reset) 1957 | netif_carrier_on(dev->net); 1958 | else 1959 | netif_carrier_off(dev->net); 1960 | 1961 | if (need_reset && link) 1962 | usbnet_defer_kevent(dev, EVENT_LINK_RESET); 1963 | else 1964 | usbnet_defer_kevent(dev, EVENT_LINK_CHANGE); 1965 | } 1966 | EXPORT_SYMBOL(usbnet_link_change); 1967 | 1968 | /*-------------------------------------------------------------------------*/ 1969 | static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype, 1970 | u16 value, u16 index, void *data, u16 size) 1971 | { 1972 | void *buf = NULL; 1973 | int err = -ENOMEM; 1974 | 1975 | netdev_dbg(dev->net, "usbnet_read_cmd cmd=0x%02x reqtype=%02x" 1976 | " value=0x%04x index=0x%04x size=%d\n", 1977 | cmd, reqtype, value, index, size); 1978 | 1979 | if (size) { 1980 | buf = kmalloc(size, GFP_KERNEL); 1981 | if (!buf) 1982 | goto out; 1983 | } 1984 | 1985 | err = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), 1986 | cmd, reqtype, value, index, buf, size, 1987 | USB_CTRL_GET_TIMEOUT); 1988 | if (err > 0 && err <= size) { 1989 | if (data) 1990 | memcpy(data, buf, err); 1991 | else 1992 | netdev_dbg(dev->net, 1993 | "Huh? Data requested but thrown away.\n"); 1994 | } 1995 | kfree(buf); 1996 | out: 1997 | return err; 1998 | } 1999 | 2000 | static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype, 2001 | u16 value, u16 index, const void *data, 2002 | u16 size) 2003 | { 2004 | void *buf = NULL; 2005 | int err = -ENOMEM; 2006 | 2007 | netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x" 2008 | " value=0x%04x index=0x%04x size=%d\n", 2009 | cmd, reqtype, value, index, size); 2010 | 2011 | if (data) { 2012 | buf = kmemdup(data, size, GFP_KERNEL); 2013 | if (!buf) 2014 | goto out; 2015 | } else { 2016 | if (size) { 2017 | WARN_ON_ONCE(1); 2018 | err = -EINVAL; 2019 | goto out; 2020 | } 2021 | } 2022 | 2023 | err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), 2024 | cmd, reqtype, value, index, buf, size, 2025 | USB_CTRL_SET_TIMEOUT); 2026 | kfree(buf); 2027 | 2028 | out: 2029 | return err; 2030 | } 2031 | 2032 | /* 2033 | * The function can't be called inside suspend/resume callback, 2034 | * otherwise deadlock will be caused. 2035 | */ 2036 | int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype, 2037 | u16 value, u16 index, void *data, u16 size) 2038 | { 2039 | int ret; 2040 | 2041 | if (usb_autopm_get_interface(dev->intf) < 0) 2042 | return -ENODEV; 2043 | ret = __usbnet_read_cmd(dev, cmd, reqtype, value, index, 2044 | data, size); 2045 | usb_autopm_put_interface(dev->intf); 2046 | return ret; 2047 | } 2048 | EXPORT_SYMBOL_GPL(usbnet_read_cmd); 2049 | 2050 | /* 2051 | * The function can't be called inside suspend/resume callback, 2052 | * otherwise deadlock will be caused. 2053 | */ 2054 | int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype, 2055 | u16 value, u16 index, const void *data, u16 size) 2056 | { 2057 | int ret; 2058 | 2059 | if (usb_autopm_get_interface(dev->intf) < 0) 2060 | return -ENODEV; 2061 | ret = __usbnet_write_cmd(dev, cmd, reqtype, value, index, 2062 | data, size); 2063 | usb_autopm_put_interface(dev->intf); 2064 | return ret; 2065 | } 2066 | EXPORT_SYMBOL_GPL(usbnet_write_cmd); 2067 | 2068 | /* 2069 | * The function can be called inside suspend/resume callback safely 2070 | * and should only be called by suspend/resume callback generally. 2071 | */ 2072 | int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype, 2073 | u16 value, u16 index, void *data, u16 size) 2074 | { 2075 | return __usbnet_read_cmd(dev, cmd, reqtype, value, index, 2076 | data, size); 2077 | } 2078 | EXPORT_SYMBOL_GPL(usbnet_read_cmd_nopm); 2079 | 2080 | /* 2081 | * The function can be called inside suspend/resume callback safely 2082 | * and should only be called by suspend/resume callback generally. 2083 | */ 2084 | int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype, 2085 | u16 value, u16 index, const void *data, 2086 | u16 size) 2087 | { 2088 | return __usbnet_write_cmd(dev, cmd, reqtype, value, index, 2089 | data, size); 2090 | } 2091 | EXPORT_SYMBOL_GPL(usbnet_write_cmd_nopm); 2092 | 2093 | static void usbnet_async_cmd_cb(struct urb *urb) 2094 | { 2095 | struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context; 2096 | int status = urb->status; 2097 | 2098 | if (status < 0) 2099 | dev_dbg(&urb->dev->dev, "%s failed with %d", 2100 | __func__, status); 2101 | 2102 | kfree(req); 2103 | usb_free_urb(urb); 2104 | } 2105 | 2106 | /* 2107 | * The caller must make sure that device can't be put into suspend 2108 | * state until the control URB completes. 2109 | */ 2110 | int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype, 2111 | u16 value, u16 index, const void *data, u16 size) 2112 | { 2113 | struct usb_ctrlrequest *req = NULL; 2114 | struct urb *urb; 2115 | int err = -ENOMEM; 2116 | void *buf = NULL; 2117 | 2118 | netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x" 2119 | " value=0x%04x index=0x%04x size=%d\n", 2120 | cmd, reqtype, value, index, size); 2121 | 2122 | urb = usb_alloc_urb(0, GFP_ATOMIC); 2123 | if (!urb) 2124 | goto fail; 2125 | 2126 | if (data) { 2127 | buf = kmemdup(data, size, GFP_ATOMIC); 2128 | if (!buf) { 2129 | netdev_err(dev->net, "Error allocating buffer" 2130 | " in %s!\n", __func__); 2131 | goto fail_free; 2132 | } 2133 | } 2134 | 2135 | req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC); 2136 | if (!req) 2137 | goto fail_free_buf; 2138 | 2139 | req->bRequestType = reqtype; 2140 | req->bRequest = cmd; 2141 | req->wValue = cpu_to_le16(value); 2142 | req->wIndex = cpu_to_le16(index); 2143 | req->wLength = cpu_to_le16(size); 2144 | 2145 | usb_fill_control_urb(urb, dev->udev, 2146 | usb_sndctrlpipe(dev->udev, 0), 2147 | (void *)req, buf, size, 2148 | usbnet_async_cmd_cb, req); 2149 | urb->transfer_flags |= URB_FREE_BUFFER; 2150 | 2151 | err = usb_submit_urb(urb, GFP_ATOMIC); 2152 | if (err < 0) { 2153 | netdev_err(dev->net, "Error submitting the control" 2154 | " message: status=%d\n", err); 2155 | goto fail_free; 2156 | } 2157 | return 0; 2158 | 2159 | fail_free_buf: 2160 | kfree(buf); 2161 | fail_free: 2162 | kfree(req); 2163 | usb_free_urb(urb); 2164 | fail: 2165 | return err; 2166 | 2167 | } 2168 | EXPORT_SYMBOL_GPL(usbnet_write_cmd_async); 2169 | /*-------------------------------------------------------------------------*/ 2170 | 2171 | static int __init usbnet_init(void) 2172 | { 2173 | /* Compiler should optimize this out. */ 2174 | BUILD_BUG_ON( 2175 | FIELD_SIZEOF(struct sk_buff, cb) < sizeof(struct skb_data)); 2176 | 2177 | eth_random_addr(node_id); 2178 | return 0; 2179 | } 2180 | module_init(usbnet_init); 2181 | 2182 | static void __exit usbnet_exit(void) 2183 | { 2184 | } 2185 | module_exit(usbnet_exit); 2186 | 2187 | MODULE_AUTHOR("David Brownell"); 2188 | MODULE_DESCRIPTION("USB network driver framework"); 2189 | MODULE_LICENSE("GPL"); 2190 | -------------------------------------------------------------------------------- /drivers/usb/serial/qcserial.c: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-2.0 2 | /* 3 | * Qualcomm Serial USB driver 4 | * 5 | * Copyright (c) 2008 QUALCOMM Incorporated. 6 | * Copyright (c) 2009 Greg Kroah-Hartman 7 | * Copyright (c) 2009 Novell Inc. 8 | */ 9 | 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include "usb-wwan.h" 17 | 18 | #define DRIVER_AUTHOR "Qualcomm Inc" 19 | #define DRIVER_DESC "Qualcomm USB Serial driver" 20 | 21 | #define QUECTEL_EC20_PID 0x9215 22 | 23 | /* standard device layouts supported by this driver */ 24 | enum qcserial_layouts { 25 | QCSERIAL_G2K = 0, /* Gobi 2000 */ 26 | QCSERIAL_G1K = 1, /* Gobi 1000 */ 27 | QCSERIAL_SWI = 2, /* Sierra Wireless */ 28 | QCSERIAL_HWI = 3, /* Huawei */ 29 | }; 30 | 31 | #define DEVICE_G1K(v, p) \ 32 | USB_DEVICE(v, p), .driver_info = QCSERIAL_G1K 33 | #define DEVICE_SWI(v, p) \ 34 | USB_DEVICE(v, p), .driver_info = QCSERIAL_SWI 35 | #define DEVICE_HWI(v, p) \ 36 | USB_DEVICE(v, p), .driver_info = QCSERIAL_HWI 37 | 38 | static const struct usb_device_id id_table[] = { 39 | /* Gobi 1000 devices */ 40 | {DEVICE_G1K(0x05c6, 0x9211)}, /* Acer Gobi QDL device */ 41 | {DEVICE_G1K(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */ 42 | {DEVICE_G1K(0x03f0, 0x1f1d)}, /* HP un2400 Gobi Modem Device */ 43 | {DEVICE_G1K(0x03f0, 0x201d)}, /* HP un2400 Gobi QDL Device */ 44 | {DEVICE_G1K(0x04da, 0x250d)}, /* Panasonic Gobi Modem device */ 45 | {DEVICE_G1K(0x04da, 0x250c)}, /* Panasonic Gobi QDL device */ 46 | {DEVICE_G1K(0x413c, 0x8172)}, /* Dell Gobi Modem device */ 47 | {DEVICE_G1K(0x413c, 0x8171)}, /* Dell Gobi QDL device */ 48 | {DEVICE_G1K(0x1410, 0xa001)}, /* Novatel/Verizon USB-1000 */ 49 | {DEVICE_G1K(0x1410, 0xa002)}, /* Novatel Gobi Modem device */ 50 | {DEVICE_G1K(0x1410, 0xa003)}, /* Novatel Gobi Modem device */ 51 | {DEVICE_G1K(0x1410, 0xa004)}, /* Novatel Gobi Modem device */ 52 | {DEVICE_G1K(0x1410, 0xa005)}, /* Novatel Gobi Modem device */ 53 | {DEVICE_G1K(0x1410, 0xa006)}, /* Novatel Gobi Modem device */ 54 | {DEVICE_G1K(0x1410, 0xa007)}, /* Novatel Gobi Modem device */ 55 | {DEVICE_G1K(0x1410, 0xa008)}, /* Novatel Gobi QDL device */ 56 | {DEVICE_G1K(0x0b05, 0x1776)}, /* Asus Gobi Modem device */ 57 | {DEVICE_G1K(0x0b05, 0x1774)}, /* Asus Gobi QDL device */ 58 | {DEVICE_G1K(0x19d2, 0xfff3)}, /* ONDA Gobi Modem device */ 59 | {DEVICE_G1K(0x19d2, 0xfff2)}, /* ONDA Gobi QDL device */ 60 | {DEVICE_G1K(0x1557, 0x0a80)}, /* OQO Gobi QDL device */ 61 | {DEVICE_G1K(0x05c6, 0x9001)}, /* Generic Gobi Modem device */ 62 | {DEVICE_G1K(0x05c6, 0x9002)}, /* Generic Gobi Modem device */ 63 | {DEVICE_G1K(0x05c6, 0x9202)}, /* Generic Gobi Modem device */ 64 | {DEVICE_G1K(0x05c6, 0x9203)}, /* Generic Gobi Modem device */ 65 | {DEVICE_G1K(0x05c6, 0x9222)}, /* Generic Gobi Modem device */ 66 | {DEVICE_G1K(0x05c6, 0x9008)}, /* Generic Gobi QDL device */ 67 | {DEVICE_G1K(0x05c6, 0x9009)}, /* Generic Gobi Modem device */ 68 | {DEVICE_G1K(0x05c6, 0x9201)}, /* Generic Gobi QDL device */ 69 | {DEVICE_G1K(0x05c6, 0x9221)}, /* Generic Gobi QDL device */ 70 | {DEVICE_G1K(0x05c6, 0x9231)}, /* Generic Gobi QDL device */ 71 | {DEVICE_G1K(0x1f45, 0x0001)}, /* Unknown Gobi QDL device */ 72 | {DEVICE_G1K(0x1bc7, 0x900e)}, /* Telit Gobi QDL device */ 73 | 74 | /* Gobi 2000 devices */ 75 | {USB_DEVICE(0x1410, 0xa010)}, /* Novatel Gobi 2000 QDL device */ 76 | {USB_DEVICE(0x1410, 0xa011)}, /* Novatel Gobi 2000 QDL device */ 77 | {USB_DEVICE(0x1410, 0xa012)}, /* Novatel Gobi 2000 QDL device */ 78 | {USB_DEVICE(0x1410, 0xa013)}, /* Novatel Gobi 2000 QDL device */ 79 | {USB_DEVICE(0x1410, 0xa014)}, /* Novatel Gobi 2000 QDL device */ 80 | {USB_DEVICE(0x413c, 0x8185)}, /* Dell Gobi 2000 QDL device (N0218, VU936) */ 81 | {USB_DEVICE(0x413c, 0x8186)}, /* Dell Gobi 2000 Modem device (N0218, VU936) */ 82 | {USB_DEVICE(0x05c6, 0x9208)}, /* Generic Gobi 2000 QDL device */ 83 | {USB_DEVICE(0x05c6, 0x920b)}, /* Generic Gobi 2000 Modem device */ 84 | {USB_DEVICE(0x05c6, 0x9224)}, /* Sony Gobi 2000 QDL device (N0279, VU730) */ 85 | {USB_DEVICE(0x05c6, 0x9225)}, /* Sony Gobi 2000 Modem device (N0279, VU730) */ 86 | {USB_DEVICE(0x05c6, 0x9244)}, /* Samsung Gobi 2000 QDL device (VL176) */ 87 | {USB_DEVICE(0x05c6, 0x9245)}, /* Samsung Gobi 2000 Modem device (VL176) */ 88 | {USB_DEVICE(0x03f0, 0x241d)}, /* HP Gobi 2000 QDL device (VP412) */ 89 | {USB_DEVICE(0x03f0, 0x251d)}, /* HP Gobi 2000 Modem device (VP412) */ 90 | {USB_DEVICE(0x05c6, 0x9214)}, /* Acer Gobi 2000 QDL device (VP413) */ 91 | /* {USB_DEVICE(0x05c6, 0x9215)}, /* Acer Gobi 2000 Modem device (VP413) */ 92 | {USB_DEVICE(0x05c6, 0x9264)}, /* Asus Gobi 2000 QDL device (VR305) */ 93 | {USB_DEVICE(0x05c6, 0x9265)}, /* Asus Gobi 2000 Modem device (VR305) */ 94 | {USB_DEVICE(0x05c6, 0x9234)}, /* Top Global Gobi 2000 QDL device (VR306) */ 95 | {USB_DEVICE(0x05c6, 0x9235)}, /* Top Global Gobi 2000 Modem device (VR306) */ 96 | {USB_DEVICE(0x05c6, 0x9274)}, /* iRex Technologies Gobi 2000 QDL device (VR307) */ 97 | {USB_DEVICE(0x05c6, 0x9275)}, /* iRex Technologies Gobi 2000 Modem device (VR307) */ 98 | {USB_DEVICE(0x1199, 0x9000)}, /* Sierra Wireless Gobi 2000 QDL device (VT773) */ 99 | {USB_DEVICE(0x1199, 0x9001)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 100 | {USB_DEVICE(0x1199, 0x9002)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 101 | {USB_DEVICE(0x1199, 0x9003)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 102 | {USB_DEVICE(0x1199, 0x9004)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 103 | {USB_DEVICE(0x1199, 0x9005)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 104 | {USB_DEVICE(0x1199, 0x9006)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 105 | {USB_DEVICE(0x1199, 0x9007)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 106 | {USB_DEVICE(0x1199, 0x9008)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 107 | {USB_DEVICE(0x1199, 0x9009)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 108 | {USB_DEVICE(0x1199, 0x900a)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */ 109 | {USB_DEVICE(0x1199, 0x9011)}, /* Sierra Wireless Gobi 2000 Modem device (MC8305) */ 110 | {USB_DEVICE(0x16d8, 0x8001)}, /* CMDTech Gobi 2000 QDL device (VU922) */ 111 | {USB_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */ 112 | {USB_DEVICE(0x05c6, 0x9204)}, /* Gobi 2000 QDL device */ 113 | {USB_DEVICE(0x05c6, 0x9205)}, /* Gobi 2000 Modem device */ 114 | 115 | /* Gobi 3000 devices */ 116 | {USB_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Gobi 3000 QDL */ 117 | {USB_DEVICE(0x05c6, 0x920c)}, /* Gobi 3000 QDL */ 118 | {USB_DEVICE(0x05c6, 0x920d)}, /* Gobi 3000 Composite */ 119 | {USB_DEVICE(0x1410, 0xa020)}, /* Novatel Gobi 3000 QDL */ 120 | {USB_DEVICE(0x1410, 0xa021)}, /* Novatel Gobi 3000 Composite */ 121 | {USB_DEVICE(0x413c, 0x8193)}, /* Dell Gobi 3000 QDL */ 122 | {USB_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */ 123 | {USB_DEVICE(0x413c, 0x81a6)}, /* Dell DW5570 QDL (MC8805) */ 124 | {USB_DEVICE(0x1199, 0x68a4)}, /* Sierra Wireless QDL */ 125 | {USB_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */ 126 | {USB_DEVICE(0x1199, 0x68a8)}, /* Sierra Wireless QDL */ 127 | {USB_DEVICE(0x1199, 0x68a9)}, /* Sierra Wireless Modem */ 128 | {USB_DEVICE(0x1199, 0x9010)}, /* Sierra Wireless Gobi 3000 QDL */ 129 | {USB_DEVICE(0x1199, 0x9012)}, /* Sierra Wireless Gobi 3000 QDL */ 130 | {USB_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */ 131 | {USB_DEVICE(0x1199, 0x9014)}, /* Sierra Wireless Gobi 3000 QDL */ 132 | {USB_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */ 133 | {USB_DEVICE(0x1199, 0x9018)}, /* Sierra Wireless Gobi 3000 QDL */ 134 | {USB_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */ 135 | {USB_DEVICE(0x1199, 0x901b)}, /* Sierra Wireless MC7770 */ 136 | {USB_DEVICE(0x12D1, 0x14F0)}, /* Sony Gobi 3000 QDL */ 137 | {USB_DEVICE(0x12D1, 0x14F1)}, /* Sony Gobi 3000 Composite */ 138 | {USB_DEVICE(0x0AF0, 0x8120)}, /* Option GTM681W */ 139 | 140 | /* non-Gobi Sierra Wireless devices */ 141 | {DEVICE_SWI(0x03f0, 0x4e1d)}, /* HP lt4111 LTE/EV-DO/HSPA+ Gobi 4G Module */ 142 | {DEVICE_SWI(0x0f3d, 0x68a2)}, /* Sierra Wireless MC7700 */ 143 | {DEVICE_SWI(0x114f, 0x68a2)}, /* Sierra Wireless MC7750 */ 144 | {DEVICE_SWI(0x1199, 0x68a2)}, /* Sierra Wireless MC7710 */ 145 | {DEVICE_SWI(0x1199, 0x68c0)}, /* Sierra Wireless MC7304/MC7354 */ 146 | {DEVICE_SWI(0x1199, 0x901c)}, /* Sierra Wireless EM7700 */ 147 | {DEVICE_SWI(0x1199, 0x901e)}, /* Sierra Wireless EM7355 QDL */ 148 | {DEVICE_SWI(0x1199, 0x901f)}, /* Sierra Wireless EM7355 */ 149 | {DEVICE_SWI(0x1199, 0x9040)}, /* Sierra Wireless Modem */ 150 | {DEVICE_SWI(0x1199, 0x9041)}, /* Sierra Wireless MC7305/MC7355 */ 151 | {DEVICE_SWI(0x1199, 0x9051)}, /* Netgear AirCard 340U */ 152 | {DEVICE_SWI(0x1199, 0x9053)}, /* Sierra Wireless Modem */ 153 | {DEVICE_SWI(0x1199, 0x9054)}, /* Sierra Wireless Modem */ 154 | {DEVICE_SWI(0x1199, 0x9055)}, /* Netgear AirCard 341U */ 155 | {DEVICE_SWI(0x1199, 0x9056)}, /* Sierra Wireless Modem */ 156 | {DEVICE_SWI(0x1199, 0x9060)}, /* Sierra Wireless Modem */ 157 | {DEVICE_SWI(0x1199, 0x9061)}, /* Sierra Wireless Modem */ 158 | {DEVICE_SWI(0x1199, 0x9063)}, /* Sierra Wireless EM7305 */ 159 | {DEVICE_SWI(0x1199, 0x9070)}, /* Sierra Wireless MC74xx */ 160 | {DEVICE_SWI(0x1199, 0x9071)}, /* Sierra Wireless MC74xx */ 161 | {DEVICE_SWI(0x1199, 0x9078)}, /* Sierra Wireless EM74xx */ 162 | {DEVICE_SWI(0x1199, 0x9079)}, /* Sierra Wireless EM74xx */ 163 | {DEVICE_SWI(0x1199, 0x907a)}, /* Sierra Wireless EM74xx QDL */ 164 | {DEVICE_SWI(0x1199, 0x907b)}, /* Sierra Wireless EM74xx */ 165 | {DEVICE_SWI(0x1199, 0x9090)}, /* Sierra Wireless EM7565 QDL */ 166 | {DEVICE_SWI(0x1199, 0x9091)}, /* Sierra Wireless EM7565 */ 167 | {DEVICE_SWI(0x413c, 0x81a2)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */ 168 | {DEVICE_SWI(0x413c, 0x81a3)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */ 169 | {DEVICE_SWI(0x413c, 0x81a4)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */ 170 | {DEVICE_SWI(0x413c, 0x81a8)}, /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card */ 171 | {DEVICE_SWI(0x413c, 0x81a9)}, /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */ 172 | {DEVICE_SWI(0x413c, 0x81b1)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card */ 173 | {DEVICE_SWI(0x413c, 0x81b3)}, /* Dell Wireless 5809e Gobi(TM) 4G LTE Mobile Broadband Card (rev3) */ 174 | {DEVICE_SWI(0x413c, 0x81b5)}, /* Dell Wireless 5811e QDL */ 175 | {DEVICE_SWI(0x413c, 0x81b6)}, /* Dell Wireless 5811e QDL */ 176 | {DEVICE_SWI(0x413c, 0x81cf)}, /* Dell Wireless 5819 */ 177 | {DEVICE_SWI(0x413c, 0x81d0)}, /* Dell Wireless 5819 */ 178 | {DEVICE_SWI(0x413c, 0x81d1)}, /* Dell Wireless 5818 */ 179 | {DEVICE_SWI(0x413c, 0x81d2)}, /* Dell Wireless 5818 */ 180 | 181 | /* Huawei devices */ 182 | {DEVICE_HWI(0x03f0, 0x581d)}, /* HP lt4112 LTE/HSPA+ Gobi 4G Modem (Huawei me906e) */ 183 | 184 | { } /* Terminating entry */ 185 | }; 186 | MODULE_DEVICE_TABLE(usb, id_table); 187 | 188 | static int handle_quectel_ec20(struct device *dev, int ifnum) 189 | { 190 | int altsetting = 0; 191 | 192 | /* 193 | * Quectel EC20 Mini PCIe LTE module layout: 194 | * 0: DM/DIAG (use libqcdm from ModemManager for communication) 195 | * 1: NMEA 196 | * 2: AT-capable modem port 197 | * 3: Modem interface 198 | * 4: NDIS 199 | */ 200 | switch (ifnum) { 201 | case 0: 202 | dev_dbg(dev, "Quectel EC20 DM/DIAG interface found\n"); 203 | break; 204 | case 1: 205 | dev_dbg(dev, "Quectel EC20 NMEA GPS interface found\n"); 206 | break; 207 | case 2: 208 | case 3: 209 | dev_dbg(dev, "Quectel EC20 Modem port found\n"); 210 | break; 211 | case 4: 212 | /* Don't claim the QMI/net interface */ 213 | altsetting = -1; 214 | break; 215 | } 216 | 217 | return altsetting; 218 | } 219 | 220 | static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id) 221 | { 222 | struct usb_host_interface *intf = serial->interface->cur_altsetting; 223 | struct device *dev = &serial->dev->dev; 224 | int retval = -ENODEV; 225 | __u8 nintf; 226 | __u8 ifnum; 227 | int altsetting = -1; 228 | bool sendsetup = false; 229 | 230 | /* we only support vendor specific functions */ 231 | if (intf->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC) 232 | goto done; 233 | 234 | nintf = serial->dev->actconfig->desc.bNumInterfaces; 235 | dev_dbg(dev, "Num Interfaces = %d\n", nintf); 236 | ifnum = intf->desc.bInterfaceNumber; 237 | dev_dbg(dev, "This Interface = %d\n", ifnum); 238 | 239 | if (nintf == 1) { 240 | /* QDL mode */ 241 | /* Gobi 2000 has a single altsetting, older ones have two */ 242 | if (serial->interface->num_altsetting == 2) 243 | intf = &serial->interface->altsetting[1]; 244 | else if (serial->interface->num_altsetting > 2) 245 | goto done; 246 | 247 | if (intf->desc.bNumEndpoints == 2 && 248 | usb_endpoint_is_bulk_in(&intf->endpoint[0].desc) && 249 | usb_endpoint_is_bulk_out(&intf->endpoint[1].desc)) { 250 | dev_dbg(dev, "QDL port found\n"); 251 | 252 | if (serial->interface->num_altsetting == 1) 253 | retval = 0; /* Success */ 254 | else 255 | altsetting = 1; 256 | } 257 | goto done; 258 | 259 | } 260 | 261 | /* default to enabling interface */ 262 | altsetting = 0; 263 | 264 | /* 265 | * Composite mode; don't bind to the QMI/net interface as that 266 | * gets handled by other drivers. 267 | */ 268 | 269 | switch (id->driver_info) { 270 | case QCSERIAL_G1K: 271 | /* 272 | * Gobi 1K USB layout: 273 | * 0: DM/DIAG (use libqcdm from ModemManager for communication) 274 | * 1: serial port (doesn't respond) 275 | * 2: AT-capable modem port 276 | * 3: QMI/net 277 | */ 278 | if (nintf < 3 || nintf > 4) { 279 | dev_err(dev, "unknown number of interfaces: %d\n", nintf); 280 | altsetting = -1; 281 | goto done; 282 | } 283 | 284 | if (ifnum == 0) { 285 | dev_dbg(dev, "Gobi 1K DM/DIAG interface found\n"); 286 | altsetting = 1; 287 | } else if (ifnum == 2) 288 | dev_dbg(dev, "Modem port found\n"); 289 | else 290 | altsetting = -1; 291 | break; 292 | case QCSERIAL_G2K: 293 | /* handle non-standard layouts */ 294 | if (nintf == 5 && id->idProduct == QUECTEL_EC20_PID) { 295 | altsetting = handle_quectel_ec20(dev, ifnum); 296 | goto done; 297 | } 298 | 299 | /* 300 | * Gobi 2K+ USB layout: 301 | * 0: QMI/net 302 | * 1: DM/DIAG (use libqcdm from ModemManager for communication) 303 | * 2: AT-capable modem port 304 | * 3: NMEA 305 | */ 306 | if (nintf < 3 || nintf > 4) { 307 | dev_err(dev, "unknown number of interfaces: %d\n", nintf); 308 | altsetting = -1; 309 | goto done; 310 | } 311 | 312 | switch (ifnum) { 313 | case 0: 314 | /* Don't claim the QMI/net interface */ 315 | altsetting = -1; 316 | break; 317 | case 1: 318 | dev_dbg(dev, "Gobi 2K+ DM/DIAG interface found\n"); 319 | break; 320 | case 2: 321 | dev_dbg(dev, "Modem port found\n"); 322 | break; 323 | case 3: 324 | /* 325 | * NMEA (serial line 9600 8N1) 326 | * # echo "\$GPS_START" > /dev/ttyUSBx 327 | * # echo "\$GPS_STOP" > /dev/ttyUSBx 328 | */ 329 | dev_dbg(dev, "Gobi 2K+ NMEA GPS interface found\n"); 330 | break; 331 | } 332 | break; 333 | case QCSERIAL_SWI: 334 | /* 335 | * Sierra Wireless layout: 336 | * 0: DM/DIAG (use libqcdm from ModemManager for communication) 337 | * 2: NMEA 338 | * 3: AT-capable modem port 339 | * 8: QMI/net 340 | */ 341 | switch (ifnum) { 342 | case 0: 343 | dev_dbg(dev, "DM/DIAG interface found\n"); 344 | break; 345 | case 2: 346 | dev_dbg(dev, "NMEA GPS interface found\n"); 347 | sendsetup = true; 348 | break; 349 | case 3: 350 | dev_dbg(dev, "Modem port found\n"); 351 | sendsetup = true; 352 | break; 353 | default: 354 | /* don't claim any unsupported interface */ 355 | altsetting = -1; 356 | break; 357 | } 358 | break; 359 | case QCSERIAL_HWI: 360 | /* 361 | * Huawei devices map functions by subclass + protocol 362 | * instead of interface numbers. The protocol identify 363 | * a specific function, while the subclass indicate a 364 | * specific firmware source 365 | * 366 | * This is a blacklist of functions known to be 367 | * non-serial. The rest are assumed to be serial and 368 | * will be handled by this driver 369 | */ 370 | switch (intf->desc.bInterfaceProtocol) { 371 | /* QMI combined (qmi_wwan) */ 372 | case 0x07: 373 | case 0x37: 374 | case 0x67: 375 | /* QMI data (qmi_wwan) */ 376 | case 0x08: 377 | case 0x38: 378 | case 0x68: 379 | /* QMI control (qmi_wwan) */ 380 | case 0x09: 381 | case 0x39: 382 | case 0x69: 383 | /* NCM like (huawei_cdc_ncm) */ 384 | case 0x16: 385 | case 0x46: 386 | case 0x76: 387 | altsetting = -1; 388 | break; 389 | default: 390 | dev_dbg(dev, "Huawei type serial port found (%02x/%02x/%02x)\n", 391 | intf->desc.bInterfaceClass, 392 | intf->desc.bInterfaceSubClass, 393 | intf->desc.bInterfaceProtocol); 394 | } 395 | break; 396 | default: 397 | dev_err(dev, "unsupported device layout type: %lu\n", 398 | id->driver_info); 399 | break; 400 | } 401 | 402 | done: 403 | if (altsetting >= 0) { 404 | retval = usb_set_interface(serial->dev, ifnum, altsetting); 405 | if (retval < 0) { 406 | dev_err(dev, 407 | "Could not set interface, error %d\n", 408 | retval); 409 | retval = -ENODEV; 410 | } 411 | } 412 | 413 | if (!retval) 414 | usb_set_serial_data(serial, (void *)(unsigned long)sendsetup); 415 | 416 | return retval; 417 | } 418 | 419 | static int qc_attach(struct usb_serial *serial) 420 | { 421 | struct usb_wwan_intf_private *data; 422 | bool sendsetup; 423 | 424 | data = kzalloc(sizeof(*data), GFP_KERNEL); 425 | if (!data) 426 | return -ENOMEM; 427 | 428 | sendsetup = !!(unsigned long)(usb_get_serial_data(serial)); 429 | if (sendsetup) 430 | data->use_send_setup = 1; 431 | 432 | spin_lock_init(&data->susp_lock); 433 | 434 | usb_set_serial_data(serial, data); 435 | 436 | return 0; 437 | } 438 | 439 | static void qc_release(struct usb_serial *serial) 440 | { 441 | struct usb_wwan_intf_private *priv = usb_get_serial_data(serial); 442 | 443 | usb_set_serial_data(serial, NULL); 444 | kfree(priv); 445 | } 446 | 447 | static struct usb_serial_driver qcdevice = { 448 | .driver = { 449 | .owner = THIS_MODULE, 450 | .name = "qcserial", 451 | }, 452 | .description = "Qualcomm USB modem", 453 | .id_table = id_table, 454 | .num_ports = 1, 455 | .probe = qcprobe, 456 | .open = usb_wwan_open, 457 | .close = usb_wwan_close, 458 | .dtr_rts = usb_wwan_dtr_rts, 459 | .write = usb_wwan_write, 460 | .write_room = usb_wwan_write_room, 461 | .chars_in_buffer = usb_wwan_chars_in_buffer, 462 | .tiocmget = usb_wwan_tiocmget, 463 | .tiocmset = usb_wwan_tiocmset, 464 | .attach = qc_attach, 465 | .release = qc_release, 466 | .port_probe = usb_wwan_port_probe, 467 | .port_remove = usb_wwan_port_remove, 468 | #ifdef CONFIG_PM 469 | .suspend = usb_wwan_suspend, 470 | .resume = usb_wwan_resume, 471 | #endif 472 | }; 473 | 474 | static struct usb_serial_driver * const serial_drivers[] = { 475 | &qcdevice, NULL 476 | }; 477 | 478 | module_usb_serial_driver(serial_drivers, id_table); 479 | 480 | MODULE_AUTHOR(DRIVER_AUTHOR); 481 | MODULE_DESCRIPTION(DRIVER_DESC); 482 | MODULE_LICENSE("GPL v2"); 483 | -------------------------------------------------------------------------------- /drivers/usb/serial/usb-wwan.h: -------------------------------------------------------------------------------- 1 | /* SPDX-License-Identifier: GPL-2.0 */ 2 | /* 3 | * Definitions for USB serial mobile broadband cards 4 | */ 5 | 6 | #ifndef __LINUX_USB_USB_WWAN 7 | #define __LINUX_USB_USB_WWAN 8 | 9 | extern void usb_wwan_dtr_rts(struct usb_serial_port *port, int on); 10 | extern int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port); 11 | extern void usb_wwan_close(struct usb_serial_port *port); 12 | extern int usb_wwan_port_probe(struct usb_serial_port *port); 13 | extern int usb_wwan_port_remove(struct usb_serial_port *port); 14 | extern int usb_wwan_write_room(struct tty_struct *tty); 15 | extern int usb_wwan_tiocmget(struct tty_struct *tty); 16 | extern int usb_wwan_tiocmset(struct tty_struct *tty, 17 | unsigned int set, unsigned int clear); 18 | extern int usb_wwan_ioctl(struct tty_struct *tty, 19 | unsigned int cmd, unsigned long arg); 20 | extern int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port, 21 | const unsigned char *buf, int count); 22 | extern int usb_wwan_chars_in_buffer(struct tty_struct *tty); 23 | #ifdef CONFIG_PM 24 | extern int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message); 25 | extern int usb_wwan_resume(struct usb_serial *serial); 26 | #endif 27 | 28 | /* per port private data */ 29 | 30 | #define N_IN_URB 4 31 | #define N_OUT_URB 4 32 | #define IN_BUFLEN 4096 33 | #define OUT_BUFLEN 4096 34 | 35 | struct usb_wwan_intf_private { 36 | spinlock_t susp_lock; 37 | unsigned int suspended:1; 38 | unsigned int use_send_setup:1; 39 | int in_flight; 40 | unsigned int open_ports; 41 | void *private; 42 | }; 43 | 44 | struct usb_wwan_port_private { 45 | /* Input endpoints and buffer for this port */ 46 | struct urb *in_urbs[N_IN_URB]; 47 | u8 *in_buffer[N_IN_URB]; 48 | /* Output endpoints and buffer for this port */ 49 | struct urb *out_urbs[N_OUT_URB]; 50 | u8 *out_buffer[N_OUT_URB]; 51 | unsigned long out_busy; /* Bit vector of URBs in use */ 52 | struct usb_anchor delayed; 53 | 54 | /* Settings for the port */ 55 | int rts_state; /* Handshaking pins (outputs) */ 56 | int dtr_state; 57 | int cts_state; /* Handshaking pins (inputs) */ 58 | int dsr_state; 59 | int dcd_state; 60 | int ri_state; 61 | 62 | unsigned long tx_start_time[N_OUT_URB]; 63 | }; 64 | 65 | #endif /* __LINUX_USB_USB_WWAN */ 66 | -------------------------------------------------------------------------------- /drivers/usb/serial/usb_wwan.c: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-2.0 2 | /* 3 | USB Driver layer for GSM modems 4 | 5 | Copyright (C) 2005 Matthias Urlichs 6 | 7 | Portions copied from the Keyspan driver by Hugh Blemings 8 | 9 | History: see the git log. 10 | 11 | Work sponsored by: Sigos GmbH, Germany 12 | 13 | This driver exists because the "normal" serial driver doesn't work too well 14 | with GSM modems. Issues: 15 | - data loss -- one single Receive URB is not nearly enough 16 | - controlling the baud rate doesn't make sense 17 | */ 18 | 19 | #define DRIVER_AUTHOR "Matthias Urlichs " 20 | #define DRIVER_DESC "USB Driver for GSM modems" 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include "usb-wwan.h" 35 | 36 | /* 37 | * Generate DTR/RTS signals on the port using the SET_CONTROL_LINE_STATE request 38 | * in CDC ACM. 39 | */ 40 | static int usb_wwan_send_setup(struct usb_serial_port *port) 41 | { 42 | struct usb_serial *serial = port->serial; 43 | struct usb_wwan_port_private *portdata; 44 | int val = 0; 45 | int ifnum; 46 | int res; 47 | 48 | portdata = usb_get_serial_port_data(port); 49 | 50 | if (portdata->dtr_state) 51 | val |= 0x01; 52 | if (portdata->rts_state) 53 | val |= 0x02; 54 | 55 | ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; 56 | 57 | res = usb_autopm_get_interface(serial->interface); 58 | if (res) 59 | return res; 60 | 61 | res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 62 | 0x22, 0x21, val, ifnum, NULL, 0, 63 | USB_CTRL_SET_TIMEOUT); 64 | 65 | usb_autopm_put_interface(port->serial->interface); 66 | 67 | return res; 68 | } 69 | 70 | void usb_wwan_dtr_rts(struct usb_serial_port *port, int on) 71 | { 72 | struct usb_wwan_port_private *portdata; 73 | struct usb_wwan_intf_private *intfdata; 74 | 75 | intfdata = usb_get_serial_data(port->serial); 76 | 77 | if (!intfdata->use_send_setup) 78 | return; 79 | 80 | portdata = usb_get_serial_port_data(port); 81 | /* FIXME: locking */ 82 | portdata->rts_state = on; 83 | portdata->dtr_state = on; 84 | 85 | usb_wwan_send_setup(port); 86 | } 87 | EXPORT_SYMBOL(usb_wwan_dtr_rts); 88 | 89 | int usb_wwan_tiocmget(struct tty_struct *tty) 90 | { 91 | struct usb_serial_port *port = tty->driver_data; 92 | unsigned int value; 93 | struct usb_wwan_port_private *portdata; 94 | 95 | portdata = usb_get_serial_port_data(port); 96 | 97 | value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 98 | ((portdata->dtr_state) ? TIOCM_DTR : 0) | 99 | ((portdata->cts_state) ? TIOCM_CTS : 0) | 100 | ((portdata->dsr_state) ? TIOCM_DSR : 0) | 101 | ((portdata->dcd_state) ? TIOCM_CAR : 0) | 102 | ((portdata->ri_state) ? TIOCM_RNG : 0); 103 | 104 | return value; 105 | } 106 | EXPORT_SYMBOL(usb_wwan_tiocmget); 107 | 108 | int usb_wwan_tiocmset(struct tty_struct *tty, 109 | unsigned int set, unsigned int clear) 110 | { 111 | struct usb_serial_port *port = tty->driver_data; 112 | struct usb_wwan_port_private *portdata; 113 | struct usb_wwan_intf_private *intfdata; 114 | 115 | portdata = usb_get_serial_port_data(port); 116 | intfdata = usb_get_serial_data(port->serial); 117 | 118 | if (!intfdata->use_send_setup) 119 | return -EINVAL; 120 | 121 | /* FIXME: what locks portdata fields ? */ 122 | if (set & TIOCM_RTS) 123 | portdata->rts_state = 1; 124 | if (set & TIOCM_DTR) 125 | portdata->dtr_state = 1; 126 | 127 | if (clear & TIOCM_RTS) 128 | portdata->rts_state = 0; 129 | if (clear & TIOCM_DTR) 130 | portdata->dtr_state = 0; 131 | return usb_wwan_send_setup(port); 132 | } 133 | EXPORT_SYMBOL(usb_wwan_tiocmset); 134 | 135 | static int get_serial_info(struct usb_serial_port *port, 136 | struct serial_struct __user *retinfo) 137 | { 138 | struct serial_struct tmp; 139 | 140 | memset(&tmp, 0, sizeof(tmp)); 141 | tmp.line = port->minor; 142 | tmp.port = port->port_number; 143 | tmp.baud_base = tty_get_baud_rate(port->port.tty); 144 | tmp.close_delay = port->port.close_delay / 10; 145 | tmp.closing_wait = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 146 | ASYNC_CLOSING_WAIT_NONE : 147 | port->port.closing_wait / 10; 148 | 149 | if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 150 | return -EFAULT; 151 | return 0; 152 | } 153 | 154 | static int set_serial_info(struct usb_serial_port *port, 155 | struct serial_struct __user *newinfo) 156 | { 157 | struct serial_struct new_serial; 158 | unsigned int closing_wait, close_delay; 159 | int retval = 0; 160 | 161 | if (copy_from_user(&new_serial, newinfo, sizeof(new_serial))) 162 | return -EFAULT; 163 | 164 | close_delay = new_serial.close_delay * 10; 165 | closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 166 | ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10; 167 | 168 | mutex_lock(&port->port.mutex); 169 | 170 | if (!capable(CAP_SYS_ADMIN)) { 171 | if ((close_delay != port->port.close_delay) || 172 | (closing_wait != port->port.closing_wait)) 173 | retval = -EPERM; 174 | else 175 | retval = -EOPNOTSUPP; 176 | } else { 177 | port->port.close_delay = close_delay; 178 | port->port.closing_wait = closing_wait; 179 | } 180 | 181 | mutex_unlock(&port->port.mutex); 182 | return retval; 183 | } 184 | 185 | int usb_wwan_ioctl(struct tty_struct *tty, 186 | unsigned int cmd, unsigned long arg) 187 | { 188 | struct usb_serial_port *port = tty->driver_data; 189 | 190 | dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd); 191 | 192 | switch (cmd) { 193 | case TIOCGSERIAL: 194 | return get_serial_info(port, 195 | (struct serial_struct __user *) arg); 196 | case TIOCSSERIAL: 197 | return set_serial_info(port, 198 | (struct serial_struct __user *) arg); 199 | default: 200 | break; 201 | } 202 | 203 | dev_dbg(&port->dev, "%s arg not supported\n", __func__); 204 | 205 | return -ENOIOCTLCMD; 206 | } 207 | EXPORT_SYMBOL(usb_wwan_ioctl); 208 | 209 | int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port, 210 | const unsigned char *buf, int count) 211 | { 212 | struct usb_wwan_port_private *portdata; 213 | struct usb_wwan_intf_private *intfdata; 214 | int i; 215 | int left, todo; 216 | struct urb *this_urb = NULL; /* spurious */ 217 | int err; 218 | unsigned long flags; 219 | 220 | portdata = usb_get_serial_port_data(port); 221 | intfdata = usb_get_serial_data(port->serial); 222 | 223 | dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count); 224 | 225 | i = 0; 226 | left = count; 227 | for (i = 0; left > 0 && i < N_OUT_URB; i++) { 228 | todo = left; 229 | if (todo > OUT_BUFLEN) 230 | todo = OUT_BUFLEN; 231 | 232 | this_urb = portdata->out_urbs[i]; 233 | if (test_and_set_bit(i, &portdata->out_busy)) { 234 | if (time_before(jiffies, 235 | portdata->tx_start_time[i] + 10 * HZ)) 236 | continue; 237 | usb_unlink_urb(this_urb); 238 | continue; 239 | } 240 | dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__, 241 | usb_pipeendpoint(this_urb->pipe), i); 242 | 243 | err = usb_autopm_get_interface_async(port->serial->interface); 244 | if (err < 0) { 245 | clear_bit(i, &portdata->out_busy); 246 | break; 247 | } 248 | 249 | /* send the data */ 250 | memcpy(this_urb->transfer_buffer, buf, todo); 251 | this_urb->transfer_buffer_length = todo; 252 | 253 | spin_lock_irqsave(&intfdata->susp_lock, flags); 254 | if (intfdata->suspended) { 255 | usb_anchor_urb(this_urb, &portdata->delayed); 256 | spin_unlock_irqrestore(&intfdata->susp_lock, flags); 257 | } else { 258 | intfdata->in_flight++; 259 | spin_unlock_irqrestore(&intfdata->susp_lock, flags); 260 | err = usb_submit_urb(this_urb, GFP_ATOMIC); 261 | if (err) { 262 | dev_err(&port->dev, 263 | "%s: submit urb %d failed: %d\n", 264 | __func__, i, err); 265 | clear_bit(i, &portdata->out_busy); 266 | spin_lock_irqsave(&intfdata->susp_lock, flags); 267 | intfdata->in_flight--; 268 | spin_unlock_irqrestore(&intfdata->susp_lock, 269 | flags); 270 | usb_autopm_put_interface_async(port->serial->interface); 271 | break; 272 | } 273 | } 274 | 275 | portdata->tx_start_time[i] = jiffies; 276 | buf += todo; 277 | left -= todo; 278 | } 279 | 280 | count -= left; 281 | dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count); 282 | return count; 283 | } 284 | EXPORT_SYMBOL(usb_wwan_write); 285 | 286 | static void usb_wwan_indat_callback(struct urb *urb) 287 | { 288 | int err; 289 | int endpoint; 290 | struct usb_serial_port *port; 291 | struct device *dev; 292 | unsigned char *data = urb->transfer_buffer; 293 | int status = urb->status; 294 | 295 | endpoint = usb_pipeendpoint(urb->pipe); 296 | port = urb->context; 297 | dev = &port->dev; 298 | 299 | if (status) { 300 | dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n", 301 | __func__, status, endpoint); 302 | } else { 303 | if (urb->actual_length) { 304 | tty_insert_flip_string(&port->port, data, 305 | urb->actual_length); 306 | tty_flip_buffer_push(&port->port); 307 | } else 308 | dev_dbg(dev, "%s: empty read urb received\n", __func__); 309 | } 310 | /* Resubmit urb so we continue receiving */ 311 | err = usb_submit_urb(urb, GFP_ATOMIC); 312 | if (err) { 313 | if (err != -EPERM && err != -ENODEV) { 314 | dev_err(dev, "%s: resubmit read urb failed. (%d)\n", 315 | __func__, err); 316 | /* busy also in error unless we are killed */ 317 | usb_mark_last_busy(port->serial->dev); 318 | } 319 | } else { 320 | usb_mark_last_busy(port->serial->dev); 321 | } 322 | } 323 | 324 | static void usb_wwan_outdat_callback(struct urb *urb) 325 | { 326 | struct usb_serial_port *port; 327 | struct usb_wwan_port_private *portdata; 328 | struct usb_wwan_intf_private *intfdata; 329 | int i; 330 | 331 | port = urb->context; 332 | intfdata = usb_get_serial_data(port->serial); 333 | 334 | usb_serial_port_softint(port); 335 | usb_autopm_put_interface_async(port->serial->interface); 336 | portdata = usb_get_serial_port_data(port); 337 | spin_lock(&intfdata->susp_lock); 338 | intfdata->in_flight--; 339 | spin_unlock(&intfdata->susp_lock); 340 | 341 | for (i = 0; i < N_OUT_URB; ++i) { 342 | if (portdata->out_urbs[i] == urb) { 343 | smp_mb__before_atomic(); 344 | clear_bit(i, &portdata->out_busy); 345 | break; 346 | } 347 | } 348 | } 349 | 350 | int usb_wwan_write_room(struct tty_struct *tty) 351 | { 352 | struct usb_serial_port *port = tty->driver_data; 353 | struct usb_wwan_port_private *portdata; 354 | int i; 355 | int data_len = 0; 356 | struct urb *this_urb; 357 | 358 | portdata = usb_get_serial_port_data(port); 359 | 360 | for (i = 0; i < N_OUT_URB; i++) { 361 | this_urb = portdata->out_urbs[i]; 362 | if (this_urb && !test_bit(i, &portdata->out_busy)) 363 | data_len += OUT_BUFLEN; 364 | } 365 | 366 | dev_dbg(&port->dev, "%s: %d\n", __func__, data_len); 367 | return data_len; 368 | } 369 | EXPORT_SYMBOL(usb_wwan_write_room); 370 | 371 | int usb_wwan_chars_in_buffer(struct tty_struct *tty) 372 | { 373 | struct usb_serial_port *port = tty->driver_data; 374 | struct usb_wwan_port_private *portdata; 375 | int i; 376 | int data_len = 0; 377 | struct urb *this_urb; 378 | 379 | portdata = usb_get_serial_port_data(port); 380 | 381 | for (i = 0; i < N_OUT_URB; i++) { 382 | this_urb = portdata->out_urbs[i]; 383 | /* FIXME: This locking is insufficient as this_urb may 384 | go unused during the test */ 385 | if (this_urb && test_bit(i, &portdata->out_busy)) 386 | data_len += this_urb->transfer_buffer_length; 387 | } 388 | dev_dbg(&port->dev, "%s: %d\n", __func__, data_len); 389 | return data_len; 390 | } 391 | EXPORT_SYMBOL(usb_wwan_chars_in_buffer); 392 | 393 | int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port) 394 | { 395 | struct usb_wwan_port_private *portdata; 396 | struct usb_wwan_intf_private *intfdata; 397 | struct usb_serial *serial = port->serial; 398 | int i, err; 399 | struct urb *urb; 400 | 401 | portdata = usb_get_serial_port_data(port); 402 | intfdata = usb_get_serial_data(serial); 403 | 404 | if (port->interrupt_in_urb) { 405 | err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 406 | if (err) { 407 | dev_err(&port->dev, "%s: submit int urb failed: %d\n", 408 | __func__, err); 409 | } 410 | } 411 | 412 | /* Start reading from the IN endpoint */ 413 | for (i = 0; i < N_IN_URB; i++) { 414 | urb = portdata->in_urbs[i]; 415 | if (!urb) 416 | continue; 417 | err = usb_submit_urb(urb, GFP_KERNEL); 418 | if (err) { 419 | dev_err(&port->dev, 420 | "%s: submit read urb %d failed: %d\n", 421 | __func__, i, err); 422 | } 423 | } 424 | 425 | spin_lock_irq(&intfdata->susp_lock); 426 | if (++intfdata->open_ports == 1) 427 | serial->interface->needs_remote_wakeup = 1; 428 | spin_unlock_irq(&intfdata->susp_lock); 429 | /* this balances a get in the generic USB serial code */ 430 | usb_autopm_put_interface(serial->interface); 431 | 432 | return 0; 433 | } 434 | EXPORT_SYMBOL(usb_wwan_open); 435 | 436 | static void unbusy_queued_urb(struct urb *urb, 437 | struct usb_wwan_port_private *portdata) 438 | { 439 | int i; 440 | 441 | for (i = 0; i < N_OUT_URB; i++) { 442 | if (urb == portdata->out_urbs[i]) { 443 | clear_bit(i, &portdata->out_busy); 444 | break; 445 | } 446 | } 447 | } 448 | 449 | void usb_wwan_close(struct usb_serial_port *port) 450 | { 451 | int i; 452 | struct usb_serial *serial = port->serial; 453 | struct usb_wwan_port_private *portdata; 454 | struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 455 | struct urb *urb; 456 | 457 | portdata = usb_get_serial_port_data(port); 458 | 459 | /* 460 | * Need to take susp_lock to make sure port is not already being 461 | * resumed, but no need to hold it due to initialized 462 | */ 463 | spin_lock_irq(&intfdata->susp_lock); 464 | if (--intfdata->open_ports == 0) 465 | serial->interface->needs_remote_wakeup = 0; 466 | spin_unlock_irq(&intfdata->susp_lock); 467 | 468 | for (;;) { 469 | urb = usb_get_from_anchor(&portdata->delayed); 470 | if (!urb) 471 | break; 472 | unbusy_queued_urb(urb, portdata); 473 | usb_autopm_put_interface_async(serial->interface); 474 | } 475 | 476 | for (i = 0; i < N_IN_URB; i++) 477 | usb_kill_urb(portdata->in_urbs[i]); 478 | for (i = 0; i < N_OUT_URB; i++) 479 | usb_kill_urb(portdata->out_urbs[i]); 480 | usb_kill_urb(port->interrupt_in_urb); 481 | 482 | usb_autopm_get_interface_no_resume(serial->interface); 483 | } 484 | EXPORT_SYMBOL(usb_wwan_close); 485 | 486 | static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port, 487 | int endpoint, 488 | int dir, void *ctx, char *buf, int len, 489 | void (*callback) (struct urb *)) 490 | { 491 | struct usb_serial *serial = port->serial; 492 | struct urb *urb; 493 | 494 | urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 495 | if (!urb) 496 | return NULL; 497 | 498 | usb_fill_bulk_urb(urb, serial->dev, 499 | usb_sndbulkpipe(serial->dev, endpoint) | dir, 500 | buf, len, callback, ctx); 501 | 502 | #if 1 //Added by Quectel for zero packet 503 | if (dir == USB_DIR_OUT) { 504 | struct usb_device_descriptor *desc = &serial->dev->descriptor; 505 | if (desc->idVendor == cpu_to_le16(0x05C6) && desc->idProduct == cpu_to_le16(0x9090)) 506 | urb->transfer_flags |= URB_ZERO_PACKET; 507 | if (desc->idVendor == cpu_to_le16(0x05C6) && desc->idProduct == cpu_to_le16(0x9003)) 508 | urb->transfer_flags |= URB_ZERO_PACKET; 509 | if (desc->idVendor == cpu_to_le16(0x05C6) && desc->idProduct == cpu_to_le16(0x9215)) 510 | urb->transfer_flags |= URB_ZERO_PACKET; 511 | if (desc->idVendor == cpu_to_le16(0x2C7C)) 512 | urb->transfer_flags |= URB_ZERO_PACKET; 513 | } 514 | #endif 515 | 516 | return urb; 517 | } 518 | 519 | int usb_wwan_port_probe(struct usb_serial_port *port) 520 | { 521 | struct usb_wwan_port_private *portdata; 522 | struct urb *urb; 523 | u8 *buffer; 524 | int i; 525 | 526 | if (!port->bulk_in_size || !port->bulk_out_size) 527 | return -ENODEV; 528 | 529 | portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 530 | if (!portdata) 531 | return -ENOMEM; 532 | 533 | init_usb_anchor(&portdata->delayed); 534 | 535 | for (i = 0; i < N_IN_URB; i++) { 536 | buffer = (u8 *)__get_free_page(GFP_KERNEL); 537 | if (!buffer) 538 | goto bail_out_error; 539 | portdata->in_buffer[i] = buffer; 540 | 541 | urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress, 542 | USB_DIR_IN, port, 543 | buffer, IN_BUFLEN, 544 | usb_wwan_indat_callback); 545 | portdata->in_urbs[i] = urb; 546 | } 547 | 548 | for (i = 0; i < N_OUT_URB; i++) { 549 | buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL); 550 | if (!buffer) 551 | goto bail_out_error2; 552 | portdata->out_buffer[i] = buffer; 553 | 554 | urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress, 555 | USB_DIR_OUT, port, 556 | buffer, OUT_BUFLEN, 557 | usb_wwan_outdat_callback); 558 | portdata->out_urbs[i] = urb; 559 | } 560 | 561 | usb_set_serial_port_data(port, portdata); 562 | 563 | return 0; 564 | 565 | bail_out_error2: 566 | for (i = 0; i < N_OUT_URB; i++) { 567 | usb_free_urb(portdata->out_urbs[i]); 568 | kfree(portdata->out_buffer[i]); 569 | } 570 | bail_out_error: 571 | for (i = 0; i < N_IN_URB; i++) { 572 | usb_free_urb(portdata->in_urbs[i]); 573 | free_page((unsigned long)portdata->in_buffer[i]); 574 | } 575 | kfree(portdata); 576 | 577 | return -ENOMEM; 578 | } 579 | EXPORT_SYMBOL_GPL(usb_wwan_port_probe); 580 | 581 | int usb_wwan_port_remove(struct usb_serial_port *port) 582 | { 583 | int i; 584 | struct usb_wwan_port_private *portdata; 585 | 586 | portdata = usb_get_serial_port_data(port); 587 | usb_set_serial_port_data(port, NULL); 588 | 589 | for (i = 0; i < N_IN_URB; i++) { 590 | usb_free_urb(portdata->in_urbs[i]); 591 | free_page((unsigned long)portdata->in_buffer[i]); 592 | } 593 | for (i = 0; i < N_OUT_URB; i++) { 594 | usb_free_urb(portdata->out_urbs[i]); 595 | kfree(portdata->out_buffer[i]); 596 | } 597 | 598 | kfree(portdata); 599 | 600 | return 0; 601 | } 602 | EXPORT_SYMBOL(usb_wwan_port_remove); 603 | 604 | #ifdef CONFIG_PM 605 | static void stop_urbs(struct usb_serial *serial) 606 | { 607 | int i, j; 608 | struct usb_serial_port *port; 609 | struct usb_wwan_port_private *portdata; 610 | 611 | for (i = 0; i < serial->num_ports; ++i) { 612 | port = serial->port[i]; 613 | portdata = usb_get_serial_port_data(port); 614 | if (!portdata) 615 | continue; 616 | for (j = 0; j < N_IN_URB; j++) 617 | usb_kill_urb(portdata->in_urbs[j]); 618 | for (j = 0; j < N_OUT_URB; j++) 619 | usb_kill_urb(portdata->out_urbs[j]); 620 | usb_kill_urb(port->interrupt_in_urb); 621 | } 622 | } 623 | 624 | int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message) 625 | { 626 | struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 627 | 628 | spin_lock_irq(&intfdata->susp_lock); 629 | if (PMSG_IS_AUTO(message)) { 630 | if (intfdata->in_flight) { 631 | spin_unlock_irq(&intfdata->susp_lock); 632 | return -EBUSY; 633 | } 634 | } 635 | intfdata->suspended = 1; 636 | spin_unlock_irq(&intfdata->susp_lock); 637 | 638 | stop_urbs(serial); 639 | 640 | return 0; 641 | } 642 | EXPORT_SYMBOL(usb_wwan_suspend); 643 | 644 | /* Caller must hold susp_lock. */ 645 | static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port) 646 | { 647 | struct usb_serial *serial = port->serial; 648 | struct usb_wwan_intf_private *data = usb_get_serial_data(serial); 649 | struct usb_wwan_port_private *portdata; 650 | struct urb *urb; 651 | int err_count = 0; 652 | int err; 653 | 654 | portdata = usb_get_serial_port_data(port); 655 | 656 | for (;;) { 657 | urb = usb_get_from_anchor(&portdata->delayed); 658 | if (!urb) 659 | break; 660 | 661 | err = usb_submit_urb(urb, GFP_ATOMIC); 662 | if (err) { 663 | dev_err(&port->dev, "%s: submit urb failed: %d\n", 664 | __func__, err); 665 | err_count++; 666 | unbusy_queued_urb(urb, portdata); 667 | usb_autopm_put_interface_async(serial->interface); 668 | continue; 669 | } 670 | data->in_flight++; 671 | } 672 | 673 | if (err_count) 674 | return -EIO; 675 | 676 | return 0; 677 | } 678 | 679 | int usb_wwan_resume(struct usb_serial *serial) 680 | { 681 | int i, j; 682 | struct usb_serial_port *port; 683 | struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 684 | struct usb_wwan_port_private *portdata; 685 | struct urb *urb; 686 | int err; 687 | int err_count = 0; 688 | 689 | spin_lock_irq(&intfdata->susp_lock); 690 | for (i = 0; i < serial->num_ports; i++) { 691 | port = serial->port[i]; 692 | 693 | if (!tty_port_initialized(&port->port)) 694 | continue; 695 | 696 | portdata = usb_get_serial_port_data(port); 697 | 698 | if (port->interrupt_in_urb) { 699 | err = usb_submit_urb(port->interrupt_in_urb, 700 | GFP_ATOMIC); 701 | if (err) { 702 | dev_err(&port->dev, 703 | "%s: submit int urb failed: %d\n", 704 | __func__, err); 705 | err_count++; 706 | } 707 | } 708 | 709 | err = usb_wwan_submit_delayed_urbs(port); 710 | if (err) 711 | err_count++; 712 | 713 | for (j = 0; j < N_IN_URB; j++) { 714 | urb = portdata->in_urbs[j]; 715 | err = usb_submit_urb(urb, GFP_ATOMIC); 716 | if (err < 0) { 717 | dev_err(&port->dev, 718 | "%s: submit read urb %d failed: %d\n", 719 | __func__, i, err); 720 | err_count++; 721 | } 722 | } 723 | } 724 | intfdata->suspended = 0; 725 | spin_unlock_irq(&intfdata->susp_lock); 726 | 727 | if (err_count) 728 | return -EIO; 729 | 730 | return 0; 731 | } 732 | EXPORT_SYMBOL(usb_wwan_resume); 733 | #endif 734 | 735 | MODULE_AUTHOR(DRIVER_AUTHOR); 736 | MODULE_DESCRIPTION(DRIVER_DESC); 737 | MODULE_LICENSE("GPL v2"); 738 | --------------------------------------------------------------------------------