qemu/roms/ipxe/src/drivers/net/ncm.c

   1 /*
   2  * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <ipxe/netdevice.h>
  29 #include <ipxe/ethernet.h>
  30 #include <ipxe/if_ether.h>
  31 #include <ipxe/profile.h>
  32 #include <ipxe/usb.h>
  33 #include <ipxe/usbnet.h>
  34 #include "ecm.h"
  35 #include "ncm.h"
  36
  37 /** @file
  38  *
  39  * CDC-NCM USB Ethernet driver
  40  *
  41  */
  42
  43 /** Interrupt completion profiler */
  44 static struct profiler ncm_intr_profiler __profiler =
  45         { .name = "ncm.intr" };
  46
  47 /** Bulk IN completion profiler */
  48 static struct profiler ncm_in_profiler __profiler =
  49         { .name = "ncm.in" };
  50
  51 /** Bulk IN per-datagram profiler */
  52 static struct profiler ncm_in_datagram_profiler __profiler =
  53         { .name = "ncm.in_dgram" };
  54
  55 /** Bulk OUT profiler */
  56 static struct profiler ncm_out_profiler __profiler =
  57         { .name = "ncm.out" };
  58
  59 /******************************************************************************
  60  *
  61  * CDC-NCM communications interface
  62  *
  63  ******************************************************************************
  64  */
  65
  66 /**
  67  * Complete interrupt transfer
  68  *
  69  * @v ep                USB endpoint
  70  * @v iobuf             I/O buffer
  71  * @v rc                Completion status code
  72  */
  73 static void ncm_intr_complete ( struct usb_endpoint *ep,
  74                                 struct io_buffer *iobuf, int rc ) {
  75         struct ncm_device *ncm = container_of ( ep, struct ncm_device,
  76                                                 usbnet.intr );
  77         struct net_device *netdev = ncm->netdev;
  78         struct usb_setup_packet *message;
  79         size_t len = iob_len ( iobuf );
  80
  81         /* Profile completions */
  82         profile_start ( &ncm_intr_profiler );
  83
  84         /* Ignore packets cancelled when the endpoint closes */
  85         if ( ! ep->open )
  86                 goto ignore;
  87
  88         /* Ignore packets with errors */
  89         if ( rc != 0 ) {
  90                 DBGC ( ncm, "NCM %p interrupt failed: %s\n",
  91                        ncm, strerror ( rc ) );
  92                 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
  93                 goto error;
  94         }
  95
  96         /* Extract message header */
  97         if ( len < sizeof ( *message ) ) {
  98                 DBGC ( ncm, "NCM %p underlength interrupt:\n", ncm );
  99                 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
 100                 rc = -EINVAL;
 101                 goto error;
 102         }
 103         message = iobuf->data;
 104
 105         /* Parse message header */
 106         switch ( message->request ) {
 107
 108         case cpu_to_le16 ( CDC_NETWORK_CONNECTION ) :
 109                 if ( message->value ) {
 110                         DBGC ( ncm, "NCM %p link up\n", ncm );
 111                         netdev_link_up ( netdev );
 112                 } else {
 113                         DBGC ( ncm, "NCM %p link down\n", ncm );
 114                         netdev_link_down ( netdev );
 115                 }
 116                 break;
 117
 118         case cpu_to_le16 ( CDC_CONNECTION_SPEED_CHANGE ) :
 119                 /* Ignore */
 120                 break;
 121
 122         default:
 123                 DBGC ( ncm, "NCM %p unrecognised interrupt:\n", ncm );
 124                 DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
 125                 goto error;
 126         }
 127
 128         /* Free I/O buffer */
 129         free_iob ( iobuf );
 130         profile_stop ( &ncm_intr_profiler );
 131
 132         return;
 133
 134  error:
 135         netdev_rx_err ( netdev, iob_disown ( iobuf ), rc );
 136  ignore:
 137         free_iob ( iobuf );
 138         return;
 139 }
 140
 141 /** Interrupt endpoint operations */
 142 static struct usb_endpoint_driver_operations ncm_intr_operations = {
 143         .complete = ncm_intr_complete,
 144 };
 145
 146 /******************************************************************************
 147  *
 148  * CDC-NCM data interface
 149  *
 150  ******************************************************************************
 151  */
 152
 153 /**
 154  * Prefill bulk IN endpoint
 155  *
 156  * @v ncm               CDC-NCM device
 157  * @ret rc              Return status code
 158  */
 159 static int ncm_in_prefill ( struct ncm_device *ncm ) {
 160         struct usb_bus *bus = ncm->bus;
 161         size_t mtu;
 162         unsigned int count;
 163         int rc;
 164
 165         /* Some devices have a very small number of internal buffers,
 166          * and rely on being able to pack multiple packets into each
 167          * buffer.  We therefore want to use large buffers if
 168          * possible.  However, large allocations have a reasonable
 169          * chance of failure, especially if this is not the first or
 170          * only device to be opened.
 171          *
 172          * We therefore attempt to find a usable buffer size, starting
 173          * large and working downwards until allocation succeeds.
 174          * Smaller buffers will still work, albeit with a higher
 175          * chance of packet loss and so lower overall throughput.
 176          */
 177         for ( mtu = ncm->mtu ; mtu >= NCM_MIN_NTB_INPUT_SIZE ; mtu >>= 1 ) {
 178
 179                 /* Attempt allocation at this MTU */
 180                 if ( mtu > NCM_MAX_NTB_INPUT_SIZE )
 181                         continue;
 182                 if ( mtu > bus->mtu )
 183                         continue;
 184                 count = ( NCM_IN_MIN_SIZE / mtu );
 185                 if ( count < NCM_IN_MIN_COUNT )
 186                         count = NCM_IN_MIN_COUNT;
 187                 if ( ( count * mtu ) > NCM_IN_MAX_SIZE )
 188                         continue;
 189                 usb_refill_init ( &ncm->usbnet.in, mtu, count );
 190                 if ( ( rc = usb_prefill ( &ncm->usbnet.in ) ) != 0 ) {
 191                         DBGC ( ncm, "NCM %p could not prefill %dx %zd-byte "
 192                                "buffers for bulk IN\n", ncm, count, mtu );
 193                         continue;
 194                 }
 195
 196                 DBGC ( ncm, "NCM %p using %dx %zd-byte buffers for bulk IN\n",
 197                        ncm, count, mtu );
 198                 return 0;
 199         }
 200
 201         DBGC ( ncm, "NCM %p could not prefill bulk IN endpoint\n", ncm );
 202         return -ENOMEM;
 203 }
 204
 205 /**
 206  * Complete bulk IN transfer
 207  *
 208  * @v ep                USB endpoint
 209  * @v iobuf             I/O buffer
 210  * @v rc                Completion status code
 211  */
 212 static void ncm_in_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf,
 213                               int rc ) {
 214         struct ncm_device *ncm = container_of ( ep, struct ncm_device,
 215                                                 usbnet.in );
 216         struct net_device *netdev = ncm->netdev;
 217         struct ncm_transfer_header *nth;
 218         struct ncm_datagram_pointer *ndp;
 219         struct ncm_datagram_descriptor *desc;
 220         struct io_buffer *pkt;
 221         unsigned int remaining;
 222         size_t ndp_offset;
 223         size_t ndp_len;
 224         size_t pkt_offset;
 225         size_t pkt_len;
 226         size_t headroom;
 227         size_t len;
 228
 229         /* Profile overall bulk IN completion */
 230         profile_start ( &ncm_in_profiler );
 231
 232         /* Ignore packets cancelled when the endpoint closes */
 233         if ( ! ep->open )
 234                 goto ignore;
 235
 236         /* Record USB errors against the network device */
 237         if ( rc != 0 ) {
 238                 DBGC ( ncm, "NCM %p bulk IN failed: %s\n",
 239                        ncm, strerror ( rc ) );
 240                 goto error;
 241         }
 242
 243         /* Locate transfer header */
 244         len = iob_len ( iobuf );
 245         if ( sizeof ( *nth ) > len ) {
 246                 DBGC ( ncm, "NCM %p packet too short for NTH:\n", ncm );
 247                 rc = -EINVAL;
 248                 goto error;
 249         }
 250         nth = iobuf->data;
 251
 252         /* Locate datagram pointer */
 253         ndp_offset = le16_to_cpu ( nth->offset );
 254         if ( ( ndp_offset + sizeof ( *ndp ) ) > len ) {
 255                 DBGC ( ncm, "NCM %p packet too short for NDP:\n", ncm );
 256                 rc = -EINVAL;
 257                 goto error;
 258         }
 259         ndp = ( iobuf->data + ndp_offset );
 260         ndp_len = le16_to_cpu ( ndp->header_len );
 261         if ( ndp_len < offsetof ( typeof ( *ndp ), desc ) ) {
 262                 DBGC ( ncm, "NCM %p NDP header length too short:\n", ncm );
 263                 rc = -EINVAL;
 264                 goto error;
 265         }
 266         if ( ( ndp_offset + ndp_len ) > len ) {
 267                 DBGC ( ncm, "NCM %p packet too short for NDP:\n", ncm );
 268                 rc = -EINVAL;
 269                 goto error;
 270         }
 271
 272         /* Process datagrams */
 273         remaining = ( ( ndp_len - offsetof ( typeof ( *ndp ), desc ) ) /
 274                       sizeof ( ndp->desc[0] ) );
 275         for ( desc = ndp->desc ; remaining && desc->offset ; remaining-- ) {
 276
 277                 /* Profile individual datagrams */
 278                 profile_start ( &ncm_in_datagram_profiler );
 279
 280                 /* Locate datagram */
 281                 pkt_offset = le16_to_cpu ( desc->offset );
 282                 pkt_len = le16_to_cpu ( desc->len );
 283                 if ( pkt_len < ETH_HLEN ) {
 284                         DBGC ( ncm, "NCM %p underlength datagram:\n", ncm );
 285                         rc = -EINVAL;
 286                         goto error;
 287                 }
 288                 if ( ( pkt_offset + pkt_len ) > len ) {
 289                         DBGC ( ncm, "NCM %p datagram exceeds packet:\n", ncm );
 290                         rc = -EINVAL;
 291                         goto error;
 292                 }
 293
 294                 /* Move to next descriptor */
 295                 desc++;
 296
 297                 /* Copy data to a new I/O buffer.  Our USB buffers may
 298                  * be very large and so we choose to recycle the
 299                  * buffers directly rather than attempt reallocation
 300                  * while the device is running.  We therefore copy the
 301                  * data to a new I/O buffer even if this is the only
 302                  * (or last) packet within the buffer.
 303                  *
 304                  * We reserve enough space at the start of each buffer
 305                  * to allow for our own transmission header, to
 306                  * support protocols such as ARP which may modify the
 307                  * received packet and reuse the same I/O buffer for
 308                  * transmission.
 309                  */
 310                 headroom = ( sizeof ( struct ncm_ntb_header ) + ncm->padding );
 311                 pkt = alloc_iob ( headroom + pkt_len );
 312                 if ( ! pkt ) {
 313                         /* Record error and continue */
 314                         netdev_rx_err ( netdev, NULL, -ENOMEM );
 315                         continue;
 316                 }
 317                 iob_reserve ( pkt, headroom );
 318                 memcpy ( iob_put ( pkt, pkt_len ),
 319                          ( iobuf->data + pkt_offset ), pkt_len );
 320
 321                 /* Strip CRC, if present */
 322                 if ( ndp->magic & cpu_to_le32 ( NCM_DATAGRAM_POINTER_MAGIC_CRC))
 323                         iob_unput ( pkt, 4 /* CRC32 */ );
 324
 325                 /* Hand off to network stack */
 326                 netdev_rx ( netdev, pkt );
 327                 profile_stop ( &ncm_in_datagram_profiler );
 328         }
 329
 330         /* Recycle I/O buffer */
 331         usb_recycle ( &ncm->usbnet.in, iobuf );
 332         profile_stop ( &ncm_in_profiler );
 333
 334         return;
 335
 336  error:
 337         /* Record error against network device */
 338         DBGC_HDA ( ncm, 0, iobuf->data, iob_len ( iobuf ) );
 339         netdev_rx_err ( netdev, NULL, rc );
 340  ignore:
 341         usb_recycle ( &ncm->usbnet.in, iobuf );
 342 }
 343
 344 /** Bulk IN endpoint operations */
 345 static struct usb_endpoint_driver_operations ncm_in_operations = {
 346         .complete = ncm_in_complete,
 347 };
 348
 349 /**
 350  * Transmit packet
 351  *
 352  * @v ncm               CDC-NCM device
 353  * @v iobuf             I/O buffer
 354  * @ret rc              Return status code
 355  */
 356 static int ncm_out_transmit ( struct ncm_device *ncm,
 357                               struct io_buffer *iobuf ) {
 358         struct ncm_ntb_header *header;
 359         size_t len = iob_len ( iobuf );
 360         size_t header_len = ( sizeof ( *header ) + ncm->padding );
 361         int rc;
 362
 363         /* Profile transmissions */
 364         profile_start ( &ncm_out_profiler );
 365
 366         /* Prepend header */
 367         if ( ( rc = iob_ensure_headroom ( iobuf, header_len ) ) != 0 )
 368                 return rc;
 369         header = iob_push ( iobuf, header_len );
 370
 371         /* Populate header */
 372         header->nth.magic = cpu_to_le32 ( NCM_TRANSFER_HEADER_MAGIC );
 373         header->nth.header_len = cpu_to_le16 ( sizeof ( header->nth ) );
 374         header->nth.sequence = cpu_to_le16 ( ncm->sequence );
 375         header->nth.len = cpu_to_le16 ( iob_len ( iobuf ) );
 376         header->nth.offset =
 377                 cpu_to_le16 ( offsetof ( typeof ( *header ), ndp ) );
 378         header->ndp.magic = cpu_to_le32 ( NCM_DATAGRAM_POINTER_MAGIC );
 379         header->ndp.header_len = cpu_to_le16 ( sizeof ( header->ndp ) +
 380                                                sizeof ( header->desc ) );
 381         header->ndp.offset = cpu_to_le16 ( 0 );
 382         header->desc[0].offset = cpu_to_le16 ( header_len );
 383         header->desc[0].len = cpu_to_le16 ( len );
 384         memset ( &header->desc[1], 0, sizeof ( header->desc[1] ) );
 385
 386         /* Enqueue I/O buffer */
 387         if ( ( rc = usb_stream ( &ncm->usbnet.out, iobuf, 0 ) ) != 0 )
 388                 return rc;
 389
 390         /* Increment sequence number */
 391         ncm->sequence++;
 392
 393         profile_stop ( &ncm_out_profiler );
 394         return 0;
 395 }
 396
 397 /**
 398  * Complete bulk OUT transfer
 399  *
 400  * @v ep                USB endpoint
 401  * @v iobuf             I/O buffer
 402  * @v rc                Completion status code
 403  */
 404 static void ncm_out_complete ( struct usb_endpoint *ep, struct io_buffer *iobuf,
 405                                int rc ) {
 406         struct ncm_device *ncm = container_of ( ep, struct ncm_device,
 407                                                 usbnet.out );
 408         struct net_device *netdev = ncm->netdev;
 409
 410         /* Report TX completion */
 411         netdev_tx_complete_err ( netdev, iobuf, rc );
 412 }
 413
 414 /** Bulk OUT endpoint operations */
 415 static struct usb_endpoint_driver_operations ncm_out_operations = {
 416         .complete = ncm_out_complete,
 417 };
 418
 419 /******************************************************************************
 420  *
 421  * Network device interface
 422  *
 423  ******************************************************************************
 424  */
 425
 426 /**
 427  * Open network device
 428  *
 429  * @v netdev            Network device
 430  * @ret rc              Return status code
 431  */
 432 static int ncm_open ( struct net_device *netdev ) {
 433         struct ncm_device *ncm = netdev->priv;
 434         struct usb_device *usb = ncm->usb;
 435         struct ncm_set_ntb_input_size size;
 436         int rc;
 437
 438         /* Reset sequence number */
 439         ncm->sequence = 0;
 440
 441         /* Prefill I/O buffers */
 442         if ( ( rc = ncm_in_prefill ( ncm ) ) != 0 )
 443                 goto err_prefill;
 444
 445         /* Set maximum input size */
 446         memset ( &size, 0, sizeof ( size ) );
 447         size.mtu = cpu_to_le32 ( ncm->usbnet.in.len );
 448         if ( ( rc = usb_control ( usb, NCM_SET_NTB_INPUT_SIZE, 0,
 449                                   ncm->usbnet.comms, &size,
 450                                   sizeof ( size ) ) ) != 0 ) {
 451                 DBGC ( ncm, "NCM %p could not set input size to %zd: %s\n",
 452                        ncm, ncm->usbnet.in.len, strerror ( rc ) );
 453                 goto err_set_ntb_input_size;
 454         }
 455
 456         /* Open USB network device */
 457         if ( ( rc = usbnet_open ( &ncm->usbnet ) ) != 0 ) {
 458                 DBGC ( ncm, "NCM %p could not open: %s\n",
 459                        ncm, strerror ( rc ) );
 460                 goto err_open;
 461         }
 462
 463         return 0;
 464
 465         usbnet_close ( &ncm->usbnet );
 466  err_open:
 467  err_set_ntb_input_size:
 468         usb_flush ( &ncm->usbnet.in );
 469  err_prefill:
 470         return rc;
 471 }
 472
 473 /**
 474  * Close network device
 475  *
 476  * @v netdev            Network device
 477  */
 478 static void ncm_close ( struct net_device *netdev ) {
 479         struct ncm_device *ncm = netdev->priv;
 480
 481         /* Close USB network device */
 482         usbnet_close ( &ncm->usbnet );
 483 }
 484
 485 /**
 486  * Transmit packet
 487  *
 488  * @v netdev            Network device
 489  * @v iobuf             I/O buffer
 490  * @ret rc              Return status code
 491  */
 492 static int ncm_transmit ( struct net_device *netdev,
 493                           struct io_buffer *iobuf ) {
 494         struct ncm_device *ncm = netdev->priv;
 495         int rc;
 496
 497         /* Transmit packet */
 498         if ( ( rc = ncm_out_transmit ( ncm, iobuf ) ) != 0 )
 499                 return rc;
 500
 501         return 0;
 502 }
 503
 504 /**
 505  * Poll for completed and received packets
 506  *
 507  * @v netdev            Network device
 508  */
 509 static void ncm_poll ( struct net_device *netdev ) {
 510         struct ncm_device *ncm = netdev->priv;
 511         int rc;
 512
 513         /* Poll USB bus */
 514         usb_poll ( ncm->bus );
 515
 516         /* Refill endpoints */
 517         if ( ( rc = usbnet_refill ( &ncm->usbnet ) ) != 0 )
 518                 netdev_rx_err ( netdev, NULL, rc );
 519
 520 }
 521
 522 /** CDC-NCM network device operations */
 523 static struct net_device_operations ncm_operations = {
 524         .open           = ncm_open,
 525         .close          = ncm_close,
 526         .transmit       = ncm_transmit,
 527         .poll           = ncm_poll,
 528 };
 529
 530 /******************************************************************************
 531  *
 532  * USB interface
 533  *
 534  ******************************************************************************
 535  */
 536
 537 /**
 538  * Probe device
 539  *
 540  * @v func              USB function
 541  * @v config            Configuration descriptor
 542  * @ret rc              Return status code
 543  */
 544 static int ncm_probe ( struct usb_function *func,
 545                        struct usb_configuration_descriptor *config ) {
 546         struct usb_device *usb = func->usb;
 547         struct net_device *netdev;
 548         struct ncm_device *ncm;
 549         struct usb_interface_descriptor *comms;
 550         struct ecm_ethernet_descriptor *ethernet;
 551         struct ncm_ntb_parameters params;
 552         int rc;
 553
 554         /* Allocate and initialise structure */
 555         netdev = alloc_etherdev ( sizeof ( *ncm ) );
 556         if ( ! netdev ) {
 557                 rc = -ENOMEM;
 558                 goto err_alloc;
 559         }
 560         netdev_init ( netdev, &ncm_operations );
 561         netdev->dev = &func->dev;
 562         ncm = netdev->priv;
 563         memset ( ncm, 0, sizeof ( *ncm ) );
 564         ncm->usb = usb;
 565         ncm->bus = usb->port->hub->bus;
 566         ncm->netdev = netdev;
 567         usbnet_init ( &ncm->usbnet, func, &ncm_intr_operations,
 568                       &ncm_in_operations, &ncm_out_operations );
 569         usb_refill_init ( &ncm->usbnet.intr, 0, NCM_INTR_COUNT );
 570         DBGC ( ncm, "NCM %p on %s\n", ncm, func->name );
 571
 572         /* Describe USB network device */
 573         if ( ( rc = usbnet_describe ( &ncm->usbnet, config ) ) != 0 ) {
 574                 DBGC ( ncm, "NCM %p could not describe: %s\n",
 575                        ncm, strerror ( rc ) );
 576                 goto err_describe;
 577         }
 578
 579         /* Locate Ethernet descriptor */
 580         comms = usb_interface_descriptor ( config, ncm->usbnet.comms, 0 );
 581         assert ( comms != NULL );
 582         ethernet = ecm_ethernet_descriptor ( config, comms );
 583         if ( ! ethernet ) {
 584                 DBGC ( ncm, "NCM %p has no Ethernet descriptor\n", ncm );
 585                 rc = -EINVAL;
 586                 goto err_ethernet;
 587         }
 588
 589         /* Fetch MAC address */
 590         if ( ( rc = ecm_fetch_mac ( usb, ethernet, netdev->hw_addr ) ) != 0 ) {
 591                 DBGC ( ncm, "NCM %p could not fetch MAC address: %s\n",
 592                        ncm, strerror ( rc ) );
 593                 goto err_fetch_mac;
 594         }
 595
 596         /* Get NTB parameters */
 597         if ( ( rc = usb_control ( usb, NCM_GET_NTB_PARAMETERS, 0,
 598                                   ncm->usbnet.comms, &params,
 599                                   sizeof ( params ) ) ) != 0 ) {
 600                 DBGC ( ncm, "NCM %p could not get NTB parameters: %s\n",
 601                        ncm, strerror ( rc ) );
 602                 goto err_ntb_parameters;
 603         }
 604
 605         /* Get maximum supported input size */
 606         ncm->mtu = le32_to_cpu ( params.in.mtu );
 607         DBGC2 ( ncm, "NCM %p maximum IN size is %zd bytes\n", ncm, ncm->mtu );
 608
 609         /* Calculate transmit padding */
 610         ncm->padding = ( ( le16_to_cpu ( params.out.remainder ) -
 611                            sizeof ( struct ncm_ntb_header ) - ETH_HLEN ) &
 612                          ( le16_to_cpu ( params.out.divisor ) - 1 ) );
 613         DBGC2 ( ncm, "NCM %p using %zd-byte transmit padding\n",
 614                 ncm, ncm->padding );
 615         assert ( ( ( sizeof ( struct ncm_ntb_header ) + ncm->padding +
 616                      ETH_HLEN ) % le16_to_cpu ( params.out.divisor ) ) ==
 617                  le16_to_cpu ( params.out.remainder ) );
 618
 619         /* Register network device */
 620         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 621                 goto err_register;
 622
 623         usb_func_set_drvdata ( func, ncm );
 624         return 0;
 625
 626         unregister_netdev ( netdev );
 627  err_register:
 628  err_ntb_parameters:
 629  err_fetch_mac:
 630  err_ethernet:
 631  err_describe:
 632         netdev_nullify ( netdev );
 633         netdev_put ( netdev );
 634  err_alloc:
 635         return rc;
 636 }
 637
 638 /**
 639  * Remove device
 640  *
 641  * @v func              USB function
 642  */
 643 static void ncm_remove ( struct usb_function *func ) {
 644         struct ncm_device *ncm = usb_func_get_drvdata ( func );
 645         struct net_device *netdev = ncm->netdev;
 646
 647         unregister_netdev ( netdev );
 648         netdev_nullify ( netdev );
 649         netdev_put ( netdev );
 650 }
 651
 652 /** CDC-NCM device IDs */
 653 static struct usb_device_id ncm_ids[] = {
 654         {
 655                 .name = "cdc-ncm",
 656                 .vendor = USB_ANY_ID,
 657                 .product = USB_ANY_ID,
 658                 .class = {
 659                         .class = USB_CLASS_CDC,
 660                         .subclass = USB_SUBCLASS_CDC_NCM,
 661                         .protocol = 0,
 662                 },
 663         },
 664 };
 665
 666 /** CDC-NCM driver */
 667 struct usb_driver ncm_driver __usb_driver = {
 668         .ids = ncm_ids,
 669         .id_count = ( sizeof ( ncm_ids ) / sizeof ( ncm_ids[0] ) ),
 670         .probe = ncm_probe,
 671         .remove = ncm_remove,
 672 };