2 * USB CDC EEM network interface driver
3 * Copyright (C) 2009 Oberthur Technologies
4 * by Omar Laazimani, Olivier Condemine
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.
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.
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
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>
37 * This driver is an implementation of the CDC "Ethernet Emulation
38 * Model" (EEM) specification, which encapsulates Ethernet frames
39 * for transport over USB using a simpler USB device model than the
40 * previous CDC "Ethernet Control Model" (ECM, or "CDC Ethernet").
42 * For details, see www.usb.org/developers/devclass_docs/CDC_EEM10.pdf
44 * This version has been tested with GIGAntIC WuaoW SIM Smart Card on 2.6.24,
45 * 2.6.27 and 2.6.30rc2 kernel.
46 * It has also been validated on Openmoko Om 2008.12 (based on 2.6.24 kernel).
47 * build on 23-April-2009
50 #define EEM_HEAD 2 /* 2 byte header */
52 /*-------------------------------------------------------------------------*/
54 static void eem_linkcmd_complete(struct urb *urb)
56 dev_kfree_skb(urb->context);
60 static void eem_linkcmd(struct usbnet *dev, struct sk_buff *skb)
65 urb = usb_alloc_urb(0, GFP_ATOMIC);
69 usb_fill_bulk_urb(urb, dev->udev, dev->out,
70 skb->data, skb->len, eem_linkcmd_complete, skb);
72 status = usb_submit_urb(urb, GFP_ATOMIC);
77 netdev_warn(dev->net, "link cmd failure\n");
82 static int eem_bind(struct usbnet *dev, struct usb_interface *intf)
86 status = usbnet_get_endpoints(dev, intf);
88 usb_set_intfdata(intf, NULL);
89 usb_driver_release_interface(driver_of(intf), intf);
93 /* no jumbogram (16K) support for now */
95 dev->net->hard_header_len += EEM_HEAD + ETH_FCS_LEN;
96 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
102 * EEM permits packing multiple Ethernet frames into USB transfers
103 * (a "bundle"), but for TX we don't try to do that.
105 static struct sk_buff *eem_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
108 struct sk_buff *skb2 = NULL;
113 /* When ((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket) is
114 * zero, stick two bytes of zero length EEM packet on the end.
115 * Else the framework would add invalid single byte padding,
116 * since it can't know whether ZLPs will be handled right by
117 * all the relevant hardware and software.
119 if (!((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket))
122 if (!skb_cloned(skb)) {
123 int headroom = skb_headroom(skb);
124 int tailroom = skb_tailroom(skb);
126 if ((tailroom >= ETH_FCS_LEN + padlen) &&
127 (headroom >= EEM_HEAD))
130 if ((headroom + tailroom)
131 > (EEM_HEAD + ETH_FCS_LEN + padlen)) {
132 skb->data = memmove(skb->head +
136 skb_set_tail_pointer(skb, len);
141 skb2 = skb_copy_expand(skb, EEM_HEAD, ETH_FCS_LEN + padlen, flags);
145 dev_kfree_skb_any(skb);
149 /* we don't use the "no Ethernet CRC" option */
150 crc = crc32_le(~0, skb->data, skb->len);
153 put_unaligned_le32(crc, skb_put(skb, 4));
155 /* EEM packet header format:
156 * b0..13: length of ethernet frame
157 * b14: bmCRC (1 == valid Ethernet CRC)
158 * b15: bmType (0 == data)
161 put_unaligned_le16(BIT(14) | len, skb_push(skb, 2));
163 /* Bundle a zero length EEM packet if needed */
165 put_unaligned_le16(0, skb_put(skb, 2));
170 static int eem_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
173 * Our task here is to strip off framing, leaving skb with one
174 * data frame for the usbnet framework code to process. But we
175 * may have received multiple EEM payloads, or command payloads.
176 * So we must process _everything_ as if it's a header, except
177 * maybe the last data payload
179 * REVISIT the framework needs updating so that when we consume
180 * all payloads (the last or only message was a command, or a
181 * zero length EEM packet) that is not accounted as an rx_error.
184 struct sk_buff *skb2 = NULL;
188 /* incomplete EEM header? */
189 if (skb->len < EEM_HEAD)
193 * EEM packet header format:
194 * b0..14: EEM type dependent (Data or Command)
197 header = get_unaligned_le16(skb->data);
198 skb_pull(skb, EEM_HEAD);
201 * The bmType bit helps to denote when EEM
202 * packet is data or command :
203 * bmType = 0 : EEM data payload
204 * bmType = 1 : EEM (link) command
206 if (header & BIT(15)) {
210 * EEM (link) command packet:
211 * b0..10: bmEEMCmdParam
213 * b14: bmReserved (must be 0)
214 * b15: 1 (EEM command)
216 if (header & BIT(14)) {
217 netdev_dbg(dev->net, "reserved command %04x\n",
222 bmEEMCmd = (header >> 11) & 0x7;
225 /* Responding to echo requests is mandatory. */
226 case 0: /* Echo command */
227 len = header & 0x7FF;
233 skb2 = skb_clone(skb, GFP_ATOMIC);
237 put_unaligned_le16(BIT(15) | (1 << 11) | len,
239 eem_linkcmd(dev, skb2);
243 * Host may choose to ignore hints.
244 * - suspend: peripheral ready to suspend
245 * - response: suggest N millisec polling
246 * - response complete: suggest N sec polling
248 * Suspend is reported and maybe heeded.
250 case 2: /* Suspend hint */
251 usbnet_device_suggests_idle(dev);
253 case 3: /* Response hint */
254 case 4: /* Response complete hint */
258 * Hosts should never receive host-to-peripheral
259 * or reserved command codes; or responses to an
260 * echo command we didn't send.
262 case 1: /* Echo response */
264 default: /* reserved */
265 netdev_warn(dev->net,
266 "unexpected link command %d\n",
275 /* zero length EEM packet? */
280 * EEM data packet header :
281 * b0..13: length of ethernet frame
285 len = header & 0x3FFF;
287 /* bogus EEM payload? */
291 /* bogus ethernet frame? */
292 if (len < (ETH_HLEN + ETH_FCS_LEN))
296 * Treat the last payload differently: framework
297 * code expects our "fixup" to have stripped off
298 * headers, so "skb" is a data packet (or error).
299 * Else if it's not the last payload, keep "skb"
300 * for further processing.
302 is_last = (len == skb->len);
306 skb2 = skb_clone(skb, GFP_ATOMIC);
312 * The bmCRC helps to denote when the CRC field in
313 * the Ethernet frame contains a calculated CRC:
314 * bmCRC = 1 : CRC is calculated
315 * bmCRC = 0 : CRC = 0xDEADBEEF
317 if (header & BIT(14)) {
318 crc = get_unaligned_le32(skb2->data
319 + len - ETH_FCS_LEN);
320 crc2 = ~crc32_le(~0, skb2->data, skb2->len
323 crc = get_unaligned_be32(skb2->data
324 + len - ETH_FCS_LEN);
327 skb_trim(skb2, len - ETH_FCS_LEN);
332 if (unlikely(crc != crc2)) {
333 dev->net->stats.rx_errors++;
334 dev_kfree_skb_any(skb2);
336 usbnet_skb_return(dev, skb2);
346 static const struct driver_info eem_info = {
347 .description = "CDC EEM Device",
348 .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
350 .rx_fixup = eem_rx_fixup,
351 .tx_fixup = eem_tx_fixup,
354 /*-------------------------------------------------------------------------*/
356 static const struct usb_device_id products[] = {
358 USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_EEM,
360 .driver_info = (unsigned long) &eem_info,
363 /* EMPTY == end of list */
366 MODULE_DEVICE_TABLE(usb, products);
368 static struct usb_driver eem_driver = {
370 .id_table = products,
371 .probe = usbnet_probe,
372 .disconnect = usbnet_disconnect,
373 .suspend = usbnet_suspend,
374 .resume = usbnet_resume,
375 .disable_hub_initiated_lpm = 1,
378 module_usb_driver(eem_driver);
380 MODULE_AUTHOR("Omar Laazimani <omar.oberthur@gmail.com>");
381 MODULE_DESCRIPTION("USB CDC EEM");
382 MODULE_LICENSE("GPL");