2 * f_eem.c -- USB CDC Ethernet (EEM) link function driver
4 * Copyright (C) 2003-2005,2008 David Brownell
5 * Copyright (C) 2008 Nokia Corporation
6 * Copyright (C) 2009 EF Johnson Technologies
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/kernel.h>
24 #include <linux/device.h>
25 #include <linux/etherdevice.h>
26 #include <linux/crc32.h>
27 #include <linux/slab.h>
34 * This function is a "CDC Ethernet Emulation Model" (CDC EEM)
43 static inline struct f_eem
*func_to_eem(struct usb_function
*f
)
45 return container_of(f
, struct f_eem
, port
.func
);
48 /*-------------------------------------------------------------------------*/
50 /* interface descriptor: */
52 static struct usb_interface_descriptor eem_intf __initdata
= {
53 .bLength
= sizeof eem_intf
,
54 .bDescriptorType
= USB_DT_INTERFACE
,
56 /* .bInterfaceNumber = DYNAMIC */
58 .bInterfaceClass
= USB_CLASS_COMM
,
59 .bInterfaceSubClass
= USB_CDC_SUBCLASS_EEM
,
60 .bInterfaceProtocol
= USB_CDC_PROTO_EEM
,
61 /* .iInterface = DYNAMIC */
64 /* full speed support: */
66 static struct usb_endpoint_descriptor eem_fs_in_desc __initdata
= {
67 .bLength
= USB_DT_ENDPOINT_SIZE
,
68 .bDescriptorType
= USB_DT_ENDPOINT
,
70 .bEndpointAddress
= USB_DIR_IN
,
71 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
74 static struct usb_endpoint_descriptor eem_fs_out_desc __initdata
= {
75 .bLength
= USB_DT_ENDPOINT_SIZE
,
76 .bDescriptorType
= USB_DT_ENDPOINT
,
78 .bEndpointAddress
= USB_DIR_OUT
,
79 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
82 static struct usb_descriptor_header
*eem_fs_function
[] __initdata
= {
83 /* CDC EEM control descriptors */
84 (struct usb_descriptor_header
*) &eem_intf
,
85 (struct usb_descriptor_header
*) &eem_fs_in_desc
,
86 (struct usb_descriptor_header
*) &eem_fs_out_desc
,
90 /* high speed support: */
92 static struct usb_endpoint_descriptor eem_hs_in_desc __initdata
= {
93 .bLength
= USB_DT_ENDPOINT_SIZE
,
94 .bDescriptorType
= USB_DT_ENDPOINT
,
96 .bEndpointAddress
= USB_DIR_IN
,
97 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
98 .wMaxPacketSize
= cpu_to_le16(512),
101 static struct usb_endpoint_descriptor eem_hs_out_desc __initdata
= {
102 .bLength
= USB_DT_ENDPOINT_SIZE
,
103 .bDescriptorType
= USB_DT_ENDPOINT
,
105 .bEndpointAddress
= USB_DIR_OUT
,
106 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
107 .wMaxPacketSize
= cpu_to_le16(512),
110 static struct usb_descriptor_header
*eem_hs_function
[] __initdata
= {
111 /* CDC EEM control descriptors */
112 (struct usb_descriptor_header
*) &eem_intf
,
113 (struct usb_descriptor_header
*) &eem_hs_in_desc
,
114 (struct usb_descriptor_header
*) &eem_hs_out_desc
,
118 /* string descriptors: */
120 static struct usb_string eem_string_defs
[] = {
121 [0].s
= "CDC Ethernet Emulation Model (EEM)",
122 { } /* end of list */
125 static struct usb_gadget_strings eem_string_table
= {
126 .language
= 0x0409, /* en-us */
127 .strings
= eem_string_defs
,
130 static struct usb_gadget_strings
*eem_strings
[] = {
135 /*-------------------------------------------------------------------------*/
137 static int eem_setup(struct usb_function
*f
, const struct usb_ctrlrequest
*ctrl
)
139 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
140 int value
= -EOPNOTSUPP
;
141 u16 w_index
= le16_to_cpu(ctrl
->wIndex
);
142 u16 w_value
= le16_to_cpu(ctrl
->wValue
);
143 u16 w_length
= le16_to_cpu(ctrl
->wLength
);
145 DBG(cdev
, "invalid control req%02x.%02x v%04x i%04x l%d\n",
146 ctrl
->bRequestType
, ctrl
->bRequest
,
147 w_value
, w_index
, w_length
);
149 /* device either stalls (value < 0) or reports success */
154 static int eem_set_alt(struct usb_function
*f
, unsigned intf
, unsigned alt
)
156 struct f_eem
*eem
= func_to_eem(f
);
157 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
158 struct net_device
*net
;
160 /* we know alt == 0, so this is an activation or a reset */
164 if (intf
== eem
->ctrl_id
) {
166 if (eem
->port
.in_ep
->driver_data
) {
167 DBG(cdev
, "reset eem\n");
168 gether_disconnect(&eem
->port
);
171 if (!eem
->port
.in_ep
->desc
|| !eem
->port
.out_ep
->desc
) {
172 DBG(cdev
, "init eem\n");
173 if (config_ep_by_speed(cdev
->gadget
, f
,
175 config_ep_by_speed(cdev
->gadget
, f
,
177 eem
->port
.in_ep
->desc
= NULL
;
178 eem
->port
.out_ep
->desc
= NULL
;
183 /* zlps should not occur because zero-length EEM packets
184 * will be inserted in those cases where they would occur
186 eem
->port
.is_zlp_ok
= 1;
187 eem
->port
.cdc_filter
= DEFAULT_FILTER
;
188 DBG(cdev
, "activate eem\n");
189 net
= gether_connect(&eem
->port
);
200 static void eem_disable(struct usb_function
*f
)
202 struct f_eem
*eem
= func_to_eem(f
);
203 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
205 DBG(cdev
, "eem deactivated\n");
207 if (eem
->port
.in_ep
->driver_data
)
208 gether_disconnect(&eem
->port
);
211 /*-------------------------------------------------------------------------*/
213 /* EEM function driver setup/binding */
216 eem_bind(struct usb_configuration
*c
, struct usb_function
*f
)
218 struct usb_composite_dev
*cdev
= c
->cdev
;
219 struct f_eem
*eem
= func_to_eem(f
);
223 /* allocate instance-specific interface IDs */
224 status
= usb_interface_id(c
, f
);
227 eem
->ctrl_id
= status
;
228 eem_intf
.bInterfaceNumber
= status
;
232 /* allocate instance-specific endpoints */
233 ep
= usb_ep_autoconfig(cdev
->gadget
, &eem_fs_in_desc
);
236 eem
->port
.in_ep
= ep
;
237 ep
->driver_data
= cdev
; /* claim */
239 ep
= usb_ep_autoconfig(cdev
->gadget
, &eem_fs_out_desc
);
242 eem
->port
.out_ep
= ep
;
243 ep
->driver_data
= cdev
; /* claim */
247 /* copy descriptors, and track endpoint copies */
248 f
->descriptors
= usb_copy_descriptors(eem_fs_function
);
252 /* support all relevant hardware speeds... we expect that when
253 * hardware is dual speed, all bulk-capable endpoints work at
256 if (gadget_is_dualspeed(c
->cdev
->gadget
)) {
257 eem_hs_in_desc
.bEndpointAddress
=
258 eem_fs_in_desc
.bEndpointAddress
;
259 eem_hs_out_desc
.bEndpointAddress
=
260 eem_fs_out_desc
.bEndpointAddress
;
262 /* copy descriptors, and track endpoint copies */
263 f
->hs_descriptors
= usb_copy_descriptors(eem_hs_function
);
264 if (!f
->hs_descriptors
)
268 DBG(cdev
, "CDC Ethernet (EEM): %s speed IN/%s OUT/%s\n",
269 gadget_is_dualspeed(c
->cdev
->gadget
) ? "dual" : "full",
270 eem
->port
.in_ep
->name
, eem
->port
.out_ep
->name
);
275 usb_free_descriptors(f
->descriptors
);
277 /* we might as well release our claims on endpoints */
278 if (eem
->port
.out_ep
->desc
)
279 eem
->port
.out_ep
->driver_data
= NULL
;
280 if (eem
->port
.in_ep
->desc
)
281 eem
->port
.in_ep
->driver_data
= NULL
;
283 ERROR(cdev
, "%s: can't bind, err %d\n", f
->name
, status
);
289 eem_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
291 struct f_eem
*eem
= func_to_eem(f
);
293 DBG(c
->cdev
, "eem unbind\n");
295 if (gadget_is_dualspeed(c
->cdev
->gadget
))
296 usb_free_descriptors(f
->hs_descriptors
);
297 usb_free_descriptors(f
->descriptors
);
301 static void eem_cmd_complete(struct usb_ep
*ep
, struct usb_request
*req
)
303 struct sk_buff
*skb
= (struct sk_buff
*)req
->context
;
305 dev_kfree_skb_any(skb
);
309 * Add the EEM header and ethernet checksum.
310 * We currently do not attempt to put multiple ethernet frames
311 * into a single USB transfer
313 static struct sk_buff
*eem_wrap(struct gether
*port
, struct sk_buff
*skb
)
315 struct sk_buff
*skb2
= NULL
;
316 struct usb_ep
*in
= port
->in_ep
;
320 if (!skb_cloned(skb
)) {
321 int headroom
= skb_headroom(skb
);
322 int tailroom
= skb_tailroom(skb
);
324 /* When (len + EEM_HLEN + ETH_FCS_LEN) % in->maxpacket) is 0,
325 * stick two bytes of zero-length EEM packet on the end.
327 if (((len
+ EEM_HLEN
+ ETH_FCS_LEN
) % in
->maxpacket
) == 0)
330 if ((tailroom
>= (ETH_FCS_LEN
+ padlen
)) &&
331 (headroom
>= EEM_HLEN
))
335 skb2
= skb_copy_expand(skb
, EEM_HLEN
, ETH_FCS_LEN
+ padlen
, GFP_ATOMIC
);
336 dev_kfree_skb_any(skb
);
342 /* use the "no CRC" option */
343 put_unaligned_be32(0xdeadbeef, skb_put(skb
, 4));
345 /* EEM packet header format:
346 * b0..13: length of ethernet frame
347 * b14: bmCRC (0 == sentinel CRC)
348 * b15: bmType (0 == data)
351 put_unaligned_le16(len
& 0x3FFF, skb_push(skb
, 2));
353 /* add a zero-length EEM packet, if needed */
355 put_unaligned_le16(0, skb_put(skb
, 2));
361 * Remove the EEM header. Note that there can be many EEM packets in a single
362 * USB transfer, so we need to break them out and handle them independently.
364 static int eem_unwrap(struct gether
*port
,
366 struct sk_buff_head
*list
)
368 struct usb_composite_dev
*cdev
= port
->func
.config
->cdev
;
372 struct sk_buff
*skb2
;
376 if (skb
->len
< EEM_HLEN
) {
378 DBG(cdev
, "invalid EEM header\n");
382 /* remove the EEM header */
383 header
= get_unaligned_le16(skb
->data
);
384 skb_pull(skb
, EEM_HLEN
);
386 /* EEM packet header format:
387 * b0..14: EEM type dependent (data or command)
388 * b15: bmType (0 == data, 1 == command)
390 if (header
& BIT(15)) {
391 struct usb_request
*req
= cdev
->req
;
394 /* EEM command packet format:
395 * b0..10: bmEEMCmdParam
397 * b14: reserved (must be zero)
398 * b15: bmType (1 == command)
400 if (header
& BIT(14))
403 bmEEMCmd
= (header
>> 11) & 0x7;
406 len
= header
& 0x7FF;
407 if (skb
->len
< len
) {
412 skb2
= skb_clone(skb
, GFP_ATOMIC
);
413 if (unlikely(!skb2
)) {
414 DBG(cdev
, "EEM echo response error\n");
418 put_unaligned_le16(BIT(15) | BIT(11) | len
,
420 skb_copy_bits(skb2
, 0, req
->buf
, skb2
->len
);
421 req
->length
= skb2
->len
;
422 req
->complete
= eem_cmd_complete
;
425 if (usb_ep_queue(port
->in_ep
, req
, GFP_ATOMIC
))
426 DBG(cdev
, "echo response queue fail\n");
429 case 1: /* echo response */
430 case 2: /* suspend hint */
431 case 3: /* response hint */
432 case 4: /* response complete hint */
434 default: /* reserved */
439 struct sk_buff
*skb3
;
441 /* check for zero-length EEM packet */
445 /* EEM data packet format:
446 * b0..13: length of ethernet frame
447 * b14: bmCRC (0 == sentinel, 1 == calculated)
448 * b15: bmType (0 == data)
450 len
= header
& 0x3FFF;
452 || (len
< (ETH_HLEN
+ ETH_FCS_LEN
))) {
458 if (header
& BIT(14)) {
459 crc
= get_unaligned_le32(skb
->data
+ len
462 skb
->data
, len
- ETH_FCS_LEN
);
464 crc
= get_unaligned_be32(skb
->data
+ len
469 DBG(cdev
, "invalid EEM CRC\n");
473 skb2
= skb_clone(skb
, GFP_ATOMIC
);
474 if (unlikely(!skb2
)) {
475 DBG(cdev
, "unable to unframe EEM packet\n");
478 skb_trim(skb2
, len
- ETH_FCS_LEN
);
480 skb3
= skb_copy_expand(skb2
,
484 if (unlikely(!skb3
)) {
485 DBG(cdev
, "unable to realign EEM packet\n");
486 dev_kfree_skb_any(skb2
);
489 dev_kfree_skb_any(skb2
);
490 skb_queue_tail(list
, skb3
);
497 dev_kfree_skb_any(skb
);
502 * eem_bind_config - add CDC Ethernet (EEM) network link to a configuration
503 * @c: the configuration to support the network link
504 * Context: single threaded during gadget setup
506 * Returns zero on success, else negative errno.
508 * Caller must have called @gether_setup(). Caller is also responsible
509 * for calling @gether_cleanup() before module unload.
511 int __init
eem_bind_config(struct usb_configuration
*c
)
516 /* maybe allocate device-global string IDs */
517 if (eem_string_defs
[0].id
== 0) {
519 /* control interface label */
520 status
= usb_string_id(c
->cdev
);
523 eem_string_defs
[0].id
= status
;
524 eem_intf
.iInterface
= status
;
527 /* allocate and initialize one new instance */
528 eem
= kzalloc(sizeof *eem
, GFP_KERNEL
);
532 eem
->port
.cdc_filter
= DEFAULT_FILTER
;
534 eem
->port
.func
.name
= "cdc_eem";
535 eem
->port
.func
.strings
= eem_strings
;
536 /* descriptors are per-instance copies */
537 eem
->port
.func
.bind
= eem_bind
;
538 eem
->port
.func
.unbind
= eem_unbind
;
539 eem
->port
.func
.set_alt
= eem_set_alt
;
540 eem
->port
.func
.setup
= eem_setup
;
541 eem
->port
.func
.disable
= eem_disable
;
542 eem
->port
.wrap
= eem_wrap
;
543 eem
->port
.unwrap
= eem_unwrap
;
544 eem
->port
.header_len
= EEM_HLEN
;
546 status
= usb_add_function(c
, &eem
->port
.func
);