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