David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 1 | /* |
| 2 | * CDC Ethernet based networking peripherals |
| 3 | * Copyright (C) 2003-2005 by David Brownell |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 4 | * Copyright (C) 2006 by Ole Andre Vadla Ravnas (ActiveSync) |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 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, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | */ |
| 20 | |
| 21 | // #define DEBUG // error path messages, extra info |
| 22 | // #define VERBOSE // more; success messages |
| 23 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 24 | #include <linux/module.h> |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 25 | #include <linux/init.h> |
| 26 | #include <linux/netdevice.h> |
| 27 | #include <linux/etherdevice.h> |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 28 | #include <linux/ethtool.h> |
| 29 | #include <linux/workqueue.h> |
| 30 | #include <linux/mii.h> |
| 31 | #include <linux/usb.h> |
David Brownell | a8c28f2 | 2006-06-13 09:57:47 -0700 | [diff] [blame] | 32 | #include <linux/usb/cdc.h> |
Jussi Kivilinna | 3692e94 | 2008-01-26 00:51:45 +0200 | [diff] [blame] | 33 | #include <linux/usb/usbnet.h> |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 34 | |
| 35 | |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 36 | #if defined(CONFIG_USB_NET_RNDIS_HOST) || defined(CONFIG_USB_NET_RNDIS_HOST_MODULE) |
| 37 | |
| 38 | static int is_rndis(struct usb_interface_descriptor *desc) |
| 39 | { |
Joe Perches | 8e95a20 | 2009-12-03 07:58:21 +0000 | [diff] [blame] | 40 | return (desc->bInterfaceClass == USB_CLASS_COMM && |
| 41 | desc->bInterfaceSubClass == 2 && |
| 42 | desc->bInterfaceProtocol == 0xff); |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 43 | } |
| 44 | |
| 45 | static int is_activesync(struct usb_interface_descriptor *desc) |
| 46 | { |
Joe Perches | 8e95a20 | 2009-12-03 07:58:21 +0000 | [diff] [blame] | 47 | return (desc->bInterfaceClass == USB_CLASS_MISC && |
| 48 | desc->bInterfaceSubClass == 1 && |
| 49 | desc->bInterfaceProtocol == 1); |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 50 | } |
| 51 | |
Thomas Backlund | 7e99eed | 2008-07-22 13:55:58 -0700 | [diff] [blame] | 52 | static int is_wireless_rndis(struct usb_interface_descriptor *desc) |
| 53 | { |
Joe Perches | 8e95a20 | 2009-12-03 07:58:21 +0000 | [diff] [blame] | 54 | return (desc->bInterfaceClass == USB_CLASS_WIRELESS_CONTROLLER && |
| 55 | desc->bInterfaceSubClass == 1 && |
| 56 | desc->bInterfaceProtocol == 3); |
Thomas Backlund | 7e99eed | 2008-07-22 13:55:58 -0700 | [diff] [blame] | 57 | } |
| 58 | |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 59 | #else |
| 60 | |
| 61 | #define is_rndis(desc) 0 |
| 62 | #define is_activesync(desc) 0 |
Thomas Backlund | 7e99eed | 2008-07-22 13:55:58 -0700 | [diff] [blame] | 63 | #define is_wireless_rndis(desc) 0 |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 64 | |
| 65 | #endif |
| 66 | |
Jonas Sjöquist | 2185126 | 2010-04-23 01:07:45 +0000 | [diff] [blame] | 67 | static const u8 mbm_guid[16] = { |
| 68 | 0xa3, 0x17, 0xa8, 0x8b, 0x04, 0x5e, 0x4f, 0x01, |
| 69 | 0xa6, 0x07, 0xc0, 0xff, 0xcb, 0x7e, 0x39, 0x2a, |
| 70 | }; |
| 71 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 72 | /* |
| 73 | * probes control interface, claims data interface, collects the bulk |
| 74 | * endpoints, activates data interface (if needed), maybe sets MTU. |
| 75 | * all pure cdc, except for certain firmware workarounds, and knowing |
| 76 | * that rndis uses one different rule. |
| 77 | */ |
| 78 | int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf) |
| 79 | { |
| 80 | u8 *buf = intf->cur_altsetting->extra; |
| 81 | int len = intf->cur_altsetting->extralen; |
| 82 | struct usb_interface_descriptor *d; |
| 83 | struct cdc_state *info = (void *) &dev->data; |
| 84 | int status; |
| 85 | int rndis; |
| 86 | struct usb_driver *driver = driver_of(intf); |
Jonas Sjöquist | 2185126 | 2010-04-23 01:07:45 +0000 | [diff] [blame] | 87 | struct usb_cdc_mdlm_desc *desc = NULL; |
| 88 | struct usb_cdc_mdlm_detail_desc *detail = NULL; |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 89 | |
| 90 | if (sizeof dev->data < sizeof *info) |
| 91 | return -EDOM; |
| 92 | |
| 93 | /* expect strict spec conformance for the descriptors, but |
| 94 | * cope with firmware which stores them in the wrong place |
| 95 | */ |
| 96 | if (len == 0 && dev->udev->actconfig->extralen) { |
| 97 | /* Motorola SB4100 (and others: Brad Hards says it's |
| 98 | * from a Broadcom design) put CDC descriptors here |
| 99 | */ |
| 100 | buf = dev->udev->actconfig->extra; |
| 101 | len = dev->udev->actconfig->extralen; |
Dan Carpenter | f5260f0 | 2010-12-25 12:23:42 +0000 | [diff] [blame] | 102 | dev_dbg(&intf->dev, "CDC descriptors on config\n"); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 103 | } |
| 104 | |
David Brownell | 4149b72 | 2007-04-29 10:09:47 -0700 | [diff] [blame] | 105 | /* Maybe CDC descriptors are after the endpoint? This bug has |
| 106 | * been seen on some 2Wire Inc RNDIS-ish products. |
| 107 | */ |
| 108 | if (len == 0) { |
| 109 | struct usb_host_endpoint *hep; |
| 110 | |
| 111 | hep = intf->cur_altsetting->endpoint; |
| 112 | if (hep) { |
| 113 | buf = hep->extra; |
| 114 | len = hep->extralen; |
| 115 | } |
| 116 | if (len) |
| 117 | dev_dbg(&intf->dev, |
| 118 | "CDC descriptors on endpoint\n"); |
| 119 | } |
| 120 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 121 | /* this assumes that if there's a non-RNDIS vendor variant |
| 122 | * of cdc-acm, it'll fail RNDIS requests cleanly. |
| 123 | */ |
Joe Perches | 8e95a20 | 2009-12-03 07:58:21 +0000 | [diff] [blame] | 124 | rndis = (is_rndis(&intf->cur_altsetting->desc) || |
| 125 | is_activesync(&intf->cur_altsetting->desc) || |
| 126 | is_wireless_rndis(&intf->cur_altsetting->desc)); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 127 | |
| 128 | memset(info, 0, sizeof *info); |
| 129 | info->control = intf; |
| 130 | while (len > 3) { |
| 131 | if (buf [1] != USB_DT_CS_INTERFACE) |
| 132 | goto next_desc; |
| 133 | |
| 134 | /* use bDescriptorSubType to identify the CDC descriptors. |
| 135 | * We expect devices with CDC header and union descriptors. |
| 136 | * For CDC Ethernet we need the ethernet descriptor. |
| 137 | * For RNDIS, ignore two (pointless) CDC modem descriptors |
| 138 | * in favor of a complicated OID-based RPC scheme doing what |
| 139 | * CDC Ethernet achieves with a simple descriptor. |
| 140 | */ |
| 141 | switch (buf [2]) { |
| 142 | case USB_CDC_HEADER_TYPE: |
| 143 | if (info->header) { |
| 144 | dev_dbg(&intf->dev, "extra CDC header\n"); |
| 145 | goto bad_desc; |
| 146 | } |
| 147 | info->header = (void *) buf; |
| 148 | if (info->header->bLength != sizeof *info->header) { |
| 149 | dev_dbg(&intf->dev, "CDC header len %u\n", |
| 150 | info->header->bLength); |
| 151 | goto bad_desc; |
| 152 | } |
| 153 | break; |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 154 | case USB_CDC_ACM_TYPE: |
| 155 | /* paranoia: disambiguate a "real" vendor-specific |
| 156 | * modem interface from an RNDIS non-modem. |
| 157 | */ |
| 158 | if (rndis) { |
David Brownell | afaee82 | 2007-07-01 11:47:59 -0700 | [diff] [blame] | 159 | struct usb_cdc_acm_descriptor *acm; |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 160 | |
David Brownell | afaee82 | 2007-07-01 11:47:59 -0700 | [diff] [blame] | 161 | acm = (void *) buf; |
| 162 | if (acm->bmCapabilities) { |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 163 | dev_dbg(&intf->dev, |
| 164 | "ACM capabilities %02x, " |
| 165 | "not really RNDIS?\n", |
David Brownell | afaee82 | 2007-07-01 11:47:59 -0700 | [diff] [blame] | 166 | acm->bmCapabilities); |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 167 | goto bad_desc; |
| 168 | } |
| 169 | } |
| 170 | break; |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 171 | case USB_CDC_UNION_TYPE: |
| 172 | if (info->u) { |
| 173 | dev_dbg(&intf->dev, "extra CDC union\n"); |
| 174 | goto bad_desc; |
| 175 | } |
| 176 | info->u = (void *) buf; |
| 177 | if (info->u->bLength != sizeof *info->u) { |
| 178 | dev_dbg(&intf->dev, "CDC union len %u\n", |
| 179 | info->u->bLength); |
| 180 | goto bad_desc; |
| 181 | } |
| 182 | |
| 183 | /* we need a master/control interface (what we're |
| 184 | * probed with) and a slave/data interface; union |
| 185 | * descriptors sort this all out. |
| 186 | */ |
| 187 | info->control = usb_ifnum_to_if(dev->udev, |
| 188 | info->u->bMasterInterface0); |
| 189 | info->data = usb_ifnum_to_if(dev->udev, |
| 190 | info->u->bSlaveInterface0); |
| 191 | if (!info->control || !info->data) { |
| 192 | dev_dbg(&intf->dev, |
| 193 | "master #%u/%p slave #%u/%p\n", |
| 194 | info->u->bMasterInterface0, |
| 195 | info->control, |
| 196 | info->u->bSlaveInterface0, |
| 197 | info->data); |
| 198 | goto bad_desc; |
| 199 | } |
| 200 | if (info->control != intf) { |
| 201 | dev_dbg(&intf->dev, "bogus CDC Union\n"); |
| 202 | /* Ambit USB Cable Modem (and maybe others) |
| 203 | * interchanges master and slave interface. |
| 204 | */ |
| 205 | if (info->data == intf) { |
| 206 | info->data = info->control; |
| 207 | info->control = intf; |
| 208 | } else |
| 209 | goto bad_desc; |
| 210 | } |
| 211 | |
| 212 | /* a data interface altsetting does the real i/o */ |
| 213 | d = &info->data->cur_altsetting->desc; |
| 214 | if (d->bInterfaceClass != USB_CLASS_CDC_DATA) { |
| 215 | dev_dbg(&intf->dev, "slave class %u\n", |
| 216 | d->bInterfaceClass); |
| 217 | goto bad_desc; |
| 218 | } |
| 219 | break; |
| 220 | case USB_CDC_ETHERNET_TYPE: |
| 221 | if (info->ether) { |
| 222 | dev_dbg(&intf->dev, "extra CDC ether\n"); |
| 223 | goto bad_desc; |
| 224 | } |
| 225 | info->ether = (void *) buf; |
| 226 | if (info->ether->bLength != sizeof *info->ether) { |
| 227 | dev_dbg(&intf->dev, "CDC ether len %u\n", |
| 228 | info->ether->bLength); |
| 229 | goto bad_desc; |
| 230 | } |
| 231 | dev->hard_mtu = le16_to_cpu( |
| 232 | info->ether->wMaxSegmentSize); |
| 233 | /* because of Zaurus, we may be ignoring the host |
| 234 | * side link address we were given. |
| 235 | */ |
| 236 | break; |
Jonas Sjöquist | 2185126 | 2010-04-23 01:07:45 +0000 | [diff] [blame] | 237 | case USB_CDC_MDLM_TYPE: |
| 238 | if (desc) { |
| 239 | dev_dbg(&intf->dev, "extra MDLM descriptor\n"); |
| 240 | goto bad_desc; |
| 241 | } |
| 242 | |
| 243 | desc = (void *)buf; |
| 244 | |
| 245 | if (desc->bLength != sizeof(*desc)) |
| 246 | goto bad_desc; |
| 247 | |
| 248 | if (memcmp(&desc->bGUID, mbm_guid, 16)) |
| 249 | goto bad_desc; |
| 250 | break; |
| 251 | case USB_CDC_MDLM_DETAIL_TYPE: |
| 252 | if (detail) { |
| 253 | dev_dbg(&intf->dev, "extra MDLM detail descriptor\n"); |
| 254 | goto bad_desc; |
| 255 | } |
| 256 | |
| 257 | detail = (void *)buf; |
| 258 | |
| 259 | if (detail->bGuidDescriptorType == 0) { |
| 260 | if (detail->bLength < (sizeof(*detail) + 1)) |
| 261 | goto bad_desc; |
| 262 | } else |
| 263 | goto bad_desc; |
| 264 | break; |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 265 | } |
| 266 | next_desc: |
| 267 | len -= buf [0]; /* bLength */ |
| 268 | buf += buf [0]; |
| 269 | } |
| 270 | |
Bjorge Dijkstra | 786e3df | 2008-01-26 00:50:44 +0200 | [diff] [blame] | 271 | /* Microsoft ActiveSync based and some regular RNDIS devices lack the |
| 272 | * CDC descriptors, so we'll hard-wire the interfaces and not check |
| 273 | * for descriptors. |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 274 | */ |
Bjorge Dijkstra | 786e3df | 2008-01-26 00:50:44 +0200 | [diff] [blame] | 275 | if (rndis && !info->u) { |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 276 | info->control = usb_ifnum_to_if(dev->udev, 0); |
| 277 | info->data = usb_ifnum_to_if(dev->udev, 1); |
| 278 | if (!info->control || !info->data) { |
| 279 | dev_dbg(&intf->dev, |
Bjorge Dijkstra | 786e3df | 2008-01-26 00:50:44 +0200 | [diff] [blame] | 280 | "rndis: master #0/%p slave #1/%p\n", |
Ole Andre Vadla Ravnas | ad55d71 | 2006-12-14 16:01:28 -0800 | [diff] [blame] | 281 | info->control, |
| 282 | info->data); |
| 283 | goto bad_desc; |
| 284 | } |
| 285 | |
| 286 | } else if (!info->header || !info->u || (!rndis && !info->ether)) { |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 287 | dev_dbg(&intf->dev, "missing cdc %s%s%sdescriptor\n", |
| 288 | info->header ? "" : "header ", |
| 289 | info->u ? "" : "union ", |
| 290 | info->ether ? "" : "ether "); |
| 291 | goto bad_desc; |
| 292 | } |
| 293 | |
| 294 | /* claim data interface and set it up ... with side effects. |
| 295 | * network traffic can't flow until an altsetting is enabled. |
| 296 | */ |
| 297 | status = usb_driver_claim_interface(driver, info->data, dev); |
| 298 | if (status < 0) |
| 299 | return status; |
| 300 | status = usbnet_get_endpoints(dev, info->data); |
| 301 | if (status < 0) { |
| 302 | /* ensure immediate exit from usbnet_disconnect */ |
| 303 | usb_set_intfdata(info->data, NULL); |
| 304 | usb_driver_release_interface(driver, info->data); |
| 305 | return status; |
| 306 | } |
| 307 | |
| 308 | /* status endpoint: optional for CDC Ethernet, not RNDIS (or ACM) */ |
| 309 | dev->status = NULL; |
| 310 | if (info->control->cur_altsetting->desc.bNumEndpoints == 1) { |
| 311 | struct usb_endpoint_descriptor *desc; |
| 312 | |
| 313 | dev->status = &info->control->cur_altsetting->endpoint [0]; |
| 314 | desc = &dev->status->desc; |
Joe Perches | 8e95a20 | 2009-12-03 07:58:21 +0000 | [diff] [blame] | 315 | if (!usb_endpoint_is_int_in(desc) || |
| 316 | (le16_to_cpu(desc->wMaxPacketSize) |
| 317 | < sizeof(struct usb_cdc_notification)) || |
| 318 | !desc->bInterval) { |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 319 | dev_dbg(&intf->dev, "bad notification endpoint\n"); |
| 320 | dev->status = NULL; |
| 321 | } |
| 322 | } |
| 323 | if (rndis && !dev->status) { |
| 324 | dev_dbg(&intf->dev, "missing RNDIS status endpoint\n"); |
| 325 | usb_set_intfdata(info->data, NULL); |
| 326 | usb_driver_release_interface(driver, info->data); |
| 327 | return -ENODEV; |
| 328 | } |
| 329 | return 0; |
| 330 | |
| 331 | bad_desc: |
| 332 | dev_info(&dev->udev->dev, "bad CDC descriptors\n"); |
| 333 | return -ENODEV; |
| 334 | } |
| 335 | EXPORT_SYMBOL_GPL(usbnet_generic_cdc_bind); |
| 336 | |
| 337 | void usbnet_cdc_unbind(struct usbnet *dev, struct usb_interface *intf) |
| 338 | { |
| 339 | struct cdc_state *info = (void *) &dev->data; |
| 340 | struct usb_driver *driver = driver_of(intf); |
| 341 | |
| 342 | /* disconnect master --> disconnect slave */ |
| 343 | if (intf == info->control && info->data) { |
| 344 | /* ensure immediate exit from usbnet_disconnect */ |
| 345 | usb_set_intfdata(info->data, NULL); |
| 346 | usb_driver_release_interface(driver, info->data); |
| 347 | info->data = NULL; |
| 348 | } |
| 349 | |
| 350 | /* and vice versa (just in case) */ |
| 351 | else if (intf == info->data && info->control) { |
| 352 | /* ensure immediate exit from usbnet_disconnect */ |
| 353 | usb_set_intfdata(info->control, NULL); |
| 354 | usb_driver_release_interface(driver, info->control); |
| 355 | info->control = NULL; |
| 356 | } |
| 357 | } |
| 358 | EXPORT_SYMBOL_GPL(usbnet_cdc_unbind); |
| 359 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 360 | /*------------------------------------------------------------------------- |
| 361 | * |
| 362 | * Communications Device Class, Ethernet Control model |
| 363 | * |
| 364 | * Takes two interfaces. The DATA interface is inactive till an altsetting |
| 365 | * is selected. Configuration data includes class descriptors. There's |
| 366 | * an optional status endpoint on the control interface. |
| 367 | * |
| 368 | * This should interop with whatever the 2.4 "CDCEther.c" driver |
| 369 | * (by Brad Hards) talked with, with more functionality. |
| 370 | * |
| 371 | *-------------------------------------------------------------------------*/ |
| 372 | |
| 373 | static void dumpspeed(struct usbnet *dev, __le32 *speeds) |
| 374 | { |
Joe Perches | a475f60 | 2010-02-17 10:30:24 +0000 | [diff] [blame] | 375 | netif_info(dev, timer, dev->net, |
| 376 | "link speeds: %u kbps up, %u kbps down\n", |
| 377 | __le32_to_cpu(speeds[0]) / 1000, |
| 378 | __le32_to_cpu(speeds[1]) / 1000); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 379 | } |
| 380 | |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 381 | void usbnet_cdc_status(struct usbnet *dev, struct urb *urb) |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 382 | { |
| 383 | struct usb_cdc_notification *event; |
| 384 | |
| 385 | if (urb->actual_length < sizeof *event) |
| 386 | return; |
| 387 | |
| 388 | /* SPEED_CHANGE can get split into two 8-byte packets */ |
| 389 | if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { |
| 390 | dumpspeed(dev, (__le32 *) urb->transfer_buffer); |
| 391 | return; |
| 392 | } |
| 393 | |
| 394 | event = urb->transfer_buffer; |
| 395 | switch (event->bNotificationType) { |
| 396 | case USB_CDC_NOTIFY_NETWORK_CONNECTION: |
Joe Perches | a475f60 | 2010-02-17 10:30:24 +0000 | [diff] [blame] | 397 | netif_dbg(dev, timer, dev->net, "CDC: carrier %s\n", |
| 398 | event->wValue ? "on" : "off"); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 399 | if (event->wValue) |
| 400 | netif_carrier_on(dev->net); |
| 401 | else |
| 402 | netif_carrier_off(dev->net); |
| 403 | break; |
| 404 | case USB_CDC_NOTIFY_SPEED_CHANGE: /* tx/rx rates */ |
Joe Perches | a475f60 | 2010-02-17 10:30:24 +0000 | [diff] [blame] | 405 | netif_dbg(dev, timer, dev->net, "CDC: speed change (len %d)\n", |
| 406 | urb->actual_length); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 407 | if (urb->actual_length != (sizeof *event + 8)) |
| 408 | set_bit(EVENT_STS_SPLIT, &dev->flags); |
| 409 | else |
| 410 | dumpspeed(dev, (__le32 *) &event[1]); |
| 411 | break; |
| 412 | /* USB_CDC_NOTIFY_RESPONSE_AVAILABLE can happen too (e.g. RNDIS), |
| 413 | * but there are no standard formats for the response data. |
| 414 | */ |
| 415 | default: |
Joe Perches | 60b8675 | 2010-02-17 10:30:23 +0000 | [diff] [blame] | 416 | netdev_err(dev->net, "CDC: unexpected notification %02x!\n", |
| 417 | event->bNotificationType); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 418 | break; |
| 419 | } |
| 420 | } |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 421 | EXPORT_SYMBOL_GPL(usbnet_cdc_status); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 422 | |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 423 | int usbnet_cdc_bind(struct usbnet *dev, struct usb_interface *intf) |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 424 | { |
| 425 | int status; |
| 426 | struct cdc_state *info = (void *) &dev->data; |
| 427 | |
Greg Kroah-Hartman | d632eb1 | 2011-11-18 09:44:20 -0800 | [diff] [blame] | 428 | BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) |
| 429 | < sizeof(struct cdc_state))); |
| 430 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 431 | status = usbnet_generic_cdc_bind(dev, intf); |
| 432 | if (status < 0) |
| 433 | return status; |
| 434 | |
Peter Holik | 03ad032 | 2009-04-18 07:24:17 +0000 | [diff] [blame] | 435 | status = usbnet_get_ethernet_addr(dev, info->ether->iMACAddress); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 436 | if (status < 0) { |
| 437 | usb_set_intfdata(info->data, NULL); |
| 438 | usb_driver_release_interface(driver_of(intf), info->data); |
| 439 | return status; |
| 440 | } |
| 441 | |
| 442 | /* FIXME cdc-ether has some multicast code too, though it complains |
| 443 | * in routine cases. info->ether describes the multicast support. |
| 444 | * Implement that here, manipulating the cdc filter as needed. |
| 445 | */ |
| 446 | return 0; |
| 447 | } |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 448 | EXPORT_SYMBOL_GPL(usbnet_cdc_bind); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 449 | |
Oliver Neukum | 69ee472f | 2009-12-03 15:31:18 -0800 | [diff] [blame] | 450 | static int cdc_manage_power(struct usbnet *dev, int on) |
| 451 | { |
| 452 | dev->intf->needs_remote_wakeup = on; |
| 453 | return 0; |
| 454 | } |
| 455 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 456 | static const struct driver_info cdc_info = { |
| 457 | .description = "CDC Ethernet Device", |
Arnd Bergmann | c261344 | 2011-04-01 20:12:02 -0700 | [diff] [blame] | 458 | .flags = FLAG_ETHER | FLAG_POINTTOPOINT, |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 459 | // .check_connect = cdc_check_connect, |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 460 | .bind = usbnet_cdc_bind, |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 461 | .unbind = usbnet_cdc_unbind, |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 462 | .status = usbnet_cdc_status, |
Oliver Neukum | 69ee472f | 2009-12-03 15:31:18 -0800 | [diff] [blame] | 463 | .manage_power = cdc_manage_power, |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 464 | }; |
| 465 | |
Dan Williams | b3c914a | 2011-04-27 09:54:28 +0000 | [diff] [blame] | 466 | static const struct driver_info wwan_info = { |
Marcel Holtmann | e1e499e | 2009-10-02 05:15:25 +0000 | [diff] [blame] | 467 | .description = "Mobile Broadband Network Device", |
| 468 | .flags = FLAG_WWAN, |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 469 | .bind = usbnet_cdc_bind, |
Marcel Holtmann | e1e499e | 2009-10-02 05:15:25 +0000 | [diff] [blame] | 470 | .unbind = usbnet_cdc_unbind, |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 471 | .status = usbnet_cdc_status, |
Torgny Johansson | 55964d7 | 2010-04-27 17:07:40 -0700 | [diff] [blame] | 472 | .manage_power = cdc_manage_power, |
Marcel Holtmann | e1e499e | 2009-10-02 05:15:25 +0000 | [diff] [blame] | 473 | }; |
| 474 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 475 | /*-------------------------------------------------------------------------*/ |
| 476 | |
Dan Williams | b3c914a | 2011-04-27 09:54:28 +0000 | [diff] [blame] | 477 | #define HUAWEI_VENDOR_ID 0x12D1 |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 478 | |
| 479 | static const struct usb_device_id products [] = { |
| 480 | /* |
| 481 | * BLACKLIST !! |
| 482 | * |
| 483 | * First blacklist any products that are egregiously nonconformant |
| 484 | * with the CDC Ethernet specs. Minor braindamage we cope with; when |
| 485 | * they're not even trying, needing a separate driver is only the first |
| 486 | * of the differences to show up. |
| 487 | */ |
| 488 | |
| 489 | #define ZAURUS_MASTER_INTERFACE \ |
| 490 | .bInterfaceClass = USB_CLASS_COMM, \ |
| 491 | .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \ |
| 492 | .bInterfaceProtocol = USB_CDC_PROTO_NONE |
| 493 | |
| 494 | /* SA-1100 based Sharp Zaurus ("collie"), or compatible; |
| 495 | * wire-incompatible with true CDC Ethernet implementations. |
| 496 | * (And, it seems, needlessly so...) |
| 497 | */ |
| 498 | { |
| 499 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 500 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 501 | .idVendor = 0x04DD, |
| 502 | .idProduct = 0x8004, |
| 503 | ZAURUS_MASTER_INTERFACE, |
| 504 | .driver_info = 0, |
| 505 | }, |
| 506 | |
| 507 | /* PXA-25x based Sharp Zaurii. Note that it seems some of these |
| 508 | * (later models especially) may have shipped only with firmware |
| 509 | * advertising false "CDC MDLM" compatibility ... but we're not |
| 510 | * clear which models did that, so for now let's assume the worst. |
| 511 | */ |
| 512 | { |
| 513 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 514 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 515 | .idVendor = 0x04DD, |
| 516 | .idProduct = 0x8005, /* A-300 */ |
| 517 | ZAURUS_MASTER_INTERFACE, |
| 518 | .driver_info = 0, |
| 519 | }, { |
| 520 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 521 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 522 | .idVendor = 0x04DD, |
| 523 | .idProduct = 0x8006, /* B-500/SL-5600 */ |
| 524 | ZAURUS_MASTER_INTERFACE, |
| 525 | .driver_info = 0, |
| 526 | }, { |
| 527 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 528 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 529 | .idVendor = 0x04DD, |
| 530 | .idProduct = 0x8007, /* C-700 */ |
| 531 | ZAURUS_MASTER_INTERFACE, |
| 532 | .driver_info = 0, |
| 533 | }, { |
| 534 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 535 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 536 | .idVendor = 0x04DD, |
| 537 | .idProduct = 0x9031, /* C-750 C-760 */ |
| 538 | ZAURUS_MASTER_INTERFACE, |
| 539 | .driver_info = 0, |
| 540 | }, { |
| 541 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 542 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 543 | .idVendor = 0x04DD, |
| 544 | .idProduct = 0x9032, /* SL-6000 */ |
| 545 | ZAURUS_MASTER_INTERFACE, |
| 546 | .driver_info = 0, |
| 547 | }, { |
| 548 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 549 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 550 | .idVendor = 0x04DD, |
| 551 | /* reported with some C860 units */ |
| 552 | .idProduct = 0x9050, /* C-860 */ |
| 553 | ZAURUS_MASTER_INTERFACE, |
| 554 | .driver_info = 0, |
| 555 | }, |
| 556 | |
David Brownell | efcaa20 | 2006-05-30 20:49:29 -0700 | [diff] [blame] | 557 | /* Olympus has some models with a Zaurus-compatible option. |
| 558 | * R-1000 uses a FreeScale i.MXL cpu (ARMv4T) |
| 559 | */ |
| 560 | { |
| 561 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO |
| 562 | | USB_DEVICE_ID_MATCH_DEVICE, |
| 563 | .idVendor = 0x07B4, |
| 564 | .idProduct = 0x0F02, /* R-1000 */ |
| 565 | ZAURUS_MASTER_INTERFACE, |
| 566 | .driver_info = 0, |
| 567 | }, |
| 568 | |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 569 | /* LG Electronics VL600 wants additional headers on every frame */ |
| 570 | { |
| 571 | USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM, |
| 572 | USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE), |
Mark Kamichoff | 6d74eb9 | 2011-11-09 11:48:10 +0000 | [diff] [blame] | 573 | .driver_info = 0, |
Andrzej Zaborowski | 7a635ea | 2011-03-28 12:56:33 +0000 | [diff] [blame] | 574 | }, |
| 575 | |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 576 | /* |
| 577 | * WHITELIST!!! |
| 578 | * |
| 579 | * CDC Ether uses two interfaces, not necessarily consecutive. |
| 580 | * We match the main interface, ignoring the optional device |
| 581 | * class so we could handle devices that aren't exclusively |
| 582 | * CDC ether. |
| 583 | * |
| 584 | * NOTE: this match must come AFTER entries blacklisting devices |
| 585 | * because of bugs/quirks in a given product (like Zaurus, above). |
| 586 | */ |
| 587 | { |
| 588 | USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET, |
| 589 | USB_CDC_PROTO_NONE), |
| 590 | .driver_info = (unsigned long) &cdc_info, |
Bjørn Mork | cac477e | 2009-02-25 04:33:58 +0000 | [diff] [blame] | 591 | }, { |
Jonas Sjöquist | 2185126 | 2010-04-23 01:07:45 +0000 | [diff] [blame] | 592 | USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM, |
| 593 | USB_CDC_PROTO_NONE), |
Dan Williams | b3c914a | 2011-04-27 09:54:28 +0000 | [diff] [blame] | 594 | .driver_info = (unsigned long)&wwan_info, |
Jonas Sjöquist | 2185126 | 2010-04-23 01:07:45 +0000 | [diff] [blame] | 595 | |
Dan Williams | b3c914a | 2011-04-27 09:54:28 +0000 | [diff] [blame] | 596 | }, { |
| 597 | /* Various Huawei modems with a network port like the UMG1831 */ |
| 598 | .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
| 599 | | USB_DEVICE_ID_MATCH_INT_INFO, |
| 600 | .idVendor = HUAWEI_VENDOR_ID, |
| 601 | .bInterfaceClass = USB_CLASS_COMM, |
| 602 | .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, |
| 603 | .bInterfaceProtocol = 255, |
| 604 | .driver_info = (unsigned long)&wwan_info, |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 605 | }, |
| 606 | { }, // END |
| 607 | }; |
| 608 | MODULE_DEVICE_TABLE(usb, products); |
| 609 | |
| 610 | static struct usb_driver cdc_driver = { |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 611 | .name = "cdc_ether", |
| 612 | .id_table = products, |
| 613 | .probe = usbnet_probe, |
| 614 | .disconnect = usbnet_disconnect, |
| 615 | .suspend = usbnet_suspend, |
| 616 | .resume = usbnet_resume, |
Oliver Neukum | 7f51579 | 2009-12-03 11:41:07 +0000 | [diff] [blame] | 617 | .reset_resume = usbnet_resume, |
Oliver Neukum | 69ee472f | 2009-12-03 15:31:18 -0800 | [diff] [blame] | 618 | .supports_autosuspend = 1, |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 619 | }; |
| 620 | |
Greg Kroah-Hartman | d632eb1 | 2011-11-18 09:44:20 -0800 | [diff] [blame] | 621 | module_usb_driver(cdc_driver); |
David Brownell | 4324fd4 | 2005-08-31 09:54:20 -0700 | [diff] [blame] | 622 | |
| 623 | MODULE_AUTHOR("David Brownell"); |
| 624 | MODULE_DESCRIPTION("USB CDC Ethernet devices"); |
| 625 | MODULE_LICENSE("GPL"); |