drivers/net/usb/cdc_eem.c

   1 /*
   2  * USB CDC EEM network interface driver
   3  * Copyright (C) 2009 Oberthur Technologies
   4  * by Omar Laazimani, Olivier Condemine
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/init.h>
  23 #include <linux/netdevice.h>
  24 #include <linux/etherdevice.h>
  25 #include <linux/ctype.h>
  26 #include <linux/ethtool.h>
  27 #include <linux/workqueue.h>
  28 #include <linux/mii.h>
  29 #include <linux/usb.h>
  30 #include <linux/crc32.h>
  31 #include <linux/usb/cdc.h>
  32 #include <linux/usb/usbnet.h>
  33 #include <linux/gfp.h>
  34 #include <linux/if_vlan.h>
  35
  36
  37 /*
  38  * This driver is an implementation of the CDC "Ethernet Emulation
  39  * Model" (EEM) specification, which encapsulates Ethernet frames
  40  * for transport over USB using a simpler USB device model than the
  41  * previous CDC "Ethernet Control Model" (ECM, or "CDC Ethernet").
  42  *
  43  * For details, see www.usb.org/developers/devclass_docs/CDC_EEM10.pdf
  44  *
  45  * This version has been tested with GIGAntIC WuaoW SIM Smart Card on 2.6.24,
  46  * 2.6.27 and 2.6.30rc2 kernel.
  47  * It has also been validated on Openmoko Om 2008.12 (based on 2.6.24 kernel).
  48  * build on 23-April-2009
  49  */
  50
  51 #define EEM_HEAD        2               /* 2 byte header */
  52
  53 /*-------------------------------------------------------------------------*/
  54
  55 static void eem_linkcmd_complete(struct urb *urb)
  56 {
  57         dev_kfree_skb(urb->context);
  58         usb_free_urb(urb);
  59 }
  60
  61 static void eem_linkcmd(struct usbnet *dev, struct sk_buff *skb)
  62 {
  63         struct urb              *urb;
  64         int                     status;
  65
  66         urb = usb_alloc_urb(0, GFP_ATOMIC);
  67         if (!urb)
  68                 goto fail;
  69
  70         usb_fill_bulk_urb(urb, dev->udev, dev->out,
  71                         skb->data, skb->len, eem_linkcmd_complete, skb);
  72
  73         status = usb_submit_urb(urb, GFP_ATOMIC);
  74         if (status) {
  75                 usb_free_urb(urb);
  76 fail:
  77                 dev_kfree_skb(skb);
  78                 netdev_warn(dev->net, "link cmd failure\n");
  79                 return;
  80         }
  81 }
  82
  83 static int eem_bind(struct usbnet *dev, struct usb_interface *intf)
  84 {
  85         int status = 0;
  86
  87         status = usbnet_get_endpoints(dev, intf);
  88         if (status < 0) {
  89                 usb_set_intfdata(intf, NULL);
  90                 usb_driver_release_interface(driver_of(intf), intf);
  91                 return status;
  92         }
  93
  94         /* no jumbogram (16K) support for now */
  95
  96         dev->net->hard_header_len += EEM_HEAD + ETH_FCS_LEN + VLAN_HLEN;
  97         dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
  98
  99         return 0;
 100 }
 101
 102 /*
 103  * EEM permits packing multiple Ethernet frames into USB transfers
 104  * (a "bundle"), but for TX we don't try to do that.
 105  */
 106 static struct sk_buff *eem_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
 107                                        gfp_t flags)
 108 {
 109         struct sk_buff  *skb2 = NULL;
 110         u16             len = skb->len;
 111         u32             crc = 0;
 112         int             padlen = 0;
 113
 114         /* When ((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket) is
 115          * zero, stick two bytes of zero length EEM packet on the end.
 116          * Else the framework would add invalid single byte padding,
 117          * since it can't know whether ZLPs will be handled right by
 118          * all the relevant hardware and software.
 119          */
 120         if (!((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket))
 121                 padlen += 2;
 122
 123         if (!skb_cloned(skb)) {
 124                 int     headroom = skb_headroom(skb);
 125                 int     tailroom = skb_tailroom(skb);
 126
 127                 if ((tailroom >= ETH_FCS_LEN + padlen) &&
 128                     (headroom >= EEM_HEAD))
 129                         goto done;
 130
 131                 if ((headroom + tailroom)
 132                                 > (EEM_HEAD + ETH_FCS_LEN + padlen)) {
 133                         skb->data = memmove(skb->head +
 134                                         EEM_HEAD,
 135                                         skb->data,
 136                                         skb->len);
 137                         skb_set_tail_pointer(skb, len);
 138                         goto done;
 139                 }
 140         }
 141
 142         skb2 = skb_copy_expand(skb, EEM_HEAD, ETH_FCS_LEN + padlen, flags);
 143         if (!skb2)
 144                 return NULL;
 145
 146         dev_kfree_skb_any(skb);
 147         skb = skb2;
 148
 149 done:
 150         /* we don't use the "no Ethernet CRC" option */
 151         crc = crc32_le(~0, skb->data, skb->len);
 152         crc = ~crc;
 153
 154         put_unaligned_le32(crc, skb_put(skb, 4));
 155
 156         /* EEM packet header format:
 157          * b0..13:      length of ethernet frame
 158          * b14:         bmCRC (1 == valid Ethernet CRC)
 159          * b15:         bmType (0 == data)
 160          */
 161         len = skb->len;
 162         put_unaligned_le16(BIT(14) | len, skb_push(skb, 2));
 163
 164         /* Bundle a zero length EEM packet if needed */
 165         if (padlen)
 166                 put_unaligned_le16(0, skb_put(skb, 2));
 167
 168         return skb;
 169 }
 170
 171 static int eem_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 172 {
 173         /*
 174          * Our task here is to strip off framing, leaving skb with one
 175          * data frame for the usbnet framework code to process.  But we
 176          * may have received multiple EEM payloads, or command payloads.
 177          * So we must process _everything_ as if it's a header, except
 178          * maybe the last data payload
 179          *
 180          * REVISIT the framework needs updating so that when we consume
 181          * all payloads (the last or only message was a command, or a
 182          * zero length EEM packet) that is not accounted as an rx_error.
 183          */
 184         do {
 185                 struct sk_buff  *skb2 = NULL;
 186                 u16             header;
 187                 u16             len = 0;
 188
 189                 /* incomplete EEM header? */
 190                 if (skb->len < EEM_HEAD)
 191                         return 0;
 192
 193                 /*
 194                  * EEM packet header format:
 195                  * b0..14:      EEM type dependent (Data or Command)
 196                  * b15:         bmType
 197                  */
 198                 header = get_unaligned_le16(skb->data);
 199                 skb_pull(skb, EEM_HEAD);
 200
 201                 /*
 202                  * The bmType bit helps to denote when EEM
 203                  * packet is data or command :
 204                  *      bmType = 0      : EEM data payload
 205                  *      bmType = 1      : EEM (link) command
 206                  */
 207                 if (header & BIT(15)) {
 208                         u16     bmEEMCmd;
 209
 210                         /*
 211                          * EEM (link) command packet:
 212                          * b0..10:      bmEEMCmdParam
 213                          * b11..13:     bmEEMCmd
 214                          * b14:         bmReserved (must be 0)
 215                          * b15:         1 (EEM command)
 216                          */
 217                         if (header & BIT(14)) {
 218                                 netdev_dbg(dev->net, "reserved command %04x\n",
 219                                            header);
 220                                 continue;
 221                         }
 222
 223                         bmEEMCmd = (header >> 11) & 0x7;
 224                         switch (bmEEMCmd) {
 225
 226                         /* Responding to echo requests is mandatory. */
 227                         case 0:         /* Echo command */
 228                                 len = header & 0x7FF;
 229
 230                                 /* bogus command? */
 231                                 if (skb->len < len)
 232                                         return 0;
 233
 234                                 skb2 = skb_clone(skb, GFP_ATOMIC);
 235                                 if (unlikely(!skb2))
 236                                         goto next;
 237                                 skb_trim(skb2, len);
 238                                 put_unaligned_le16(BIT(15) | (1 << 11) | len,
 239                                                 skb_push(skb2, 2));
 240                                 eem_linkcmd(dev, skb2);
 241                                 break;
 242
 243                         /*
 244                          * Host may choose to ignore hints.
 245                          *  - suspend: peripheral ready to suspend
 246                          *  - response: suggest N millisec polling
 247                          *  - response complete: suggest N sec polling
 248                          *
 249                          * Suspend is reported and maybe heeded.
 250                          */
 251                         case 2:         /* Suspend hint */
 252                                 usbnet_device_suggests_idle(dev);
 253                                 continue;
 254                         case 3:         /* Response hint */
 255                         case 4:         /* Response complete hint */
 256                                 continue;
 257
 258                         /*
 259                          * Hosts should never receive host-to-peripheral
 260                          * or reserved command codes; or responses to an
 261                          * echo command we didn't send.
 262                          */
 263                         case 1:         /* Echo response */
 264                         case 5:         /* Tickle */
 265                         default:        /* reserved */
 266                                 netdev_warn(dev->net,
 267                                             "unexpected link command %d\n",
 268                                             bmEEMCmd);
 269                                 continue;
 270                         }
 271
 272                 } else {
 273                         u32     crc, crc2;
 274                         int     is_last;
 275
 276                         /* zero length EEM packet? */
 277                         if (header == 0)
 278                                 continue;
 279
 280                         /*
 281                          * EEM data packet header :
 282                          * b0..13:      length of ethernet frame
 283                          * b14:         bmCRC
 284                          * b15:         0 (EEM data)
 285                          */
 286                         len = header & 0x3FFF;
 287
 288                         /* bogus EEM payload? */
 289                         if (skb->len < len)
 290                                 return 0;
 291
 292                         /* bogus ethernet frame? */
 293                         if (len < (ETH_HLEN + ETH_FCS_LEN))
 294                                 goto next;
 295
 296                         /*
 297                          * Treat the last payload differently: framework
 298                          * code expects our "fixup" to have stripped off
 299                          * headers, so "skb" is a data packet (or error).
 300                          * Else if it's not the last payload, keep "skb"
 301                          * for further processing.
 302                          */
 303                         is_last = (len == skb->len);
 304                         if (is_last)
 305                                 skb2 = skb;
 306                         else {
 307                                 skb2 = skb_clone(skb, GFP_ATOMIC);
 308                                 if (unlikely(!skb2))
 309                                         return 0;
 310                         }
 311
 312                         /*
 313                          * The bmCRC helps to denote when the CRC field in
 314                          * the Ethernet frame contains a calculated CRC:
 315                          *      bmCRC = 1       : CRC is calculated
 316                          *      bmCRC = 0       : CRC = 0xDEADBEEF
 317                          */
 318                         if (header & BIT(14)) {
 319                                 crc = get_unaligned_le32(skb2->data
 320                                                 + len - ETH_FCS_LEN);
 321                                 crc2 = ~crc32_le(~0, skb2->data, skb2->len
 322                                                 - ETH_FCS_LEN);
 323                         } else {
 324                                 crc = get_unaligned_be32(skb2->data
 325                                                 + len - ETH_FCS_LEN);
 326                                 crc2 = 0xdeadbeef;
 327                         }
 328                         skb_trim(skb2, len - ETH_FCS_LEN);
 329
 330                         if (is_last)
 331                                 return crc == crc2;
 332
 333                         if (unlikely(crc != crc2)) {
 334                                 dev->net->stats.rx_errors++;
 335                                 dev_kfree_skb_any(skb2);
 336                         } else
 337                                 usbnet_skb_return(dev, skb2);
 338                 }
 339
 340 next:
 341                 skb_pull(skb, len);
 342         } while (skb->len);
 343
 344         return 1;
 345 }
 346
 347 static const struct driver_info eem_info = {
 348         .description =  "CDC EEM Device",
 349         .flags =        FLAG_ETHER | FLAG_POINTTOPOINT,
 350         .bind =         eem_bind,
 351         .rx_fixup =     eem_rx_fixup,
 352         .tx_fixup =     eem_tx_fixup,
 353 };
 354
 355 /*-------------------------------------------------------------------------*/
 356
 357 static const struct usb_device_id products[] = {
 358 {
 359         USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_EEM,
 360                         USB_CDC_PROTO_EEM),
 361         .driver_info = (unsigned long) &eem_info,
 362 },
 363 {
 364         /* EMPTY == end of list */
 365 },
 366 };
 367 MODULE_DEVICE_TABLE(usb, products);
 368
 369 static struct usb_driver eem_driver = {
 370         .name =         "cdc_eem",
 371         .id_table =     products,
 372         .probe =        usbnet_probe,
 373         .disconnect =   usbnet_disconnect,
 374         .suspend =      usbnet_suspend,
 375         .resume =       usbnet_resume,
 376         .disable_hub_initiated_lpm = 1,
 377 };
 378
 379 module_usb_driver(eem_driver);
 380
 381 MODULE_AUTHOR("Omar Laazimani <omar.oberthur@gmail.com>");
 382 MODULE_DESCRIPTION("USB CDC EEM");
 383 MODULE_LICENSE("GPL");