1 /* 2 * cdc_ncm.c 3 * 4 * Copyright (C) ST-Ericsson 2010-2011 5 * Contact: Alexey Orishko <alexey.orishko@stericsson.com> 6 * Original author: Hans Petter Selasky <hans.petter.selasky@stericsson.com> 7 * 8 * USB Host Driver for Network Control Model (NCM) 9 * http://www.usb.org/developers/devclass_docs/NCM10.zip 10 * 11 * The NCM encoding, decoding and initialization logic 12 * derives from FreeBSD 8.x. if_cdce.c and if_cdcereg.h 13 * 14 * This software is available to you under a choice of one of two 15 * licenses. You may choose this file to be licensed under the terms 16 * of the GNU General Public License (GPL) Version 2 or the 2-clause 17 * BSD license listed below: 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions and the following disclaimer. 24 * 2. Redistributions in binary form must reproduce the above copyright 25 * notice, this list of conditions and the following disclaimer in the 26 * documentation and/or other materials provided with the distribution. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 */ 40 41 #include <linux/module.h> 42 #include <linux/init.h> 43 #include <linux/netdevice.h> 44 #include <linux/ctype.h> 45 #include <linux/ethtool.h> 46 #include <linux/workqueue.h> 47 #include <linux/mii.h> 48 #include <linux/crc32.h> 49 #include <linux/usb.h> 50 #include <linux/timer.h> 51 #include <linux/spinlock.h> 52 #include <linux/atomic.h> 53 #include <linux/usb/usbnet.h> 54 #include <linux/usb/cdc.h> 55 56 #define DRIVER_VERSION "04-Aug-2011" 57 58 /* CDC NCM subclass 3.2.1 */ 59 #define USB_CDC_NCM_NDP16_LENGTH_MIN 0x10 60 61 /* Maximum NTB length */ 62 #define CDC_NCM_NTB_MAX_SIZE_TX 16384 /* bytes */ 63 #define CDC_NCM_NTB_MAX_SIZE_RX 16384 /* bytes */ 64 65 /* Minimum value for MaxDatagramSize, ch. 6.2.9 */ 66 #define CDC_NCM_MIN_DATAGRAM_SIZE 1514 /* bytes */ 67 68 #define CDC_NCM_MIN_TX_PKT 512 /* bytes */ 69 70 /* Default value for MaxDatagramSize */ 71 #define CDC_NCM_MAX_DATAGRAM_SIZE 2048 /* bytes */ 72 73 /* 74 * Maximum amount of datagrams in NCM Datagram Pointer Table, not counting 75 * the last NULL entry. Any additional datagrams in NTB would be discarded. 76 */ 77 #define CDC_NCM_DPT_DATAGRAMS_MAX 32 78 79 /* Maximum amount of IN datagrams in NTB */ 80 #define CDC_NCM_DPT_DATAGRAMS_IN_MAX 0 /* unlimited */ 81 82 /* Restart the timer, if amount of datagrams is less than given value */ 83 #define CDC_NCM_RESTART_TIMER_DATAGRAM_CNT 3 84 85 /* The following macro defines the minimum header space */ 86 #define CDC_NCM_MIN_HDR_SIZE \ 87 (sizeof(struct usb_cdc_ncm_nth16) + sizeof(struct usb_cdc_ncm_ndp16) + \ 88 (CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16)) 89 90 struct cdc_ncm_data { 91 struct usb_cdc_ncm_nth16 nth16; 92 struct usb_cdc_ncm_ndp16 ndp16; 93 struct usb_cdc_ncm_dpe16 dpe16[CDC_NCM_DPT_DATAGRAMS_MAX + 1]; 94 }; 95 96 struct cdc_ncm_ctx { 97 struct cdc_ncm_data rx_ncm; 98 struct cdc_ncm_data tx_ncm; 99 struct usb_cdc_ncm_ntb_parameters ncm_parm; 100 struct timer_list tx_timer; 101 102 const struct usb_cdc_ncm_desc *func_desc; 103 const struct usb_cdc_header_desc *header_desc; 104 const struct usb_cdc_union_desc *union_desc; 105 const struct usb_cdc_ether_desc *ether_desc; 106 107 struct net_device *netdev; 108 struct usb_device *udev; 109 struct usb_host_endpoint *in_ep; 110 struct usb_host_endpoint *out_ep; 111 struct usb_host_endpoint *status_ep; 112 struct usb_interface *intf; 113 struct usb_interface *control; 114 struct usb_interface *data; 115 116 struct sk_buff *tx_curr_skb; 117 struct sk_buff *tx_rem_skb; 118 119 spinlock_t mtx; 120 121 u32 tx_timer_pending; 122 u32 tx_curr_offset; 123 u32 tx_curr_last_offset; 124 u32 tx_curr_frame_num; 125 u32 rx_speed; 126 u32 tx_speed; 127 u32 rx_max; 128 u32 tx_max; 129 u32 max_datagram_size; 130 u16 tx_max_datagrams; 131 u16 tx_remainder; 132 u16 tx_modulus; 133 u16 tx_ndp_modulus; 134 u16 tx_seq; 135 u16 connected; 136 }; 137 138 static void cdc_ncm_tx_timeout(unsigned long arg); 139 static const struct driver_info cdc_ncm_info; 140 static struct usb_driver cdc_ncm_driver; 141 static struct ethtool_ops cdc_ncm_ethtool_ops; 142 143 static const struct usb_device_id cdc_devs[] = { 144 { USB_INTERFACE_INFO(USB_CLASS_COMM, 145 USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE), 146 .driver_info = (unsigned long)&cdc_ncm_info, 147 }, 148 { 149 }, 150 }; 151 152 MODULE_DEVICE_TABLE(usb, cdc_devs); 153 154 static void 155 cdc_ncm_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info) 156 { 157 struct usbnet *dev = netdev_priv(net); 158 159 strncpy(info->driver, dev->driver_name, sizeof(info->driver)); 160 strncpy(info->version, DRIVER_VERSION, sizeof(info->version)); 161 strncpy(info->fw_version, dev->driver_info->description, 162 sizeof(info->fw_version)); 163 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info)); 164 } 165 166 static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx) 167 { 168 u32 val; 169 u8 flags; 170 u8 iface_no; 171 int err; 172 u16 ntb_fmt_supported; 173 174 iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber; 175 176 err = usb_control_msg(ctx->udev, 177 usb_rcvctrlpipe(ctx->udev, 0), 178 USB_CDC_GET_NTB_PARAMETERS, 179 USB_TYPE_CLASS | USB_DIR_IN 180 | USB_RECIP_INTERFACE, 181 0, iface_no, &ctx->ncm_parm, 182 sizeof(ctx->ncm_parm), 10000); 183 if (err < 0) { 184 pr_debug("failed GET_NTB_PARAMETERS\n"); 185 return 1; 186 } 187 188 /* read correct set of parameters according to device mode */ 189 ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize); 190 ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize); 191 ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder); 192 ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor); 193 ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment); 194 /* devices prior to NCM Errata shall set this field to zero */ 195 ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams); 196 ntb_fmt_supported = le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported); 197 198 if (ctx->func_desc != NULL) 199 flags = ctx->func_desc->bmNetworkCapabilities; 200 else 201 flags = 0; 202 203 pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u " 204 "wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u " 205 "wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n", 206 ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus, 207 ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags); 208 209 /* max count of tx datagrams */ 210 if ((ctx->tx_max_datagrams == 0) || 211 (ctx->tx_max_datagrams > CDC_NCM_DPT_DATAGRAMS_MAX)) 212 ctx->tx_max_datagrams = CDC_NCM_DPT_DATAGRAMS_MAX; 213 214 /* verify maximum size of received NTB in bytes */ 215 if (ctx->rx_max < USB_CDC_NCM_NTB_MIN_IN_SIZE) { 216 pr_debug("Using min receive length=%d\n", 217 USB_CDC_NCM_NTB_MIN_IN_SIZE); 218 ctx->rx_max = USB_CDC_NCM_NTB_MIN_IN_SIZE; 219 } 220 221 if (ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX) { 222 pr_debug("Using default maximum receive length=%d\n", 223 CDC_NCM_NTB_MAX_SIZE_RX); 224 ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX; 225 } 226 227 /* inform device about NTB input size changes */ 228 if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) { 229 230 if (flags & USB_CDC_NCM_NCAP_NTB_INPUT_SIZE) { 231 struct usb_cdc_ncm_ndp_input_size ndp_in_sz; 232 err = usb_control_msg(ctx->udev, 233 usb_sndctrlpipe(ctx->udev, 0), 234 USB_CDC_SET_NTB_INPUT_SIZE, 235 USB_TYPE_CLASS | USB_DIR_OUT 236 | USB_RECIP_INTERFACE, 237 0, iface_no, &ndp_in_sz, 8, 1000); 238 } else { 239 __le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max); 240 err = usb_control_msg(ctx->udev, 241 usb_sndctrlpipe(ctx->udev, 0), 242 USB_CDC_SET_NTB_INPUT_SIZE, 243 USB_TYPE_CLASS | USB_DIR_OUT 244 | USB_RECIP_INTERFACE, 245 0, iface_no, &dwNtbInMaxSize, 4, 1000); 246 } 247 248 if (err < 0) 249 pr_debug("Setting NTB Input Size failed\n"); 250 } 251 252 /* verify maximum size of transmitted NTB in bytes */ 253 if ((ctx->tx_max < 254 (CDC_NCM_MIN_HDR_SIZE + CDC_NCM_MIN_DATAGRAM_SIZE)) || 255 (ctx->tx_max > CDC_NCM_NTB_MAX_SIZE_TX)) { 256 pr_debug("Using default maximum transmit length=%d\n", 257 CDC_NCM_NTB_MAX_SIZE_TX); 258 ctx->tx_max = CDC_NCM_NTB_MAX_SIZE_TX; 259 } 260 261 /* 262 * verify that the structure alignment is: 263 * - power of two 264 * - not greater than the maximum transmit length 265 * - not less than four bytes 266 */ 267 val = ctx->tx_ndp_modulus; 268 269 if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) || 270 (val != ((-val) & val)) || (val >= ctx->tx_max)) { 271 pr_debug("Using default alignment: 4 bytes\n"); 272 ctx->tx_ndp_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE; 273 } 274 275 /* 276 * verify that the payload alignment is: 277 * - power of two 278 * - not greater than the maximum transmit length 279 * - not less than four bytes 280 */ 281 val = ctx->tx_modulus; 282 283 if ((val < USB_CDC_NCM_NDP_ALIGN_MIN_SIZE) || 284 (val != ((-val) & val)) || (val >= ctx->tx_max)) { 285 pr_debug("Using default transmit modulus: 4 bytes\n"); 286 ctx->tx_modulus = USB_CDC_NCM_NDP_ALIGN_MIN_SIZE; 287 } 288 289 /* verify the payload remainder */ 290 if (ctx->tx_remainder >= ctx->tx_modulus) { 291 pr_debug("Using default transmit remainder: 0 bytes\n"); 292 ctx->tx_remainder = 0; 293 } 294 295 /* adjust TX-remainder according to NCM specification. */ 296 ctx->tx_remainder = ((ctx->tx_remainder - ETH_HLEN) & 297 (ctx->tx_modulus - 1)); 298 299 /* additional configuration */ 300 301 /* set CRC Mode */ 302 if (flags & USB_CDC_NCM_NCAP_CRC_MODE) { 303 err = usb_control_msg(ctx->udev, usb_sndctrlpipe(ctx->udev, 0), 304 USB_CDC_SET_CRC_MODE, 305 USB_TYPE_CLASS | USB_DIR_OUT 306 | USB_RECIP_INTERFACE, 307 USB_CDC_NCM_CRC_NOT_APPENDED, 308 iface_no, NULL, 0, 1000); 309 if (err < 0) 310 pr_debug("Setting CRC mode off failed\n"); 311 } 312 313 /* set NTB format, if both formats are supported */ 314 if (ntb_fmt_supported & USB_CDC_NCM_NTH32_SIGN) { 315 err = usb_control_msg(ctx->udev, usb_sndctrlpipe(ctx->udev, 0), 316 USB_CDC_SET_NTB_FORMAT, USB_TYPE_CLASS 317 | USB_DIR_OUT | USB_RECIP_INTERFACE, 318 USB_CDC_NCM_NTB16_FORMAT, 319 iface_no, NULL, 0, 1000); 320 if (err < 0) 321 pr_debug("Setting NTB format to 16-bit failed\n"); 322 } 323 324 ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE; 325 326 /* set Max Datagram Size (MTU) */ 327 if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) { 328 __le16 max_datagram_size; 329 u16 eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize); 330 err = usb_control_msg(ctx->udev, usb_rcvctrlpipe(ctx->udev, 0), 331 USB_CDC_GET_MAX_DATAGRAM_SIZE, 332 USB_TYPE_CLASS | USB_DIR_IN 333 | USB_RECIP_INTERFACE, 334 0, iface_no, &max_datagram_size, 335 2, 1000); 336 if (err < 0) { 337 pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n", 338 CDC_NCM_MIN_DATAGRAM_SIZE); 339 } else { 340 ctx->max_datagram_size = le16_to_cpu(max_datagram_size); 341 /* Check Eth descriptor value */ 342 if (eth_max_sz < CDC_NCM_MAX_DATAGRAM_SIZE) { 343 if (ctx->max_datagram_size > eth_max_sz) 344 ctx->max_datagram_size = eth_max_sz; 345 } else { 346 if (ctx->max_datagram_size > 347 CDC_NCM_MAX_DATAGRAM_SIZE) 348 ctx->max_datagram_size = 349 CDC_NCM_MAX_DATAGRAM_SIZE; 350 } 351 352 if (ctx->max_datagram_size < CDC_NCM_MIN_DATAGRAM_SIZE) 353 ctx->max_datagram_size = 354 CDC_NCM_MIN_DATAGRAM_SIZE; 355 356 /* if value changed, update device */ 357 err = usb_control_msg(ctx->udev, 358 usb_sndctrlpipe(ctx->udev, 0), 359 USB_CDC_SET_MAX_DATAGRAM_SIZE, 360 USB_TYPE_CLASS | USB_DIR_OUT 361 | USB_RECIP_INTERFACE, 362 0, 363 iface_no, &max_datagram_size, 364 2, 1000); 365 if (err < 0) 366 pr_debug("SET_MAX_DATAGRAM_SIZE failed\n"); 367 } 368 369 } 370 371 if (ctx->netdev->mtu != (ctx->max_datagram_size - ETH_HLEN)) 372 ctx->netdev->mtu = ctx->max_datagram_size - ETH_HLEN; 373 374 return 0; 375 } 376 377 static void 378 cdc_ncm_find_endpoints(struct cdc_ncm_ctx *ctx, struct usb_interface *intf) 379 { 380 struct usb_host_endpoint *e; 381 u8 ep; 382 383 for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) { 384 385 e = intf->cur_altsetting->endpoint + ep; 386 switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { 387 case USB_ENDPOINT_XFER_INT: 388 if (usb_endpoint_dir_in(&e->desc)) { 389 if (ctx->status_ep == NULL) 390 ctx->status_ep = e; 391 } 392 break; 393 394 case USB_ENDPOINT_XFER_BULK: 395 if (usb_endpoint_dir_in(&e->desc)) { 396 if (ctx->in_ep == NULL) 397 ctx->in_ep = e; 398 } else { 399 if (ctx->out_ep == NULL) 400 ctx->out_ep = e; 401 } 402 break; 403 404 default: 405 break; 406 } 407 } 408 } 409 410 static void cdc_ncm_free(struct cdc_ncm_ctx *ctx) 411 { 412 if (ctx == NULL) 413 return; 414 415 del_timer_sync(&ctx->tx_timer); 416 417 if (ctx->tx_rem_skb != NULL) { 418 dev_kfree_skb_any(ctx->tx_rem_skb); 419 ctx->tx_rem_skb = NULL; 420 } 421 422 if (ctx->tx_curr_skb != NULL) { 423 dev_kfree_skb_any(ctx->tx_curr_skb); 424 ctx->tx_curr_skb = NULL; 425 } 426 427 kfree(ctx); 428 } 429 430 static int cdc_ncm_bind(struct usbnet *dev, struct usb_interface *intf) 431 { 432 struct cdc_ncm_ctx *ctx; 433 struct usb_driver *driver; 434 u8 *buf; 435 int len; 436 int temp; 437 u8 iface_no; 438 439 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); 440 if (ctx == NULL) 441 return -ENODEV; 442 443 memset(ctx, 0, sizeof(*ctx)); 444 445 init_timer(&ctx->tx_timer); 446 spin_lock_init(&ctx->mtx); 447 ctx->netdev = dev->net; 448 449 /* store ctx pointer in device data field */ 450 dev->data[0] = (unsigned long)ctx; 451 452 /* get some pointers */ 453 driver = driver_of(intf); 454 buf = intf->cur_altsetting->extra; 455 len = intf->cur_altsetting->extralen; 456 457 ctx->udev = dev->udev; 458 ctx->intf = intf; 459 460 /* parse through descriptors associated with control interface */ 461 while ((len > 0) && (buf[0] > 2) && (buf[0] <= len)) { 462 463 if (buf[1] != USB_DT_CS_INTERFACE) 464 goto advance; 465 466 switch (buf[2]) { 467 case USB_CDC_UNION_TYPE: 468 if (buf[0] < sizeof(*(ctx->union_desc))) 469 break; 470 471 ctx->union_desc = 472 (const struct usb_cdc_union_desc *)buf; 473 474 ctx->control = usb_ifnum_to_if(dev->udev, 475 ctx->union_desc->bMasterInterface0); 476 ctx->data = usb_ifnum_to_if(dev->udev, 477 ctx->union_desc->bSlaveInterface0); 478 break; 479 480 case USB_CDC_ETHERNET_TYPE: 481 if (buf[0] < sizeof(*(ctx->ether_desc))) 482 break; 483 484 ctx->ether_desc = 485 (const struct usb_cdc_ether_desc *)buf; 486 dev->hard_mtu = 487 le16_to_cpu(ctx->ether_desc->wMaxSegmentSize); 488 489 if (dev->hard_mtu < CDC_NCM_MIN_DATAGRAM_SIZE) 490 dev->hard_mtu = CDC_NCM_MIN_DATAGRAM_SIZE; 491 else if (dev->hard_mtu > CDC_NCM_MAX_DATAGRAM_SIZE) 492 dev->hard_mtu = CDC_NCM_MAX_DATAGRAM_SIZE; 493 break; 494 495 case USB_CDC_NCM_TYPE: 496 if (buf[0] < sizeof(*(ctx->func_desc))) 497 break; 498 499 ctx->func_desc = (const struct usb_cdc_ncm_desc *)buf; 500 break; 501 502 default: 503 break; 504 } 505 advance: 506 /* advance to next descriptor */ 507 temp = buf[0]; 508 buf += temp; 509 len -= temp; 510 } 511 512 /* check if we got everything */ 513 if ((ctx->control == NULL) || (ctx->data == NULL) || 514 (ctx->ether_desc == NULL) || (ctx->control != intf)) 515 goto error; 516 517 /* claim interfaces, if any */ 518 temp = usb_driver_claim_interface(driver, ctx->data, dev); 519 if (temp) 520 goto error; 521 522 iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber; 523 524 /* reset data interface */ 525 temp = usb_set_interface(dev->udev, iface_no, 0); 526 if (temp) 527 goto error2; 528 529 /* initialize data interface */ 530 if (cdc_ncm_setup(ctx)) 531 goto error2; 532 533 /* configure data interface */ 534 temp = usb_set_interface(dev->udev, iface_no, 1); 535 if (temp) 536 goto error2; 537 538 cdc_ncm_find_endpoints(ctx, ctx->data); 539 cdc_ncm_find_endpoints(ctx, ctx->control); 540 541 if ((ctx->in_ep == NULL) || (ctx->out_ep == NULL) || 542 (ctx->status_ep == NULL)) 543 goto error2; 544 545 dev->net->ethtool_ops = &cdc_ncm_ethtool_ops; 546 547 usb_set_intfdata(ctx->data, dev); 548 usb_set_intfdata(ctx->control, dev); 549 usb_set_intfdata(ctx->intf, dev); 550 551 temp = usbnet_get_ethernet_addr(dev, ctx->ether_desc->iMACAddress); 552 if (temp) 553 goto error2; 554 555 dev_info(&dev->udev->dev, "MAC-Address: " 556 "0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x\n", 557 dev->net->dev_addr[0], dev->net->dev_addr[1], 558 dev->net->dev_addr[2], dev->net->dev_addr[3], 559 dev->net->dev_addr[4], dev->net->dev_addr[5]); 560 561 dev->in = usb_rcvbulkpipe(dev->udev, 562 ctx->in_ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 563 dev->out = usb_sndbulkpipe(dev->udev, 564 ctx->out_ep->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 565 dev->status = ctx->status_ep; 566 dev->rx_urb_size = ctx->rx_max; 567 568 /* 569 * We should get an event when network connection is "connected" or 570 * "disconnected". Set network connection in "disconnected" state 571 * (carrier is OFF) during attach, so the IP network stack does not 572 * start IPv6 negotiation and more. 573 */ 574 netif_carrier_off(dev->net); 575 ctx->tx_speed = ctx->rx_speed = 0; 576 return 0; 577 578 error2: 579 usb_set_intfdata(ctx->control, NULL); 580 usb_set_intfdata(ctx->data, NULL); 581 usb_driver_release_interface(driver, ctx->data); 582 error: 583 cdc_ncm_free((struct cdc_ncm_ctx *)dev->data[0]); 584 dev->data[0] = 0; 585 dev_info(&dev->udev->dev, "bind() failure\n"); 586 return -ENODEV; 587 } 588 589 static void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf) 590 { 591 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 592 struct usb_driver *driver = driver_of(intf); 593 594 if (ctx == NULL) 595 return; /* no setup */ 596 597 /* disconnect master --> disconnect slave */ 598 if (intf == ctx->control && ctx->data) { 599 usb_set_intfdata(ctx->data, NULL); 600 usb_driver_release_interface(driver, ctx->data); 601 ctx->data = NULL; 602 603 } else if (intf == ctx->data && ctx->control) { 604 usb_set_intfdata(ctx->control, NULL); 605 usb_driver_release_interface(driver, ctx->control); 606 ctx->control = NULL; 607 } 608 609 usb_set_intfdata(ctx->intf, NULL); 610 cdc_ncm_free(ctx); 611 } 612 613 static void cdc_ncm_zero_fill(u8 *ptr, u32 first, u32 end, u32 max) 614 { 615 if (first >= max) 616 return; 617 if (first >= end) 618 return; 619 if (end > max) 620 end = max; 621 memset(ptr + first, 0, end - first); 622 } 623 624 static struct sk_buff * 625 cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb) 626 { 627 struct sk_buff *skb_out; 628 u32 rem; 629 u32 offset; 630 u32 last_offset; 631 u16 n = 0, index; 632 u8 ready2send = 0; 633 634 /* if there is a remaining skb, it gets priority */ 635 if (skb != NULL) 636 swap(skb, ctx->tx_rem_skb); 637 else 638 ready2send = 1; 639 640 /* 641 * +----------------+ 642 * | skb_out | 643 * +----------------+ 644 * ^ offset 645 * ^ last_offset 646 */ 647 648 /* check if we are resuming an OUT skb */ 649 if (ctx->tx_curr_skb != NULL) { 650 /* pop variables */ 651 skb_out = ctx->tx_curr_skb; 652 offset = ctx->tx_curr_offset; 653 last_offset = ctx->tx_curr_last_offset; 654 n = ctx->tx_curr_frame_num; 655 656 } else { 657 /* reset variables */ 658 skb_out = alloc_skb((ctx->tx_max + 1), GFP_ATOMIC); 659 if (skb_out == NULL) { 660 if (skb != NULL) { 661 dev_kfree_skb_any(skb); 662 ctx->netdev->stats.tx_dropped++; 663 } 664 goto exit_no_skb; 665 } 666 667 /* make room for NTH and NDP */ 668 offset = ALIGN(sizeof(struct usb_cdc_ncm_nth16), 669 ctx->tx_ndp_modulus) + 670 sizeof(struct usb_cdc_ncm_ndp16) + 671 (ctx->tx_max_datagrams + 1) * 672 sizeof(struct usb_cdc_ncm_dpe16); 673 674 /* store last valid offset before alignment */ 675 last_offset = offset; 676 /* align first Datagram offset correctly */ 677 offset = ALIGN(offset, ctx->tx_modulus) + ctx->tx_remainder; 678 /* zero buffer till the first IP datagram */ 679 cdc_ncm_zero_fill(skb_out->data, 0, offset, offset); 680 n = 0; 681 ctx->tx_curr_frame_num = 0; 682 } 683 684 for (; n < ctx->tx_max_datagrams; n++) { 685 /* check if end of transmit buffer is reached */ 686 if (offset >= ctx->tx_max) { 687 ready2send = 1; 688 break; 689 } 690 /* compute maximum buffer size */ 691 rem = ctx->tx_max - offset; 692 693 if (skb == NULL) { 694 skb = ctx->tx_rem_skb; 695 ctx->tx_rem_skb = NULL; 696 697 /* check for end of skb */ 698 if (skb == NULL) 699 break; 700 } 701 702 if (skb->len > rem) { 703 if (n == 0) { 704 /* won't fit, MTU problem? */ 705 dev_kfree_skb_any(skb); 706 skb = NULL; 707 ctx->netdev->stats.tx_dropped++; 708 } else { 709 /* no room for skb - store for later */ 710 if (ctx->tx_rem_skb != NULL) { 711 dev_kfree_skb_any(ctx->tx_rem_skb); 712 ctx->netdev->stats.tx_dropped++; 713 } 714 ctx->tx_rem_skb = skb; 715 skb = NULL; 716 ready2send = 1; 717 } 718 break; 719 } 720 721 memcpy(((u8 *)skb_out->data) + offset, skb->data, skb->len); 722 723 ctx->tx_ncm.dpe16[n].wDatagramLength = cpu_to_le16(skb->len); 724 ctx->tx_ncm.dpe16[n].wDatagramIndex = cpu_to_le16(offset); 725 726 /* update offset */ 727 offset += skb->len; 728 729 /* store last valid offset before alignment */ 730 last_offset = offset; 731 732 /* align offset correctly */ 733 offset = ALIGN(offset, ctx->tx_modulus) + ctx->tx_remainder; 734 735 /* zero padding */ 736 cdc_ncm_zero_fill(skb_out->data, last_offset, offset, 737 ctx->tx_max); 738 dev_kfree_skb_any(skb); 739 skb = NULL; 740 } 741 742 /* free up any dangling skb */ 743 if (skb != NULL) { 744 dev_kfree_skb_any(skb); 745 skb = NULL; 746 ctx->netdev->stats.tx_dropped++; 747 } 748 749 ctx->tx_curr_frame_num = n; 750 751 if (n == 0) { 752 /* wait for more frames */ 753 /* push variables */ 754 ctx->tx_curr_skb = skb_out; 755 ctx->tx_curr_offset = offset; 756 ctx->tx_curr_last_offset = last_offset; 757 goto exit_no_skb; 758 759 } else if ((n < ctx->tx_max_datagrams) && (ready2send == 0)) { 760 /* wait for more frames */ 761 /* push variables */ 762 ctx->tx_curr_skb = skb_out; 763 ctx->tx_curr_offset = offset; 764 ctx->tx_curr_last_offset = last_offset; 765 /* set the pending count */ 766 if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT) 767 ctx->tx_timer_pending = 2; 768 goto exit_no_skb; 769 770 } else { 771 /* frame goes out */ 772 /* variables will be reset at next call */ 773 } 774 775 /* check for overflow */ 776 if (last_offset > ctx->tx_max) 777 last_offset = ctx->tx_max; 778 779 /* revert offset */ 780 offset = last_offset; 781 782 /* 783 * If collected data size is less or equal CDC_NCM_MIN_TX_PKT bytes, 784 * we send buffers as it is. If we get more data, it would be more 785 * efficient for USB HS mobile device with DMA engine to receive a full 786 * size NTB, than canceling DMA transfer and receiving a short packet. 787 */ 788 if (offset > CDC_NCM_MIN_TX_PKT) 789 offset = ctx->tx_max; 790 791 /* final zero padding */ 792 cdc_ncm_zero_fill(skb_out->data, last_offset, offset, ctx->tx_max); 793 794 /* store last offset */ 795 last_offset = offset; 796 797 if (((last_offset < ctx->tx_max) && ((last_offset % 798 le16_to_cpu(ctx->out_ep->desc.wMaxPacketSize)) == 0)) || 799 (((last_offset == ctx->tx_max) && ((ctx->tx_max % 800 le16_to_cpu(ctx->out_ep->desc.wMaxPacketSize)) == 0)) && 801 (ctx->tx_max < le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize)))) { 802 /* force short packet */ 803 *(((u8 *)skb_out->data) + last_offset) = 0; 804 last_offset++; 805 } 806 807 /* zero the rest of the DPEs plus the last NULL entry */ 808 for (; n <= CDC_NCM_DPT_DATAGRAMS_MAX; n++) { 809 ctx->tx_ncm.dpe16[n].wDatagramLength = 0; 810 ctx->tx_ncm.dpe16[n].wDatagramIndex = 0; 811 } 812 813 /* fill out 16-bit NTB header */ 814 ctx->tx_ncm.nth16.dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN); 815 ctx->tx_ncm.nth16.wHeaderLength = 816 cpu_to_le16(sizeof(ctx->tx_ncm.nth16)); 817 ctx->tx_ncm.nth16.wSequence = cpu_to_le16(ctx->tx_seq); 818 ctx->tx_ncm.nth16.wBlockLength = cpu_to_le16(last_offset); 819 index = ALIGN(sizeof(struct usb_cdc_ncm_nth16), ctx->tx_ndp_modulus); 820 ctx->tx_ncm.nth16.wNdpIndex = cpu_to_le16(index); 821 822 memcpy(skb_out->data, &(ctx->tx_ncm.nth16), sizeof(ctx->tx_ncm.nth16)); 823 ctx->tx_seq++; 824 825 /* fill out 16-bit NDP table */ 826 ctx->tx_ncm.ndp16.dwSignature = 827 cpu_to_le32(USB_CDC_NCM_NDP16_NOCRC_SIGN); 828 rem = sizeof(ctx->tx_ncm.ndp16) + ((ctx->tx_curr_frame_num + 1) * 829 sizeof(struct usb_cdc_ncm_dpe16)); 830 ctx->tx_ncm.ndp16.wLength = cpu_to_le16(rem); 831 ctx->tx_ncm.ndp16.wNextNdpIndex = 0; /* reserved */ 832 833 memcpy(((u8 *)skb_out->data) + index, 834 &(ctx->tx_ncm.ndp16), 835 sizeof(ctx->tx_ncm.ndp16)); 836 837 memcpy(((u8 *)skb_out->data) + index + sizeof(ctx->tx_ncm.ndp16), 838 &(ctx->tx_ncm.dpe16), 839 (ctx->tx_curr_frame_num + 1) * 840 sizeof(struct usb_cdc_ncm_dpe16)); 841 842 /* set frame length */ 843 skb_put(skb_out, last_offset); 844 845 /* return skb */ 846 ctx->tx_curr_skb = NULL; 847 return skb_out; 848 849 exit_no_skb: 850 return NULL; 851 } 852 853 static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx) 854 { 855 /* start timer, if not already started */ 856 if (timer_pending(&ctx->tx_timer) == 0) { 857 ctx->tx_timer.function = &cdc_ncm_tx_timeout; 858 ctx->tx_timer.data = (unsigned long)ctx; 859 ctx->tx_timer.expires = jiffies + ((HZ + 999) / 1000); 860 add_timer(&ctx->tx_timer); 861 } 862 } 863 864 static void cdc_ncm_tx_timeout(unsigned long arg) 865 { 866 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)arg; 867 u8 restart; 868 869 spin_lock(&ctx->mtx); 870 if (ctx->tx_timer_pending != 0) { 871 ctx->tx_timer_pending--; 872 restart = 1; 873 } else { 874 restart = 0; 875 } 876 877 spin_unlock(&ctx->mtx); 878 879 if (restart) { 880 spin_lock(&ctx->mtx); 881 cdc_ncm_tx_timeout_start(ctx); 882 spin_unlock(&ctx->mtx); 883 } else if (ctx->netdev != NULL) { 884 usbnet_start_xmit(NULL, ctx->netdev); 885 } 886 } 887 888 static struct sk_buff * 889 cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags) 890 { 891 struct sk_buff *skb_out; 892 struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0]; 893 u8 need_timer = 0; 894 895 /* 896 * The Ethernet API we are using does not support transmitting 897 * multiple Ethernet frames in a single call. This driver will 898 * accumulate multiple Ethernet frames and send out a larger 899 * USB frame when the USB buffer is full or when a single jiffies 900 * timeout happens. 901 */ 902 if (ctx == NULL) 903 goto error; 904 905 spin_lock(&ctx->mtx); 906 skb_out = cdc_ncm_fill_tx_frame(ctx, skb); 907 if (ctx->tx_curr_skb != NULL) 908 need_timer = 1; 909 910 /* Start timer, if there is a remaining skb */ 911 if (need_timer) 912 cdc_ncm_tx_timeout_start(ctx); 913 914 if (skb_out) 915 dev->net->stats.tx_packets += ctx->tx_curr_frame_num; 916 917 spin_unlock(&ctx->mtx); 918 return skb_out; 919 920 error: 921 if (skb != NULL) 922 dev_kfree_skb_any(skb); 923 924 return NULL; 925 } 926 927 static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in) 928 { 929 struct sk_buff *skb; 930 struct cdc_ncm_ctx *ctx; 931 int sumlen; 932 int actlen; 933 int temp; 934 int nframes; 935 int x; 936 int offset; 937 938 ctx = (struct cdc_ncm_ctx *)dev->data[0]; 939 if (ctx == NULL) 940 goto error; 941 942 actlen = skb_in->len; 943 sumlen = CDC_NCM_NTB_MAX_SIZE_RX; 944 945 if (actlen < (sizeof(ctx->rx_ncm.nth16) + sizeof(ctx->rx_ncm.ndp16))) { 946 pr_debug("frame too short\n"); 947 goto error; 948 } 949 950 memcpy(&(ctx->rx_ncm.nth16), ((u8 *)skb_in->data), 951 sizeof(ctx->rx_ncm.nth16)); 952 953 if (le32_to_cpu(ctx->rx_ncm.nth16.dwSignature) != 954 USB_CDC_NCM_NTH16_SIGN) { 955 pr_debug("invalid NTH16 signature <%u>\n", 956 le32_to_cpu(ctx->rx_ncm.nth16.dwSignature)); 957 goto error; 958 } 959 960 temp = le16_to_cpu(ctx->rx_ncm.nth16.wBlockLength); 961 if (temp > sumlen) { 962 pr_debug("unsupported NTB block length %u/%u\n", temp, sumlen); 963 goto error; 964 } 965 966 temp = le16_to_cpu(ctx->rx_ncm.nth16.wNdpIndex); 967 if ((temp + sizeof(ctx->rx_ncm.ndp16)) > actlen) { 968 pr_debug("invalid DPT16 index\n"); 969 goto error; 970 } 971 972 memcpy(&(ctx->rx_ncm.ndp16), ((u8 *)skb_in->data) + temp, 973 sizeof(ctx->rx_ncm.ndp16)); 974 975 if (le32_to_cpu(ctx->rx_ncm.ndp16.dwSignature) != 976 USB_CDC_NCM_NDP16_NOCRC_SIGN) { 977 pr_debug("invalid DPT16 signature <%u>\n", 978 le32_to_cpu(ctx->rx_ncm.ndp16.dwSignature)); 979 goto error; 980 } 981 982 if (le16_to_cpu(ctx->rx_ncm.ndp16.wLength) < 983 USB_CDC_NCM_NDP16_LENGTH_MIN) { 984 pr_debug("invalid DPT16 length <%u>\n", 985 le32_to_cpu(ctx->rx_ncm.ndp16.dwSignature)); 986 goto error; 987 } 988 989 nframes = ((le16_to_cpu(ctx->rx_ncm.ndp16.wLength) - 990 sizeof(struct usb_cdc_ncm_ndp16)) / 991 sizeof(struct usb_cdc_ncm_dpe16)); 992 nframes--; /* we process NDP entries except for the last one */ 993 994 pr_debug("nframes = %u\n", nframes); 995 996 temp += sizeof(ctx->rx_ncm.ndp16); 997 998 if ((temp + nframes * (sizeof(struct usb_cdc_ncm_dpe16))) > actlen) { 999 pr_debug("Invalid nframes = %d\n", nframes); 1000 goto error; 1001 } 1002 1003 if (nframes > CDC_NCM_DPT_DATAGRAMS_MAX) { 1004 pr_debug("Truncating number of frames from %u to %u\n", 1005 nframes, CDC_NCM_DPT_DATAGRAMS_MAX); 1006 nframes = CDC_NCM_DPT_DATAGRAMS_MAX; 1007 } 1008 1009 memcpy(&(ctx->rx_ncm.dpe16), ((u8 *)skb_in->data) + temp, 1010 nframes * (sizeof(struct usb_cdc_ncm_dpe16))); 1011 1012 for (x = 0; x < nframes; x++) { 1013 offset = le16_to_cpu(ctx->rx_ncm.dpe16[x].wDatagramIndex); 1014 temp = le16_to_cpu(ctx->rx_ncm.dpe16[x].wDatagramLength); 1015 1016 /* 1017 * CDC NCM ch. 3.7 1018 * All entries after first NULL entry are to be ignored 1019 */ 1020 if ((offset == 0) || (temp == 0)) { 1021 if (!x) 1022 goto error; /* empty NTB */ 1023 break; 1024 } 1025 1026 /* sanity checking */ 1027 if (((offset + temp) > actlen) || 1028 (temp > CDC_NCM_MAX_DATAGRAM_SIZE) || (temp < ETH_HLEN)) { 1029 pr_debug("invalid frame detected (ignored)" 1030 "offset[%u]=%u, length=%u, skb=%p\n", 1031 x, offset, temp, skb_in); 1032 if (!x) 1033 goto error; 1034 break; 1035 1036 } else { 1037 skb = skb_clone(skb_in, GFP_ATOMIC); 1038 if (!skb) 1039 goto error; 1040 skb->len = temp; 1041 skb->data = ((u8 *)skb_in->data) + offset; 1042 skb_set_tail_pointer(skb, temp); 1043 usbnet_skb_return(dev, skb); 1044 } 1045 } 1046 return 1; 1047 error: 1048 return 0; 1049 } 1050 1051 static void 1052 cdc_ncm_speed_change(struct cdc_ncm_ctx *ctx, 1053 struct usb_cdc_speed_change *data) 1054 { 1055 uint32_t rx_speed = le32_to_cpu(data->DLBitRRate); 1056 uint32_t tx_speed = le32_to_cpu(data->ULBitRate); 1057 1058 /* 1059 * Currently the USB-NET API does not support reporting the actual 1060 * device speed. Do print it instead. 1061 */ 1062 if ((tx_speed != ctx->tx_speed) || (rx_speed != ctx->rx_speed)) { 1063 ctx->tx_speed = tx_speed; 1064 ctx->rx_speed = rx_speed; 1065 1066 if ((tx_speed > 1000000) && (rx_speed > 1000000)) { 1067 printk(KERN_INFO KBUILD_MODNAME 1068 ": %s: %u mbit/s downlink " 1069 "%u mbit/s uplink\n", 1070 ctx->netdev->name, 1071 (unsigned int)(rx_speed / 1000000U), 1072 (unsigned int)(tx_speed / 1000000U)); 1073 } else { 1074 printk(KERN_INFO KBUILD_MODNAME 1075 ": %s: %u kbit/s downlink " 1076 "%u kbit/s uplink\n", 1077 ctx->netdev->name, 1078 (unsigned int)(rx_speed / 1000U), 1079 (unsigned int)(tx_speed / 1000U)); 1080 } 1081 } 1082 } 1083 1084 static void cdc_ncm_status(struct usbnet *dev, struct urb *urb) 1085 { 1086 struct cdc_ncm_ctx *ctx; 1087 struct usb_cdc_notification *event; 1088 1089 ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1090 1091 if (urb->actual_length < sizeof(*event)) 1092 return; 1093 1094 /* test for split data in 8-byte chunks */ 1095 if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { 1096 cdc_ncm_speed_change(ctx, 1097 (struct usb_cdc_speed_change *)urb->transfer_buffer); 1098 return; 1099 } 1100 1101 event = urb->transfer_buffer; 1102 1103 switch (event->bNotificationType) { 1104 case USB_CDC_NOTIFY_NETWORK_CONNECTION: 1105 /* 1106 * According to the CDC NCM specification ch.7.1 1107 * USB_CDC_NOTIFY_NETWORK_CONNECTION notification shall be 1108 * sent by device after USB_CDC_NOTIFY_SPEED_CHANGE. 1109 */ 1110 ctx->connected = event->wValue; 1111 1112 printk(KERN_INFO KBUILD_MODNAME ": %s: network connection:" 1113 " %sconnected\n", 1114 ctx->netdev->name, ctx->connected ? "" : "dis"); 1115 1116 if (ctx->connected) 1117 netif_carrier_on(dev->net); 1118 else { 1119 netif_carrier_off(dev->net); 1120 ctx->tx_speed = ctx->rx_speed = 0; 1121 } 1122 break; 1123 1124 case USB_CDC_NOTIFY_SPEED_CHANGE: 1125 if (urb->actual_length < (sizeof(*event) + 1126 sizeof(struct usb_cdc_speed_change))) 1127 set_bit(EVENT_STS_SPLIT, &dev->flags); 1128 else 1129 cdc_ncm_speed_change(ctx, 1130 (struct usb_cdc_speed_change *) &event[1]); 1131 break; 1132 1133 default: 1134 dev_err(&dev->udev->dev, "NCM: unexpected " 1135 "notification 0x%02x!\n", event->bNotificationType); 1136 break; 1137 } 1138 } 1139 1140 static int cdc_ncm_check_connect(struct usbnet *dev) 1141 { 1142 struct cdc_ncm_ctx *ctx; 1143 1144 ctx = (struct cdc_ncm_ctx *)dev->data[0]; 1145 if (ctx == NULL) 1146 return 1; /* disconnected */ 1147 1148 return !ctx->connected; 1149 } 1150 1151 static int 1152 cdc_ncm_probe(struct usb_interface *udev, const struct usb_device_id *prod) 1153 { 1154 return usbnet_probe(udev, prod); 1155 } 1156 1157 static void cdc_ncm_disconnect(struct usb_interface *intf) 1158 { 1159 struct usbnet *dev = usb_get_intfdata(intf); 1160 1161 if (dev == NULL) 1162 return; /* already disconnected */ 1163 1164 usbnet_disconnect(intf); 1165 } 1166 1167 static int cdc_ncm_manage_power(struct usbnet *dev, int status) 1168 { 1169 dev->intf->needs_remote_wakeup = status; 1170 return 0; 1171 } 1172 1173 static const struct driver_info cdc_ncm_info = { 1174 .description = "CDC NCM", 1175 .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT | FLAG_MULTI_PACKET, 1176 .bind = cdc_ncm_bind, 1177 .unbind = cdc_ncm_unbind, 1178 .check_connect = cdc_ncm_check_connect, 1179 .manage_power = cdc_ncm_manage_power, 1180 .status = cdc_ncm_status, 1181 .rx_fixup = cdc_ncm_rx_fixup, 1182 .tx_fixup = cdc_ncm_tx_fixup, 1183 }; 1184 1185 static struct usb_driver cdc_ncm_driver = { 1186 .name = "cdc_ncm", 1187 .id_table = cdc_devs, 1188 .probe = cdc_ncm_probe, 1189 .disconnect = cdc_ncm_disconnect, 1190 .suspend = usbnet_suspend, 1191 .resume = usbnet_resume, 1192 .reset_resume = usbnet_resume, 1193 .supports_autosuspend = 1, 1194 }; 1195 1196 static struct ethtool_ops cdc_ncm_ethtool_ops = { 1197 .get_drvinfo = cdc_ncm_get_drvinfo, 1198 .get_link = usbnet_get_link, 1199 .get_msglevel = usbnet_get_msglevel, 1200 .set_msglevel = usbnet_set_msglevel, 1201 .get_settings = usbnet_get_settings, 1202 .set_settings = usbnet_set_settings, 1203 .nway_reset = usbnet_nway_reset, 1204 }; 1205 1206 static int __init cdc_ncm_init(void) 1207 { 1208 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION "\n"); 1209 return usb_register(&cdc_ncm_driver); 1210 } 1211 1212 module_init(cdc_ncm_init); 1213 1214 static void __exit cdc_ncm_exit(void) 1215 { 1216 usb_deregister(&cdc_ncm_driver); 1217 } 1218 1219 module_exit(cdc_ncm_exit); 1220 1221 MODULE_AUTHOR("Hans Petter Selasky"); 1222 MODULE_DESCRIPTION("USB CDC NCM host driver"); 1223 MODULE_LICENSE("Dual BSD/GPL"); 1224