drivers/usb/gadget/function/f_ncm.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * f_ncm.c -- USB CDC Network (NCM) link function driver
   4  *
   5  * Copyright (C) 2010 Nokia Corporation
   6  * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
   7  *
   8  * The driver borrows from f_ecm.c which is:
   9  *
  10  * Copyright (C) 2003-2005,2008 David Brownell
  11  * Copyright (C) 2008 Nokia Corporation
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/module.h>
  17 #include <linux/device.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/crc32.h>
  20
  21 #include <linux/usb/cdc.h>
  22
  23 #include "u_ether.h"
  24 #include "u_ether_configfs.h"
  25 #include "u_ncm.h"
  26
  27 /*
  28  * This function is a "CDC Network Control Model" (CDC NCM) Ethernet link.
  29  * NCM is intended to be used with high-speed network attachments.
  30  *
  31  * Note that NCM requires the use of "alternate settings" for its data
  32  * interface.  This means that the set_alt() method has real work to do,
  33  * and also means that a get_alt() method is required.
  34  */
  35
  36 /* to trigger crc/non-crc ndp signature */
  37
  38 #define NCM_NDP_HDR_CRC_MASK    0x01000000
  39 #define NCM_NDP_HDR_CRC         0x01000000
  40 #define NCM_NDP_HDR_NOCRC       0x00000000
  41
  42 enum ncm_notify_state {
  43         NCM_NOTIFY_NONE,                /* don't notify */
  44         NCM_NOTIFY_CONNECT,             /* issue CONNECT next */
  45         NCM_NOTIFY_SPEED,               /* issue SPEED_CHANGE next */
  46 };
  47
  48 struct f_ncm {
  49         struct gether                   port;
  50         u8                              ctrl_id, data_id;
  51
  52         char                            ethaddr[14];
  53
  54         struct usb_ep                   *notify;
  55         struct usb_request              *notify_req;
  56         u8                              notify_state;
  57         bool                            is_open;
  58
  59         const struct ndp_parser_opts    *parser_opts;
  60         bool                            is_crc;
  61         u32                             ndp_sign;
  62
  63         /*
  64          * for notification, it is accessed from both
  65          * callback and ethernet open/close
  66          */
  67         spinlock_t                      lock;
  68
  69         struct net_device               *netdev;
  70
  71         /* For multi-frame NDP TX */
  72         struct sk_buff                  *skb_tx_data;
  73         struct sk_buff                  *skb_tx_ndp;
  74         u16                             ndp_dgram_count;
  75         bool                            timer_force_tx;
  76         struct tasklet_struct           tx_tasklet;
  77         struct hrtimer                  task_timer;
  78
  79         bool                            timer_stopping;
  80 };
  81
  82 static inline struct f_ncm *func_to_ncm(struct usb_function *f)
  83 {
  84         return container_of(f, struct f_ncm, port.func);
  85 }
  86
  87 /* peak (theoretical) bulk transfer rate in bits-per-second */
  88 static inline unsigned ncm_bitrate(struct usb_gadget *g)
  89 {
  90         if (gadget_is_superspeed(g) && g->speed == USB_SPEED_SUPER)
  91                 return 13 * 1024 * 8 * 1000 * 8;
  92         else if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
  93                 return 13 * 512 * 8 * 1000 * 8;
  94         else
  95                 return 19 *  64 * 1 * 1000 * 8;
  96 }
  97
  98 /*-------------------------------------------------------------------------*/
  99
 100 /*
 101  * We cannot group frames so use just the minimal size which ok to put
 102  * one max-size ethernet frame.
 103  * If the host can group frames, allow it to do that, 16K is selected,
 104  * because it's used by default by the current linux host driver
 105  */
 106 #define NTB_DEFAULT_IN_SIZE     16384
 107 #define NTB_OUT_SIZE            16384
 108
 109 /* Allocation for storing the NDP, 32 should suffice for a
 110  * 16k packet. This allows a maximum of 32 * 507 Byte packets to
 111  * be transmitted in a single 16kB skb, though when sending full size
 112  * packets this limit will be plenty.
 113  * Smaller packets are not likely to be trying to maximize the
 114  * throughput and will be mstly sending smaller infrequent frames.
 115  */
 116 #define TX_MAX_NUM_DPE          32
 117
 118 /* Delay for the transmit to wait before sending an unfilled NTB frame. */
 119 #define TX_TIMEOUT_NSECS        300000
 120
 121 #define FORMATS_SUPPORTED       (USB_CDC_NCM_NTB16_SUPPORTED |  \
 122                                  USB_CDC_NCM_NTB32_SUPPORTED)
 123
 124 static struct usb_cdc_ncm_ntb_parameters ntb_parameters = {
 125         .wLength = cpu_to_le16(sizeof(ntb_parameters)),
 126         .bmNtbFormatsSupported = cpu_to_le16(FORMATS_SUPPORTED),
 127         .dwNtbInMaxSize = cpu_to_le32(NTB_DEFAULT_IN_SIZE),
 128         .wNdpInDivisor = cpu_to_le16(4),
 129         .wNdpInPayloadRemainder = cpu_to_le16(0),
 130         .wNdpInAlignment = cpu_to_le16(4),
 131
 132         .dwNtbOutMaxSize = cpu_to_le32(NTB_OUT_SIZE),
 133         .wNdpOutDivisor = cpu_to_le16(4),
 134         .wNdpOutPayloadRemainder = cpu_to_le16(0),
 135         .wNdpOutAlignment = cpu_to_le16(4),
 136 };
 137
 138 /*
 139  * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
 140  * packet, to simplify cancellation; and a big transfer interval, to
 141  * waste less bandwidth.
 142  */
 143
 144 #define NCM_STATUS_INTERVAL_MS          32
 145 #define NCM_STATUS_BYTECOUNT            16      /* 8 byte header + data */
 146
 147 static struct usb_interface_assoc_descriptor ncm_iad_desc = {
 148         .bLength =              sizeof ncm_iad_desc,
 149         .bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
 150
 151         /* .bFirstInterface =   DYNAMIC, */
 152         .bInterfaceCount =      2,      /* control + data */
 153         .bFunctionClass =       USB_CLASS_COMM,
 154         .bFunctionSubClass =    USB_CDC_SUBCLASS_NCM,
 155         .bFunctionProtocol =    USB_CDC_PROTO_NONE,
 156         /* .iFunction =         DYNAMIC */
 157 };
 158
 159 /* interface descriptor: */
 160
 161 static struct usb_interface_descriptor ncm_control_intf = {
 162         .bLength =              sizeof ncm_control_intf,
 163         .bDescriptorType =      USB_DT_INTERFACE,
 164
 165         /* .bInterfaceNumber = DYNAMIC */
 166         .bNumEndpoints =        1,
 167         .bInterfaceClass =      USB_CLASS_COMM,
 168         .bInterfaceSubClass =   USB_CDC_SUBCLASS_NCM,
 169         .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
 170         /* .iInterface = DYNAMIC */
 171 };
 172
 173 static struct usb_cdc_header_desc ncm_header_desc = {
 174         .bLength =              sizeof ncm_header_desc,
 175         .bDescriptorType =      USB_DT_CS_INTERFACE,
 176         .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
 177
 178         .bcdCDC =               cpu_to_le16(0x0110),
 179 };
 180
 181 static struct usb_cdc_union_desc ncm_union_desc = {
 182         .bLength =              sizeof(ncm_union_desc),
 183         .bDescriptorType =      USB_DT_CS_INTERFACE,
 184         .bDescriptorSubType =   USB_CDC_UNION_TYPE,
 185         /* .bMasterInterface0 = DYNAMIC */
 186         /* .bSlaveInterface0 =  DYNAMIC */
 187 };
 188
 189 static struct usb_cdc_ether_desc ecm_desc = {
 190         .bLength =              sizeof ecm_desc,
 191         .bDescriptorType =      USB_DT_CS_INTERFACE,
 192         .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
 193
 194         /* this descriptor actually adds value, surprise! */
 195         /* .iMACAddress = DYNAMIC */
 196         .bmEthernetStatistics = cpu_to_le32(0), /* no statistics */
 197         .wMaxSegmentSize =      cpu_to_le16(ETH_FRAME_LEN),
 198         .wNumberMCFilters =     cpu_to_le16(0),
 199         .bNumberPowerFilters =  0,
 200 };
 201
 202 #define NCAPS   (USB_CDC_NCM_NCAP_ETH_FILTER | USB_CDC_NCM_NCAP_CRC_MODE)
 203
 204 static struct usb_cdc_ncm_desc ncm_desc = {
 205         .bLength =              sizeof ncm_desc,
 206         .bDescriptorType =      USB_DT_CS_INTERFACE,
 207         .bDescriptorSubType =   USB_CDC_NCM_TYPE,
 208
 209         .bcdNcmVersion =        cpu_to_le16(0x0100),
 210         /* can process SetEthernetPacketFilter */
 211         .bmNetworkCapabilities = NCAPS,
 212 };
 213
 214 /* the default data interface has no endpoints ... */
 215
 216 static struct usb_interface_descriptor ncm_data_nop_intf = {
 217         .bLength =              sizeof ncm_data_nop_intf,
 218         .bDescriptorType =      USB_DT_INTERFACE,
 219
 220         .bInterfaceNumber =     1,
 221         .bAlternateSetting =    0,
 222         .bNumEndpoints =        0,
 223         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 224         .bInterfaceSubClass =   0,
 225         .bInterfaceProtocol =   USB_CDC_NCM_PROTO_NTB,
 226         /* .iInterface = DYNAMIC */
 227 };
 228
 229 /* ... but the "real" data interface has two bulk endpoints */
 230
 231 static struct usb_interface_descriptor ncm_data_intf = {
 232         .bLength =              sizeof ncm_data_intf,
 233         .bDescriptorType =      USB_DT_INTERFACE,
 234
 235         .bInterfaceNumber =     1,
 236         .bAlternateSetting =    1,
 237         .bNumEndpoints =        2,
 238         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 239         .bInterfaceSubClass =   0,
 240         .bInterfaceProtocol =   USB_CDC_NCM_PROTO_NTB,
 241         /* .iInterface = DYNAMIC */
 242 };
 243
 244 /* full speed support: */
 245
 246 static struct usb_endpoint_descriptor fs_ncm_notify_desc = {
 247         .bLength =              USB_DT_ENDPOINT_SIZE,
 248         .bDescriptorType =      USB_DT_ENDPOINT,
 249
 250         .bEndpointAddress =     USB_DIR_IN,
 251         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 252         .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
 253         .bInterval =            NCM_STATUS_INTERVAL_MS,
 254 };
 255
 256 static struct usb_endpoint_descriptor fs_ncm_in_desc = {
 257         .bLength =              USB_DT_ENDPOINT_SIZE,
 258         .bDescriptorType =      USB_DT_ENDPOINT,
 259
 260         .bEndpointAddress =     USB_DIR_IN,
 261         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 262 };
 263
 264 static struct usb_endpoint_descriptor fs_ncm_out_desc = {
 265         .bLength =              USB_DT_ENDPOINT_SIZE,
 266         .bDescriptorType =      USB_DT_ENDPOINT,
 267
 268         .bEndpointAddress =     USB_DIR_OUT,
 269         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 270 };
 271
 272 static struct usb_descriptor_header *ncm_fs_function[] = {
 273         (struct usb_descriptor_header *) &ncm_iad_desc,
 274         /* CDC NCM control descriptors */
 275         (struct usb_descriptor_header *) &ncm_control_intf,
 276         (struct usb_descriptor_header *) &ncm_header_desc,
 277         (struct usb_descriptor_header *) &ncm_union_desc,
 278         (struct usb_descriptor_header *) &ecm_desc,
 279         (struct usb_descriptor_header *) &ncm_desc,
 280         (struct usb_descriptor_header *) &fs_ncm_notify_desc,
 281         /* data interface, altsettings 0 and 1 */
 282         (struct usb_descriptor_header *) &ncm_data_nop_intf,
 283         (struct usb_descriptor_header *) &ncm_data_intf,
 284         (struct usb_descriptor_header *) &fs_ncm_in_desc,
 285         (struct usb_descriptor_header *) &fs_ncm_out_desc,
 286         NULL,
 287 };
 288
 289 /* high speed support: */
 290
 291 static struct usb_endpoint_descriptor hs_ncm_notify_desc = {
 292         .bLength =              USB_DT_ENDPOINT_SIZE,
 293         .bDescriptorType =      USB_DT_ENDPOINT,
 294
 295         .bEndpointAddress =     USB_DIR_IN,
 296         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 297         .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
 298         .bInterval =            USB_MS_TO_HS_INTERVAL(NCM_STATUS_INTERVAL_MS),
 299 };
 300 static struct usb_endpoint_descriptor hs_ncm_in_desc = {
 301         .bLength =              USB_DT_ENDPOINT_SIZE,
 302         .bDescriptorType =      USB_DT_ENDPOINT,
 303
 304         .bEndpointAddress =     USB_DIR_IN,
 305         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 306         .wMaxPacketSize =       cpu_to_le16(512),
 307 };
 308
 309 static struct usb_endpoint_descriptor hs_ncm_out_desc = {
 310         .bLength =              USB_DT_ENDPOINT_SIZE,
 311         .bDescriptorType =      USB_DT_ENDPOINT,
 312
 313         .bEndpointAddress =     USB_DIR_OUT,
 314         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 315         .wMaxPacketSize =       cpu_to_le16(512),
 316 };
 317
 318 static struct usb_descriptor_header *ncm_hs_function[] = {
 319         (struct usb_descriptor_header *) &ncm_iad_desc,
 320         /* CDC NCM control descriptors */
 321         (struct usb_descriptor_header *) &ncm_control_intf,
 322         (struct usb_descriptor_header *) &ncm_header_desc,
 323         (struct usb_descriptor_header *) &ncm_union_desc,
 324         (struct usb_descriptor_header *) &ecm_desc,
 325         (struct usb_descriptor_header *) &ncm_desc,
 326         (struct usb_descriptor_header *) &hs_ncm_notify_desc,
 327         /* data interface, altsettings 0 and 1 */
 328         (struct usb_descriptor_header *) &ncm_data_nop_intf,
 329         (struct usb_descriptor_header *) &ncm_data_intf,
 330         (struct usb_descriptor_header *) &hs_ncm_in_desc,
 331         (struct usb_descriptor_header *) &hs_ncm_out_desc,
 332         NULL,
 333 };
 334
 335
 336 /* super speed support: */
 337
 338 static struct usb_endpoint_descriptor ss_ncm_notify_desc = {
 339         .bLength =              USB_DT_ENDPOINT_SIZE,
 340         .bDescriptorType =      USB_DT_ENDPOINT,
 341
 342         .bEndpointAddress =     USB_DIR_IN,
 343         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 344         .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
 345         .bInterval =            USB_MS_TO_HS_INTERVAL(NCM_STATUS_INTERVAL_MS)
 346 };
 347
 348 static struct usb_ss_ep_comp_descriptor ss_ncm_notify_comp_desc = {
 349         .bLength =              sizeof(ss_ncm_notify_comp_desc),
 350         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 351
 352         /* the following 3 values can be tweaked if necessary */
 353         /* .bMaxBurst =         0, */
 354         /* .bmAttributes =      0, */
 355         .wBytesPerInterval =    cpu_to_le16(NCM_STATUS_BYTECOUNT),
 356 };
 357
 358 static struct usb_endpoint_descriptor ss_ncm_in_desc = {
 359         .bLength =              USB_DT_ENDPOINT_SIZE,
 360         .bDescriptorType =      USB_DT_ENDPOINT,
 361
 362         .bEndpointAddress =     USB_DIR_IN,
 363         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 364         .wMaxPacketSize =       cpu_to_le16(1024),
 365 };
 366
 367 static struct usb_endpoint_descriptor ss_ncm_out_desc = {
 368         .bLength =              USB_DT_ENDPOINT_SIZE,
 369         .bDescriptorType =      USB_DT_ENDPOINT,
 370
 371         .bEndpointAddress =     USB_DIR_OUT,
 372         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 373         .wMaxPacketSize =       cpu_to_le16(1024),
 374 };
 375
 376 static struct usb_ss_ep_comp_descriptor ss_ncm_bulk_comp_desc = {
 377         .bLength =              sizeof(ss_ncm_bulk_comp_desc),
 378         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 379
 380         /* the following 2 values can be tweaked if necessary */
 381         /* .bMaxBurst =         0, */
 382         /* .bmAttributes =      0, */
 383 };
 384
 385 static struct usb_descriptor_header *ncm_ss_function[] = {
 386         (struct usb_descriptor_header *) &ncm_iad_desc,
 387         /* CDC NCM control descriptors */
 388         (struct usb_descriptor_header *) &ncm_control_intf,
 389         (struct usb_descriptor_header *) &ncm_header_desc,
 390         (struct usb_descriptor_header *) &ncm_union_desc,
 391         (struct usb_descriptor_header *) &ecm_desc,
 392         (struct usb_descriptor_header *) &ncm_desc,
 393         (struct usb_descriptor_header *) &ss_ncm_notify_desc,
 394         (struct usb_descriptor_header *) &ss_ncm_notify_comp_desc,
 395         /* data interface, altsettings 0 and 1 */
 396         (struct usb_descriptor_header *) &ncm_data_nop_intf,
 397         (struct usb_descriptor_header *) &ncm_data_intf,
 398         (struct usb_descriptor_header *) &ss_ncm_in_desc,
 399         (struct usb_descriptor_header *) &ss_ncm_bulk_comp_desc,
 400         (struct usb_descriptor_header *) &ss_ncm_out_desc,
 401         (struct usb_descriptor_header *) &ss_ncm_bulk_comp_desc,
 402         NULL,
 403 };
 404
 405 /* string descriptors: */
 406
 407 #define STRING_CTRL_IDX 0
 408 #define STRING_MAC_IDX  1
 409 #define STRING_DATA_IDX 2
 410 #define STRING_IAD_IDX  3
 411
 412 static struct usb_string ncm_string_defs[] = {
 413         [STRING_CTRL_IDX].s = "CDC Network Control Model (NCM)",
 414         [STRING_MAC_IDX].s = "",
 415         [STRING_DATA_IDX].s = "CDC Network Data",
 416         [STRING_IAD_IDX].s = "CDC NCM",
 417         {  } /* end of list */
 418 };
 419
 420 static struct usb_gadget_strings ncm_string_table = {
 421         .language =             0x0409, /* en-us */
 422         .strings =              ncm_string_defs,
 423 };
 424
 425 static struct usb_gadget_strings *ncm_strings[] = {
 426         &ncm_string_table,
 427         NULL,
 428 };
 429
 430 /*
 431  * Here are options for NCM Datagram Pointer table (NDP) parser.
 432  * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
 433  * in NDP16 offsets and sizes fields are 1 16bit word wide,
 434  * in NDP32 -- 2 16bit words wide. Also signatures are different.
 435  * To make the parser code the same, put the differences in the structure,
 436  * and switch pointers to the structures when the format is changed.
 437  */
 438
 439 struct ndp_parser_opts {
 440         u32             nth_sign;
 441         u32             ndp_sign;
 442         unsigned        nth_size;
 443         unsigned        ndp_size;
 444         unsigned        dpe_size;
 445         unsigned        ndplen_align;
 446         /* sizes in u16 units */
 447         unsigned        dgram_item_len; /* index or length */
 448         unsigned        block_length;
 449         unsigned        ndp_index;
 450         unsigned        reserved1;
 451         unsigned        reserved2;
 452         unsigned        next_ndp_index;
 453 };
 454
 455 #define INIT_NDP16_OPTS {                                       \
 456                 .nth_sign = USB_CDC_NCM_NTH16_SIGN,             \
 457                 .ndp_sign = USB_CDC_NCM_NDP16_NOCRC_SIGN,       \
 458                 .nth_size = sizeof(struct usb_cdc_ncm_nth16),   \
 459                 .ndp_size = sizeof(struct usb_cdc_ncm_ndp16),   \
 460                 .dpe_size = sizeof(struct usb_cdc_ncm_dpe16),   \
 461                 .ndplen_align = 4,                              \
 462                 .dgram_item_len = 1,                            \
 463                 .block_length = 1,                              \
 464                 .ndp_index = 1,                                 \
 465                 .reserved1 = 0,                                 \
 466                 .reserved2 = 0,                                 \
 467                 .next_ndp_index = 1,                            \
 468         }
 469
 470
 471 #define INIT_NDP32_OPTS {                                       \
 472                 .nth_sign = USB_CDC_NCM_NTH32_SIGN,             \
 473                 .ndp_sign = USB_CDC_NCM_NDP32_NOCRC_SIGN,       \
 474                 .nth_size = sizeof(struct usb_cdc_ncm_nth32),   \
 475                 .ndp_size = sizeof(struct usb_cdc_ncm_ndp32),   \
 476                 .dpe_size = sizeof(struct usb_cdc_ncm_dpe32),   \
 477                 .ndplen_align = 8,                              \
 478                 .dgram_item_len = 2,                            \
 479                 .block_length = 2,                              \
 480                 .ndp_index = 2,                                 \
 481                 .reserved1 = 1,                                 \
 482                 .reserved2 = 2,                                 \
 483                 .next_ndp_index = 2,                            \
 484         }
 485
 486 static const struct ndp_parser_opts ndp16_opts = INIT_NDP16_OPTS;
 487 static const struct ndp_parser_opts ndp32_opts = INIT_NDP32_OPTS;
 488
 489 static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
 490 {
 491         switch (size) {
 492         case 1:
 493                 put_unaligned_le16((u16)val, *p);
 494                 break;
 495         case 2:
 496                 put_unaligned_le32((u32)val, *p);
 497
 498                 break;
 499         default:
 500                 BUG();
 501         }
 502
 503         *p += size;
 504 }
 505
 506 static inline unsigned get_ncm(__le16 **p, unsigned size)
 507 {
 508         unsigned tmp;
 509
 510         switch (size) {
 511         case 1:
 512                 tmp = get_unaligned_le16(*p);
 513                 break;
 514         case 2:
 515                 tmp = get_unaligned_le32(*p);
 516                 break;
 517         default:
 518                 BUG();
 519         }
 520
 521         *p += size;
 522         return tmp;
 523 }
 524
 525 /*-------------------------------------------------------------------------*/
 526
 527 static inline void ncm_reset_values(struct f_ncm *ncm)
 528 {
 529         ncm->parser_opts = &ndp16_opts;
 530         ncm->is_crc = false;
 531         ncm->port.cdc_filter = DEFAULT_FILTER;
 532
 533         /* doesn't make sense for ncm, fixed size used */
 534         ncm->port.header_len = 0;
 535
 536         ncm->port.fixed_out_len = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
 537         ncm->port.fixed_in_len = NTB_DEFAULT_IN_SIZE;
 538 }
 539
 540 /*
 541  * Context: ncm->lock held
 542  */
 543 static void ncm_do_notify(struct f_ncm *ncm)
 544 {
 545         struct usb_request              *req = ncm->notify_req;
 546         struct usb_cdc_notification     *event;
 547         struct usb_composite_dev        *cdev = ncm->port.func.config->cdev;
 548         __le32                          *data;
 549         int                             status;
 550
 551         /* notification already in flight? */
 552         if (!req)
 553                 return;
 554
 555         event = req->buf;
 556         switch (ncm->notify_state) {
 557         case NCM_NOTIFY_NONE:
 558                 return;
 559
 560         case NCM_NOTIFY_CONNECT:
 561                 event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
 562                 if (ncm->is_open)
 563                         event->wValue = cpu_to_le16(1);
 564                 else
 565                         event->wValue = cpu_to_le16(0);
 566                 event->wLength = 0;
 567                 req->length = sizeof *event;
 568
 569                 DBG(cdev, "notify connect %s\n",
 570                                 ncm->is_open ? "true" : "false");
 571                 ncm->notify_state = NCM_NOTIFY_NONE;
 572                 break;
 573
 574         case NCM_NOTIFY_SPEED:
 575                 event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
 576                 event->wValue = cpu_to_le16(0);
 577                 event->wLength = cpu_to_le16(8);
 578                 req->length = NCM_STATUS_BYTECOUNT;
 579
 580                 /* SPEED_CHANGE data is up/down speeds in bits/sec */
 581                 data = req->buf + sizeof *event;
 582                 data[0] = cpu_to_le32(ncm_bitrate(cdev->gadget));
 583                 data[1] = data[0];
 584
 585                 DBG(cdev, "notify speed %d\n", ncm_bitrate(cdev->gadget));
 586                 ncm->notify_state = NCM_NOTIFY_CONNECT;
 587                 break;
 588         }
 589         event->bmRequestType = 0xA1;
 590         event->wIndex = cpu_to_le16(ncm->ctrl_id);
 591
 592         ncm->notify_req = NULL;
 593         /*
 594          * In double buffering if there is a space in FIFO,
 595          * completion callback can be called right after the call,
 596          * so unlocking
 597          */
 598         spin_unlock(&ncm->lock);
 599         status = usb_ep_queue(ncm->notify, req, GFP_ATOMIC);
 600         spin_lock(&ncm->lock);
 601         if (status < 0) {
 602                 ncm->notify_req = req;
 603                 DBG(cdev, "notify --> %d\n", status);
 604         }
 605 }
 606
 607 /*
 608  * Context: ncm->lock held
 609  */
 610 static void ncm_notify(struct f_ncm *ncm)
 611 {
 612         /*
 613          * NOTE on most versions of Linux, host side cdc-ethernet
 614          * won't listen for notifications until its netdevice opens.
 615          * The first notification then sits in the FIFO for a long
 616          * time, and the second one is queued.
 617          *
 618          * If ncm_notify() is called before the second (CONNECT)
 619          * notification is sent, then it will reset to send the SPEED
 620          * notificaion again (and again, and again), but it's not a problem
 621          */
 622         ncm->notify_state = NCM_NOTIFY_SPEED;
 623         ncm_do_notify(ncm);
 624 }
 625
 626 static void ncm_notify_complete(struct usb_ep *ep, struct usb_request *req)
 627 {
 628         struct f_ncm                    *ncm = req->context;
 629         struct usb_composite_dev        *cdev = ncm->port.func.config->cdev;
 630         struct usb_cdc_notification     *event = req->buf;
 631
 632         spin_lock(&ncm->lock);
 633         switch (req->status) {
 634         case 0:
 635                 VDBG(cdev, "Notification %02x sent\n",
 636                      event->bNotificationType);
 637                 break;
 638         case -ECONNRESET:
 639         case -ESHUTDOWN:
 640                 ncm->notify_state = NCM_NOTIFY_NONE;
 641                 break;
 642         default:
 643                 DBG(cdev, "event %02x --> %d\n",
 644                         event->bNotificationType, req->status);
 645                 break;
 646         }
 647         ncm->notify_req = req;
 648         ncm_do_notify(ncm);
 649         spin_unlock(&ncm->lock);
 650 }
 651
 652 static void ncm_ep0out_complete(struct usb_ep *ep, struct usb_request *req)
 653 {
 654         /* now for SET_NTB_INPUT_SIZE only */
 655         unsigned                in_size;
 656         struct usb_function     *f = req->context;
 657         struct f_ncm            *ncm = func_to_ncm(f);
 658         struct usb_composite_dev *cdev = f->config->cdev;
 659
 660         req->context = NULL;
 661         if (req->status || req->actual != req->length) {
 662                 DBG(cdev, "Bad control-OUT transfer\n");
 663                 goto invalid;
 664         }
 665
 666         in_size = get_unaligned_le32(req->buf);
 667         if (in_size < USB_CDC_NCM_NTB_MIN_IN_SIZE ||
 668             in_size > le32_to_cpu(ntb_parameters.dwNtbInMaxSize)) {
 669                 DBG(cdev, "Got wrong INPUT SIZE (%d) from host\n", in_size);
 670                 goto invalid;
 671         }
 672
 673         ncm->port.fixed_in_len = in_size;
 674         VDBG(cdev, "Set NTB INPUT SIZE %d\n", in_size);
 675         return;
 676
 677 invalid:
 678         usb_ep_set_halt(ep);
 679         return;
 680 }
 681
 682 static int ncm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 683 {
 684         struct f_ncm            *ncm = func_to_ncm(f);
 685         struct usb_composite_dev *cdev = f->config->cdev;
 686         struct usb_request      *req = cdev->req;
 687         int                     value = -EOPNOTSUPP;
 688         u16                     w_index = le16_to_cpu(ctrl->wIndex);
 689         u16                     w_value = le16_to_cpu(ctrl->wValue);
 690         u16                     w_length = le16_to_cpu(ctrl->wLength);
 691
 692         /*
 693          * composite driver infrastructure handles everything except
 694          * CDC class messages; interface activation uses set_alt().
 695          */
 696         switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
 697         case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 698                         | USB_CDC_SET_ETHERNET_PACKET_FILTER:
 699                 /*
 700                  * see 6.2.30: no data, wIndex = interface,
 701                  * wValue = packet filter bitmap
 702                  */
 703                 if (w_length != 0 || w_index != ncm->ctrl_id)
 704                         goto invalid;
 705                 DBG(cdev, "packet filter %02x\n", w_value);
 706                 /*
 707                  * REVISIT locking of cdc_filter.  This assumes the UDC
 708                  * driver won't have a concurrent packet TX irq running on
 709                  * another CPU; or that if it does, this write is atomic...
 710                  */
 711                 ncm->port.cdc_filter = w_value;
 712                 value = 0;
 713                 break;
 714         /*
 715          * and optionally:
 716          * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
 717          * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
 718          * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
 719          * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
 720          * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
 721          * case USB_CDC_GET_ETHERNET_STATISTIC:
 722          */
 723
 724         case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 725                 | USB_CDC_GET_NTB_PARAMETERS:
 726
 727                 if (w_length == 0 || w_value != 0 || w_index != ncm->ctrl_id)
 728                         goto invalid;
 729                 value = w_length > sizeof ntb_parameters ?
 730                         sizeof ntb_parameters : w_length;
 731                 memcpy(req->buf, &ntb_parameters, value);
 732                 VDBG(cdev, "Host asked NTB parameters\n");
 733                 break;
 734
 735         case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 736                 | USB_CDC_GET_NTB_INPUT_SIZE:
 737
 738                 if (w_length < 4 || w_value != 0 || w_index != ncm->ctrl_id)
 739                         goto invalid;
 740                 put_unaligned_le32(ncm->port.fixed_in_len, req->buf);
 741                 value = 4;
 742                 VDBG(cdev, "Host asked INPUT SIZE, sending %d\n",
 743                      ncm->port.fixed_in_len);
 744                 break;
 745
 746         case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 747                 | USB_CDC_SET_NTB_INPUT_SIZE:
 748         {
 749                 if (w_length != 4 || w_value != 0 || w_index != ncm->ctrl_id)
 750                         goto invalid;
 751                 req->complete = ncm_ep0out_complete;
 752                 req->length = w_length;
 753                 req->context = f;
 754
 755                 value = req->length;
 756                 break;
 757         }
 758
 759         case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 760                 | USB_CDC_GET_NTB_FORMAT:
 761         {
 762                 uint16_t format;
 763
 764                 if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
 765                         goto invalid;
 766                 format = (ncm->parser_opts == &ndp16_opts) ? 0x0000 : 0x0001;
 767                 put_unaligned_le16(format, req->buf);
 768                 value = 2;
 769                 VDBG(cdev, "Host asked NTB FORMAT, sending %d\n", format);
 770                 break;
 771         }
 772
 773         case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 774                 | USB_CDC_SET_NTB_FORMAT:
 775         {
 776                 if (w_length != 0 || w_index != ncm->ctrl_id)
 777                         goto invalid;
 778                 switch (w_value) {
 779                 case 0x0000:
 780                         ncm->parser_opts = &ndp16_opts;
 781                         DBG(cdev, "NCM16 selected\n");
 782                         break;
 783                 case 0x0001:
 784                         ncm->parser_opts = &ndp32_opts;
 785                         DBG(cdev, "NCM32 selected\n");
 786                         break;
 787                 default:
 788                         goto invalid;
 789                 }
 790                 value = 0;
 791                 break;
 792         }
 793         case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 794                 | USB_CDC_GET_CRC_MODE:
 795         {
 796                 uint16_t is_crc;
 797
 798                 if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
 799                         goto invalid;
 800                 is_crc = ncm->is_crc ? 0x0001 : 0x0000;
 801                 put_unaligned_le16(is_crc, req->buf);
 802                 value = 2;
 803                 VDBG(cdev, "Host asked CRC MODE, sending %d\n", is_crc);
 804                 break;
 805         }
 806
 807         case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
 808                 | USB_CDC_SET_CRC_MODE:
 809         {
 810                 int ndp_hdr_crc = 0;
 811
 812                 if (w_length != 0 || w_index != ncm->ctrl_id)
 813                         goto invalid;
 814                 switch (w_value) {
 815                 case 0x0000:
 816                         ncm->is_crc = false;
 817                         ndp_hdr_crc = NCM_NDP_HDR_NOCRC;
 818                         DBG(cdev, "non-CRC mode selected\n");
 819                         break;
 820                 case 0x0001:
 821                         ncm->is_crc = true;
 822                         ndp_hdr_crc = NCM_NDP_HDR_CRC;
 823                         DBG(cdev, "CRC mode selected\n");
 824                         break;
 825                 default:
 826                         goto invalid;
 827                 }
 828                 ncm->ndp_sign = ncm->parser_opts->ndp_sign | ndp_hdr_crc;
 829                 value = 0;
 830                 break;
 831         }
 832
 833         /* and disabled in ncm descriptor: */
 834         /* case USB_CDC_GET_NET_ADDRESS: */
 835         /* case USB_CDC_SET_NET_ADDRESS: */
 836         /* case USB_CDC_GET_MAX_DATAGRAM_SIZE: */
 837         /* case USB_CDC_SET_MAX_DATAGRAM_SIZE: */
 838
 839         default:
 840 invalid:
 841                 DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
 842                         ctrl->bRequestType, ctrl->bRequest,
 843                         w_value, w_index, w_length);
 844         }
 845
 846         /* respond with data transfer or status phase? */
 847         if (value >= 0) {
 848                 DBG(cdev, "ncm req%02x.%02x v%04x i%04x l%d\n",
 849                         ctrl->bRequestType, ctrl->bRequest,
 850                         w_value, w_index, w_length);
 851                 req->zero = 0;
 852                 req->length = value;
 853                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 854                 if (value < 0)
 855                         ERROR(cdev, "ncm req %02x.%02x response err %d\n",
 856                                         ctrl->bRequestType, ctrl->bRequest,
 857                                         value);
 858         }
 859
 860         /* device either stalls (value < 0) or reports success */
 861         return value;
 862 }
 863
 864
 865 static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 866 {
 867         struct f_ncm            *ncm = func_to_ncm(f);
 868         struct usb_composite_dev *cdev = f->config->cdev;
 869
 870         /* Control interface has only altsetting 0 */
 871         if (intf == ncm->ctrl_id) {
 872                 if (alt != 0)
 873                         goto fail;
 874
 875                 DBG(cdev, "reset ncm control %d\n", intf);
 876                 usb_ep_disable(ncm->notify);
 877
 878                 if (!(ncm->notify->desc)) {
 879                         DBG(cdev, "init ncm ctrl %d\n", intf);
 880                         if (config_ep_by_speed(cdev->gadget, f, ncm->notify))
 881                                 goto fail;
 882                 }
 883                 usb_ep_enable(ncm->notify);
 884
 885         /* Data interface has two altsettings, 0 and 1 */
 886         } else if (intf == ncm->data_id) {
 887                 if (alt > 1)
 888                         goto fail;
 889
 890                 if (ncm->port.in_ep->enabled) {
 891                         DBG(cdev, "reset ncm\n");
 892                         ncm->timer_stopping = true;
 893                         ncm->netdev = NULL;
 894                         gether_disconnect(&ncm->port);
 895                         ncm_reset_values(ncm);
 896                 }
 897
 898                 /*
 899                  * CDC Network only sends data in non-default altsettings.
 900                  * Changing altsettings resets filters, statistics, etc.
 901                  */
 902                 if (alt == 1) {
 903                         struct net_device       *net;
 904
 905                         if (!ncm->port.in_ep->desc ||
 906                             !ncm->port.out_ep->desc) {
 907                                 DBG(cdev, "init ncm\n");
 908                                 if (config_ep_by_speed(cdev->gadget, f,
 909                                                        ncm->port.in_ep) ||
 910                                     config_ep_by_speed(cdev->gadget, f,
 911                                                        ncm->port.out_ep)) {
 912                                         ncm->port.in_ep->desc = NULL;
 913                                         ncm->port.out_ep->desc = NULL;
 914                                         goto fail;
 915                                 }
 916                         }
 917
 918                         /* TODO */
 919                         /* Enable zlps by default for NCM conformance;
 920                          * override for musb_hdrc (avoids txdma ovhead)
 921                          */
 922                         ncm->port.is_zlp_ok =
 923                                 gadget_is_zlp_supported(cdev->gadget);
 924                         ncm->port.cdc_filter = DEFAULT_FILTER;
 925                         DBG(cdev, "activate ncm\n");
 926                         net = gether_connect(&ncm->port);
 927                         if (IS_ERR(net))
 928                                 return PTR_ERR(net);
 929                         ncm->netdev = net;
 930                         ncm->timer_stopping = false;
 931                 }
 932
 933                 spin_lock(&ncm->lock);
 934                 ncm_notify(ncm);
 935                 spin_unlock(&ncm->lock);
 936         } else
 937                 goto fail;
 938
 939         return 0;
 940 fail:
 941         return -EINVAL;
 942 }
 943
 944 /*
 945  * Because the data interface supports multiple altsettings,
 946  * this NCM function *MUST* implement a get_alt() method.
 947  */
 948 static int ncm_get_alt(struct usb_function *f, unsigned intf)
 949 {
 950         struct f_ncm            *ncm = func_to_ncm(f);
 951
 952         if (intf == ncm->ctrl_id)
 953                 return 0;
 954         return ncm->port.in_ep->enabled ? 1 : 0;
 955 }
 956
 957 static struct sk_buff *package_for_tx(struct f_ncm *ncm)
 958 {
 959         __le16          *ntb_iter;
 960         struct sk_buff  *skb2 = NULL;
 961         unsigned        ndp_pad;
 962         unsigned        ndp_index;
 963         unsigned        new_len;
 964
 965         const struct ndp_parser_opts *opts = ncm->parser_opts;
 966         const int ndp_align = le16_to_cpu(ntb_parameters.wNdpInAlignment);
 967         const int dgram_idx_len = 2 * 2 * opts->dgram_item_len;
 968
 969         /* Stop the timer */
 970         hrtimer_try_to_cancel(&ncm->task_timer);
 971
 972         ndp_pad = ALIGN(ncm->skb_tx_data->len, ndp_align) -
 973                         ncm->skb_tx_data->len;
 974         ndp_index = ncm->skb_tx_data->len + ndp_pad;
 975         new_len = ndp_index + dgram_idx_len + ncm->skb_tx_ndp->len;
 976
 977         /* Set the final BlockLength and wNdpIndex */
 978         ntb_iter = (void *) ncm->skb_tx_data->data;
 979         /* Increment pointer to BlockLength */
 980         ntb_iter += 2 + 1 + 1;
 981         put_ncm(&ntb_iter, opts->block_length, new_len);
 982         put_ncm(&ntb_iter, opts->ndp_index, ndp_index);
 983
 984         /* Set the final NDP wLength */
 985         new_len = opts->ndp_size +
 986                         (ncm->ndp_dgram_count * dgram_idx_len);
 987         ncm->ndp_dgram_count = 0;
 988         /* Increment from start to wLength */
 989         ntb_iter = (void *) ncm->skb_tx_ndp->data;
 990         ntb_iter += 2;
 991         put_unaligned_le16(new_len, ntb_iter);
 992
 993         /* Merge the skbs */
 994         swap(skb2, ncm->skb_tx_data);
 995         if (ncm->skb_tx_data) {
 996                 dev_consume_skb_any(ncm->skb_tx_data);
 997                 ncm->skb_tx_data = NULL;
 998         }
 999
1000         /* Insert NDP alignment. */
1001         skb_put_zero(skb2, ndp_pad);
1002
1003         /* Copy NTB across. */
1004         skb_put_data(skb2, ncm->skb_tx_ndp->data, ncm->skb_tx_ndp->len);
1005         dev_consume_skb_any(ncm->skb_tx_ndp);
1006         ncm->skb_tx_ndp = NULL;
1007
1008         /* Insert zero'd datagram. */
1009         skb_put_zero(skb2, dgram_idx_len);
1010
1011         return skb2;
1012 }
1013
1014 static struct sk_buff *ncm_wrap_ntb(struct gether *port,
1015                                     struct sk_buff *skb)
1016 {
1017         struct f_ncm    *ncm = func_to_ncm(&port->func);
1018         struct sk_buff  *skb2 = NULL;
1019         int             ncb_len = 0;
1020         __le16          *ntb_data;
1021         __le16          *ntb_ndp;
1022         int             dgram_pad;
1023
1024         unsigned        max_size = ncm->port.fixed_in_len;
1025         const struct ndp_parser_opts *opts = ncm->parser_opts;
1026         const int ndp_align = le16_to_cpu(ntb_parameters.wNdpInAlignment);
1027         const int div = le16_to_cpu(ntb_parameters.wNdpInDivisor);
1028         const int rem = le16_to_cpu(ntb_parameters.wNdpInPayloadRemainder);
1029         const int dgram_idx_len = 2 * 2 * opts->dgram_item_len;
1030
1031         if (!skb && !ncm->skb_tx_data)
1032                 return NULL;
1033
1034         if (skb) {
1035                 /* Add the CRC if required up front */
1036                 if (ncm->is_crc) {
1037                         uint32_t        crc;
1038                         __le16          *crc_pos;
1039
1040                         crc = ~crc32_le(~0,
1041                                         skb->data,
1042                                         skb->len);
1043                         crc_pos = skb_put(skb, sizeof(uint32_t));
1044                         put_unaligned_le32(crc, crc_pos);
1045                 }
1046
1047                 /* If the new skb is too big for the current NCM NTB then
1048                  * set the current stored skb to be sent now and clear it
1049                  * ready for new data.
1050                  * NOTE: Assume maximum align for speed of calculation.
1051                  */
1052                 if (ncm->skb_tx_data
1053                     && (ncm->ndp_dgram_count >= TX_MAX_NUM_DPE
1054                     || (ncm->skb_tx_data->len +
1055                     div + rem + skb->len +
1056                     ncm->skb_tx_ndp->len + ndp_align + (2 * dgram_idx_len))
1057                     > max_size)) {
1058                         skb2 = package_for_tx(ncm);
1059                         if (!skb2)
1060                                 goto err;
1061                 }
1062
1063                 if (!ncm->skb_tx_data) {
1064                         ncb_len = opts->nth_size;
1065                         dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len;
1066                         ncb_len += dgram_pad;
1067
1068                         /* Create a new skb for the NTH and datagrams. */
1069                         ncm->skb_tx_data = alloc_skb(max_size, GFP_ATOMIC);
1070                         if (!ncm->skb_tx_data)
1071                                 goto err;
1072
1073                         ncm->skb_tx_data->dev = ncm->netdev;
1074                         ntb_data = skb_put_zero(ncm->skb_tx_data, ncb_len);
1075                         /* dwSignature */
1076                         put_unaligned_le32(opts->nth_sign, ntb_data);
1077                         ntb_data += 2;
1078                         /* wHeaderLength */
1079                         put_unaligned_le16(opts->nth_size, ntb_data++);
1080
1081                         /* Allocate an skb for storing the NDP,
1082                          * TX_MAX_NUM_DPE should easily suffice for a
1083                          * 16k packet.
1084                          */
1085                         ncm->skb_tx_ndp = alloc_skb((int)(opts->ndp_size
1086                                                     + opts->dpe_size
1087                                                     * TX_MAX_NUM_DPE),
1088                                                     GFP_ATOMIC);
1089                         if (!ncm->skb_tx_ndp)
1090                                 goto err;
1091
1092                         ncm->skb_tx_ndp->dev = ncm->netdev;
1093                         ntb_ndp = skb_put(ncm->skb_tx_ndp, opts->ndp_size);
1094                         memset(ntb_ndp, 0, ncb_len);
1095                         /* dwSignature */
1096                         put_unaligned_le32(ncm->ndp_sign, ntb_ndp);
1097                         ntb_ndp += 2;
1098
1099                         /* There is always a zeroed entry */
1100                         ncm->ndp_dgram_count = 1;
1101
1102                         /* Note: we skip opts->next_ndp_index */
1103                 }
1104
1105                 /* Delay the timer. */
1106                 hrtimer_start(&ncm->task_timer, TX_TIMEOUT_NSECS,
1107                               HRTIMER_MODE_REL);
1108
1109                 /* Add the datagram position entries */
1110                 ntb_ndp = skb_put_zero(ncm->skb_tx_ndp, dgram_idx_len);
1111
1112                 ncb_len = ncm->skb_tx_data->len;
1113                 dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len;
1114                 ncb_len += dgram_pad;
1115
1116                 /* (d)wDatagramIndex */
1117                 put_ncm(&ntb_ndp, opts->dgram_item_len, ncb_len);
1118                 /* (d)wDatagramLength */
1119                 put_ncm(&ntb_ndp, opts->dgram_item_len, skb->len);
1120                 ncm->ndp_dgram_count++;
1121
1122                 /* Add the new data to the skb */
1123                 skb_put_zero(ncm->skb_tx_data, dgram_pad);
1124                 skb_put_data(ncm->skb_tx_data, skb->data, skb->len);
1125                 dev_consume_skb_any(skb);
1126                 skb = NULL;
1127
1128         } else if (ncm->skb_tx_data && ncm->timer_force_tx) {
1129                 /* If the tx was requested because of a timeout then send */
1130                 skb2 = package_for_tx(ncm);
1131                 if (!skb2)
1132                         goto err;
1133         }
1134
1135         return skb2;
1136
1137 err:
1138         ncm->netdev->stats.tx_dropped++;
1139
1140         if (skb)
1141                 dev_kfree_skb_any(skb);
1142         if (ncm->skb_tx_data)
1143                 dev_kfree_skb_any(ncm->skb_tx_data);
1144         if (ncm->skb_tx_ndp)
1145                 dev_kfree_skb_any(ncm->skb_tx_ndp);
1146
1147         return NULL;
1148 }
1149
1150 /*
1151  * This transmits the NTB if there are frames waiting.
1152  */
1153 static void ncm_tx_tasklet(unsigned long data)
1154 {
1155         struct f_ncm    *ncm = (void *)data;
1156
1157         if (ncm->timer_stopping)
1158                 return;
1159
1160         /* Only send if data is available. */
1161         if (ncm->skb_tx_data) {
1162                 ncm->timer_force_tx = true;
1163
1164                 /* XXX This allowance of a NULL skb argument to ndo_start_xmit
1165                  * XXX is not sane.  The gadget layer should be redesigned so
1166                  * XXX that the dev->wrap() invocations to build SKBs is transparent
1167                  * XXX and performed in some way outside of the ndo_start_xmit
1168                  * XXX interface.
1169                  */
1170                 ncm->netdev->netdev_ops->ndo_start_xmit(NULL, ncm->netdev);
1171
1172                 ncm->timer_force_tx = false;
1173         }
1174 }
1175
1176 /*
1177  * The transmit should only be run if no skb data has been sent
1178  * for a certain duration.
1179  */
1180 static enum hrtimer_restart ncm_tx_timeout(struct hrtimer *data)
1181 {
1182         struct f_ncm *ncm = container_of(data, struct f_ncm, task_timer);
1183         tasklet_schedule(&ncm->tx_tasklet);
1184         return HRTIMER_NORESTART;
1185 }
1186
1187 static int ncm_unwrap_ntb(struct gether *port,
1188                           struct sk_buff *skb,
1189                           struct sk_buff_head *list)
1190 {
1191         struct f_ncm    *ncm = func_to_ncm(&port->func);
1192         __le16          *tmp = (void *) skb->data;
1193         unsigned        index, index2;
1194         int             ndp_index;
1195         unsigned        dg_len, dg_len2;
1196         unsigned        ndp_len;
1197         struct sk_buff  *skb2;
1198         int             ret = -EINVAL;
1199         unsigned        max_size = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
1200         const struct ndp_parser_opts *opts = ncm->parser_opts;
1201         unsigned        crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
1202         int             dgram_counter;
1203
1204         /* dwSignature */
1205         if (get_unaligned_le32(tmp) != opts->nth_sign) {
1206                 INFO(port->func.config->cdev, "Wrong NTH SIGN, skblen %d\n",
1207                         skb->len);
1208                 print_hex_dump(KERN_INFO, "HEAD:", DUMP_PREFIX_ADDRESS, 32, 1,
1209                                skb->data, 32, false);
1210
1211                 goto err;
1212         }
1213         tmp += 2;
1214         /* wHeaderLength */
1215         if (get_unaligned_le16(tmp++) != opts->nth_size) {
1216                 INFO(port->func.config->cdev, "Wrong NTB headersize\n");
1217                 goto err;
1218         }
1219         tmp++; /* skip wSequence */
1220
1221         /* (d)wBlockLength */
1222         if (get_ncm(&tmp, opts->block_length) > max_size) {
1223                 INFO(port->func.config->cdev, "OUT size exceeded\n");
1224                 goto err;
1225         }
1226
1227         ndp_index = get_ncm(&tmp, opts->ndp_index);
1228
1229         /* Run through all the NDP's in the NTB */
1230         do {
1231                 /* NCM 3.2 */
1232                 if (((ndp_index % 4) != 0) &&
1233                                 (ndp_index < opts->nth_size)) {
1234                         INFO(port->func.config->cdev, "Bad index: %#X\n",
1235                              ndp_index);
1236                         goto err;
1237                 }
1238
1239                 /* walk through NDP */
1240                 tmp = (void *)(skb->data + ndp_index);
1241                 if (get_unaligned_le32(tmp) != ncm->ndp_sign) {
1242                         INFO(port->func.config->cdev, "Wrong NDP SIGN\n");
1243                         goto err;
1244                 }
1245                 tmp += 2;
1246
1247                 ndp_len = get_unaligned_le16(tmp++);
1248                 /*
1249                  * NCM 3.3.1
1250                  * entry is 2 items
1251                  * item size is 16/32 bits, opts->dgram_item_len * 2 bytes
1252                  * minimal: struct usb_cdc_ncm_ndpX + normal entry + zero entry
1253                  * Each entry is a dgram index and a dgram length.
1254                  */
1255                 if ((ndp_len < opts->ndp_size
1256                                 + 2 * 2 * (opts->dgram_item_len * 2))
1257                                 || (ndp_len % opts->ndplen_align != 0)) {
1258                         INFO(port->func.config->cdev, "Bad NDP length: %#X\n",
1259                              ndp_len);
1260                         goto err;
1261                 }
1262                 tmp += opts->reserved1;
1263                 /* Check for another NDP (d)wNextNdpIndex */
1264                 ndp_index = get_ncm(&tmp, opts->next_ndp_index);
1265                 tmp += opts->reserved2;
1266
1267                 ndp_len -= opts->ndp_size;
1268                 index2 = get_ncm(&tmp, opts->dgram_item_len);
1269                 dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
1270                 dgram_counter = 0;
1271
1272                 do {
1273                         index = index2;
1274                         dg_len = dg_len2;
1275                         if (dg_len < 14 + crc_len) { /* ethernet hdr + crc */
1276                                 INFO(port->func.config->cdev,
1277                                      "Bad dgram length: %#X\n", dg_len);
1278                                 goto err;
1279                         }
1280                         if (ncm->is_crc) {
1281                                 uint32_t crc, crc2;
1282
1283                                 crc = get_unaligned_le32(skb->data +
1284                                                          index + dg_len -
1285                                                          crc_len);
1286                                 crc2 = ~crc32_le(~0,
1287                                                  skb->data + index,
1288                                                  dg_len - crc_len);
1289                                 if (crc != crc2) {
1290                                         INFO(port->func.config->cdev,
1291                                              "Bad CRC\n");
1292                                         goto err;
1293                                 }
1294                         }
1295
1296                         index2 = get_ncm(&tmp, opts->dgram_item_len);
1297                         dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
1298
1299                         /*
1300                          * Copy the data into a new skb.
1301                          * This ensures the truesize is correct
1302                          */
1303                         skb2 = netdev_alloc_skb_ip_align(ncm->netdev,
1304                                                          dg_len - crc_len);
1305                         if (skb2 == NULL)
1306                                 goto err;
1307                         skb_put_data(skb2, skb->data + index,
1308                                      dg_len - crc_len);
1309
1310                         skb_queue_tail(list, skb2);
1311
1312                         ndp_len -= 2 * (opts->dgram_item_len * 2);
1313
1314                         dgram_counter++;
1315
1316                         if (index2 == 0 || dg_len2 == 0)
1317                                 break;
1318                 } while (ndp_len > 2 * (opts->dgram_item_len * 2));
1319         } while (ndp_index);
1320
1321         dev_consume_skb_any(skb);
1322
1323         VDBG(port->func.config->cdev,
1324              "Parsed NTB with %d frames\n", dgram_counter);
1325         return 0;
1326 err:
1327         skb_queue_purge(list);
1328         dev_kfree_skb_any(skb);
1329         return ret;
1330 }
1331
1332 static void ncm_disable(struct usb_function *f)
1333 {
1334         struct f_ncm            *ncm = func_to_ncm(f);
1335         struct usb_composite_dev *cdev = f->config->cdev;
1336
1337         DBG(cdev, "ncm deactivated\n");
1338
1339         if (ncm->port.in_ep->enabled) {
1340                 ncm->timer_stopping = true;
1341                 ncm->netdev = NULL;
1342                 gether_disconnect(&ncm->port);
1343         }
1344
1345         if (ncm->notify->enabled) {
1346                 usb_ep_disable(ncm->notify);
1347                 ncm->notify->desc = NULL;
1348         }
1349 }
1350
1351 /*-------------------------------------------------------------------------*/
1352
1353 /*
1354  * Callbacks let us notify the host about connect/disconnect when the
1355  * net device is opened or closed.
1356  *
1357  * For testing, note that link states on this side include both opened
1358  * and closed variants of:
1359  *
1360  *   - disconnected/unconfigured
1361  *   - configured but inactive (data alt 0)
1362  *   - configured and active (data alt 1)
1363  *
1364  * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
1365  * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
1366  * imply the host is actually polling the notification endpoint, and
1367  * likewise that "active" doesn't imply it's actually using the data
1368  * endpoints for traffic.
1369  */
1370
1371 static void ncm_open(struct gether *geth)
1372 {
1373         struct f_ncm            *ncm = func_to_ncm(&geth->func);
1374
1375         DBG(ncm->port.func.config->cdev, "%s\n", __func__);
1376
1377         spin_lock(&ncm->lock);
1378         ncm->is_open = true;
1379         ncm_notify(ncm);
1380         spin_unlock(&ncm->lock);
1381 }
1382
1383 static void ncm_close(struct gether *geth)
1384 {
1385         struct f_ncm            *ncm = func_to_ncm(&geth->func);
1386
1387         DBG(ncm->port.func.config->cdev, "%s\n", __func__);
1388
1389         spin_lock(&ncm->lock);
1390         ncm->is_open = false;
1391         ncm_notify(ncm);
1392         spin_unlock(&ncm->lock);
1393 }
1394
1395 /*-------------------------------------------------------------------------*/
1396
1397 /* ethernet function driver setup/binding */
1398
1399 static int ncm_bind(struct usb_configuration *c, struct usb_function *f)
1400 {
1401         struct usb_composite_dev *cdev = c->cdev;
1402         struct f_ncm            *ncm = func_to_ncm(f);
1403         struct usb_string       *us;
1404         int                     status;
1405         struct usb_ep           *ep;
1406         struct f_ncm_opts       *ncm_opts;
1407
1408         if (!can_support_ecm(cdev->gadget))
1409                 return -EINVAL;
1410
1411         ncm_opts = container_of(f->fi, struct f_ncm_opts, func_inst);
1412         /*
1413          * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
1414          * configurations are bound in sequence with list_for_each_entry,
1415          * in each configuration its functions are bound in sequence
1416          * with list_for_each_entry, so we assume no race condition
1417          * with regard to ncm_opts->bound access
1418          */
1419         if (!ncm_opts->bound) {
1420                 mutex_lock(&ncm_opts->lock);
1421                 gether_set_gadget(ncm_opts->net, cdev->gadget);
1422                 status = gether_register_netdev(ncm_opts->net);
1423                 mutex_unlock(&ncm_opts->lock);
1424                 if (status)
1425                         return status;
1426                 ncm_opts->bound = true;
1427         }
1428         us = usb_gstrings_attach(cdev, ncm_strings,
1429                                  ARRAY_SIZE(ncm_string_defs));
1430         if (IS_ERR(us))
1431                 return PTR_ERR(us);
1432         ncm_control_intf.iInterface = us[STRING_CTRL_IDX].id;
1433         ncm_data_nop_intf.iInterface = us[STRING_DATA_IDX].id;
1434         ncm_data_intf.iInterface = us[STRING_DATA_IDX].id;
1435         ecm_desc.iMACAddress = us[STRING_MAC_IDX].id;
1436         ncm_iad_desc.iFunction = us[STRING_IAD_IDX].id;
1437
1438         /* allocate instance-specific interface IDs */
1439         status = usb_interface_id(c, f);
1440         if (status < 0)
1441                 goto fail;
1442         ncm->ctrl_id = status;
1443         ncm_iad_desc.bFirstInterface = status;
1444
1445         ncm_control_intf.bInterfaceNumber = status;
1446         ncm_union_desc.bMasterInterface0 = status;
1447
1448         status = usb_interface_id(c, f);
1449         if (status < 0)
1450                 goto fail;
1451         ncm->data_id = status;
1452
1453         ncm_data_nop_intf.bInterfaceNumber = status;
1454         ncm_data_intf.bInterfaceNumber = status;
1455         ncm_union_desc.bSlaveInterface0 = status;
1456
1457         status = -ENODEV;
1458
1459         /* allocate instance-specific endpoints */
1460         ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_in_desc);
1461         if (!ep)
1462                 goto fail;
1463         ncm->port.in_ep = ep;
1464
1465         ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_out_desc);
1466         if (!ep)
1467                 goto fail;
1468         ncm->port.out_ep = ep;
1469
1470         ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_notify_desc);
1471         if (!ep)
1472                 goto fail;
1473         ncm->notify = ep;
1474
1475         status = -ENOMEM;
1476
1477         /* allocate notification request and buffer */
1478         ncm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
1479         if (!ncm->notify_req)
1480                 goto fail;
1481         ncm->notify_req->buf = kmalloc(NCM_STATUS_BYTECOUNT, GFP_KERNEL);
1482         if (!ncm->notify_req->buf)
1483                 goto fail;
1484         ncm->notify_req->context = ncm;
1485         ncm->notify_req->complete = ncm_notify_complete;
1486
1487         /*
1488          * support all relevant hardware speeds... we expect that when
1489          * hardware is dual speed, all bulk-capable endpoints work at
1490          * both speeds
1491          */
1492         hs_ncm_in_desc.bEndpointAddress = fs_ncm_in_desc.bEndpointAddress;
1493         hs_ncm_out_desc.bEndpointAddress = fs_ncm_out_desc.bEndpointAddress;
1494         hs_ncm_notify_desc.bEndpointAddress =
1495                 fs_ncm_notify_desc.bEndpointAddress;
1496
1497         ss_ncm_in_desc.bEndpointAddress = fs_ncm_in_desc.bEndpointAddress;
1498         ss_ncm_out_desc.bEndpointAddress = fs_ncm_out_desc.bEndpointAddress;
1499         ss_ncm_notify_desc.bEndpointAddress =
1500                 fs_ncm_notify_desc.bEndpointAddress;
1501
1502         status = usb_assign_descriptors(f, ncm_fs_function, ncm_hs_function,
1503                         ncm_ss_function, NULL);
1504         if (status)
1505                 goto fail;
1506
1507         /*
1508          * NOTE:  all that is done without knowing or caring about
1509          * the network link ... which is unavailable to this code
1510          * until we're activated via set_alt().
1511          */
1512
1513         ncm->port.open = ncm_open;
1514         ncm->port.close = ncm_close;
1515
1516         tasklet_init(&ncm->tx_tasklet, ncm_tx_tasklet, (unsigned long) ncm);
1517         hrtimer_init(&ncm->task_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1518         ncm->task_timer.function = ncm_tx_timeout;
1519
1520         DBG(cdev, "CDC Network: %s speed IN/%s OUT/%s NOTIFY/%s\n",
1521                         gadget_is_superspeed(c->cdev->gadget) ? "super" :
1522                         gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
1523                         ncm->port.in_ep->name, ncm->port.out_ep->name,
1524                         ncm->notify->name);
1525         return 0;
1526
1527 fail:
1528         if (ncm->notify_req) {
1529                 kfree(ncm->notify_req->buf);
1530                 usb_ep_free_request(ncm->notify, ncm->notify_req);
1531         }
1532
1533         ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
1534
1535         return status;
1536 }
1537
1538 static inline struct f_ncm_opts *to_f_ncm_opts(struct config_item *item)
1539 {
1540         return container_of(to_config_group(item), struct f_ncm_opts,
1541                             func_inst.group);
1542 }
1543
1544 /* f_ncm_item_ops */
1545 USB_ETHERNET_CONFIGFS_ITEM(ncm);
1546
1547 /* f_ncm_opts_dev_addr */
1548 USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(ncm);
1549
1550 /* f_ncm_opts_host_addr */
1551 USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(ncm);
1552
1553 /* f_ncm_opts_qmult */
1554 USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(ncm);
1555
1556 /* f_ncm_opts_ifname */
1557 USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(ncm);
1558
1559 static struct configfs_attribute *ncm_attrs[] = {
1560         &ncm_opts_attr_dev_addr,
1561         &ncm_opts_attr_host_addr,
1562         &ncm_opts_attr_qmult,
1563         &ncm_opts_attr_ifname,
1564         NULL,
1565 };
1566
1567 static const struct config_item_type ncm_func_type = {
1568         .ct_item_ops    = &ncm_item_ops,
1569         .ct_attrs       = ncm_attrs,
1570         .ct_owner       = THIS_MODULE,
1571 };
1572
1573 static void ncm_free_inst(struct usb_function_instance *f)
1574 {
1575         struct f_ncm_opts *opts;
1576
1577         opts = container_of(f, struct f_ncm_opts, func_inst);
1578         if (opts->bound)
1579                 gether_cleanup(netdev_priv(opts->net));
1580         else
1581                 free_netdev(opts->net);
1582         kfree(opts);
1583 }
1584
1585 static struct usb_function_instance *ncm_alloc_inst(void)
1586 {
1587         struct f_ncm_opts *opts;
1588
1589         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1590         if (!opts)
1591                 return ERR_PTR(-ENOMEM);
1592         mutex_init(&opts->lock);
1593         opts->func_inst.free_func_inst = ncm_free_inst;
1594         opts->net = gether_setup_default();
1595         if (IS_ERR(opts->net)) {
1596                 struct net_device *net = opts->net;
1597                 kfree(opts);
1598                 return ERR_CAST(net);
1599         }
1600
1601         config_group_init_type_name(&opts->func_inst.group, "", &ncm_func_type);
1602
1603         return &opts->func_inst;
1604 }
1605
1606 static void ncm_free(struct usb_function *f)
1607 {
1608         struct f_ncm *ncm;
1609         struct f_ncm_opts *opts;
1610
1611         ncm = func_to_ncm(f);
1612         opts = container_of(f->fi, struct f_ncm_opts, func_inst);
1613         kfree(ncm);
1614         mutex_lock(&opts->lock);
1615         opts->refcnt--;
1616         mutex_unlock(&opts->lock);
1617 }
1618
1619 static void ncm_unbind(struct usb_configuration *c, struct usb_function *f)
1620 {
1621         struct f_ncm *ncm = func_to_ncm(f);
1622
1623         DBG(c->cdev, "ncm unbind\n");
1624
1625         hrtimer_cancel(&ncm->task_timer);
1626         tasklet_kill(&ncm->tx_tasklet);
1627
1628         ncm_string_defs[0].id = 0;
1629         usb_free_all_descriptors(f);
1630
1631         kfree(ncm->notify_req->buf);
1632         usb_ep_free_request(ncm->notify, ncm->notify_req);
1633 }
1634
1635 static struct usb_function *ncm_alloc(struct usb_function_instance *fi)
1636 {
1637         struct f_ncm            *ncm;
1638         struct f_ncm_opts       *opts;
1639         int status;
1640
1641         /* allocate and initialize one new instance */
1642         ncm = kzalloc(sizeof(*ncm), GFP_KERNEL);
1643         if (!ncm)
1644                 return ERR_PTR(-ENOMEM);
1645
1646         opts = container_of(fi, struct f_ncm_opts, func_inst);
1647         mutex_lock(&opts->lock);
1648         opts->refcnt++;
1649
1650         /* export host's Ethernet address in CDC format */
1651         status = gether_get_host_addr_cdc(opts->net, ncm->ethaddr,
1652                                       sizeof(ncm->ethaddr));
1653         if (status < 12) { /* strlen("01234567890a") */
1654                 kfree(ncm);
1655                 mutex_unlock(&opts->lock);
1656                 return ERR_PTR(-EINVAL);
1657         }
1658         ncm_string_defs[STRING_MAC_IDX].s = ncm->ethaddr;
1659
1660         spin_lock_init(&ncm->lock);
1661         ncm_reset_values(ncm);
1662         ncm->port.ioport = netdev_priv(opts->net);
1663         mutex_unlock(&opts->lock);
1664         ncm->port.is_fixed = true;
1665         ncm->port.supports_multi_frame = true;
1666
1667         ncm->port.func.name = "cdc_network";
1668         /* descriptors are per-instance copies */
1669         ncm->port.func.bind = ncm_bind;
1670         ncm->port.func.unbind = ncm_unbind;
1671         ncm->port.func.set_alt = ncm_set_alt;
1672         ncm->port.func.get_alt = ncm_get_alt;
1673         ncm->port.func.setup = ncm_setup;
1674         ncm->port.func.disable = ncm_disable;
1675         ncm->port.func.free_func = ncm_free;
1676
1677         ncm->port.wrap = ncm_wrap_ntb;
1678         ncm->port.unwrap = ncm_unwrap_ntb;
1679
1680         return &ncm->port.func;
1681 }
1682
1683 DECLARE_USB_FUNCTION_INIT(ncm, ncm_alloc_inst, ncm_alloc);
1684 MODULE_LICENSE("GPL");
1685 MODULE_AUTHOR("Yauheni Kaliuta");