2 * f_rndis.c -- RNDIS link function driver
4 * Copyright (C) 2003-2005,2008 David Brownell
5 * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
6 * Copyright (C) 2008 Nokia Corporation
7 * Copyright (C) 2009 Samsung Electronics
8 * Author: Michal Nazarewicz (mina86@mina86.com)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
16 /* #define VERBOSE_DEBUG */
18 #include <linux/slab.h>
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/device.h>
22 #include <linux/etherdevice.h>
24 #include <linux/atomic.h>
27 #include "u_ether_configfs.h"
33 * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
34 * been promoted instead of the standard CDC Ethernet. The published RNDIS
35 * spec is ambiguous, incomplete, and needlessly complex. Variants such as
36 * ActiveSync have even worse status in terms of specification.
38 * In short: it's a protocol controlled by (and for) Microsoft, not for an
39 * Open ecosystem or markets. Linux supports it *only* because Microsoft
40 * doesn't support the CDC Ethernet standard.
42 * The RNDIS data transfer model is complex, with multiple Ethernet packets
43 * per USB message, and out of band data. The control model is built around
44 * what's essentially an "RNDIS RPC" protocol. It's all wrapped in a CDC ACM
45 * (modem, not Ethernet) veneer, with those ACM descriptors being entirely
46 * useless (they're ignored). RNDIS expects to be the only function in its
47 * configuration, so it's no real help if you need composite devices; and
48 * it expects to be the first configuration too.
50 * There is a single technical advantage of RNDIS over CDC Ethernet, if you
51 * discount the fluff that its RPC can be made to deliver: it doesn't need
52 * a NOP altsetting for the data interface. That lets it work on some of the
53 * "so smart it's stupid" hardware which takes over configuration changes
54 * from the software, and adds restrictions like "no altsettings".
56 * Unfortunately MSFT's RNDIS drivers are buggy. They hang or oops, and
57 * have all sorts of contrary-to-specification oddities that can prevent
58 * them from working sanely. Since bugfixes (or accurate specs, letting
59 * Linux work around those bugs) are unlikely to ever come from MSFT, you
60 * may want to avoid using RNDIS on purely operational grounds.
62 * Omissions from the RNDIS 1.0 specification include:
64 * - Power management ... references data that's scattered around lots
65 * of other documentation, which is incorrect/incomplete there too.
67 * - There are various undocumented protocol requirements, like the need
68 * to send garbage in some control-OUT messages.
70 * - MS-Windows drivers sometimes emit undocumented requests.
78 const char *manufacturer
;
81 struct usb_ep
*notify
;
82 struct usb_request
*notify_req
;
83 atomic_t notify_count
;
86 static inline struct f_rndis
*func_to_rndis(struct usb_function
*f
)
88 return container_of(f
, struct f_rndis
, port
.func
);
91 /* peak (theoretical) bulk transfer rate in bits-per-second */
92 static unsigned int bitrate(struct usb_gadget
*g
)
94 if (gadget_is_superspeed(g
) && g
->speed
== USB_SPEED_SUPER
)
95 return 13 * 1024 * 8 * 1000 * 8;
96 else if (gadget_is_dualspeed(g
) && g
->speed
== USB_SPEED_HIGH
)
97 return 13 * 512 * 8 * 1000 * 8;
99 return 19 * 64 * 1 * 1000 * 8;
102 /*-------------------------------------------------------------------------*/
107 #define RNDIS_STATUS_INTERVAL_MS 32
108 #define STATUS_BYTECOUNT 8 /* 8 bytes data */
111 /* interface descriptor: */
113 static struct usb_interface_descriptor rndis_control_intf
= {
114 .bLength
= sizeof rndis_control_intf
,
115 .bDescriptorType
= USB_DT_INTERFACE
,
117 /* .bInterfaceNumber = DYNAMIC */
118 /* status endpoint is optional; this could be patched later */
120 .bInterfaceClass
= USB_CLASS_COMM
,
121 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
122 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_VENDOR
,
123 /* .iInterface = DYNAMIC */
126 static struct usb_cdc_header_desc header_desc
= {
127 .bLength
= sizeof header_desc
,
128 .bDescriptorType
= USB_DT_CS_INTERFACE
,
129 .bDescriptorSubType
= USB_CDC_HEADER_TYPE
,
131 .bcdCDC
= cpu_to_le16(0x0110),
134 static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor
= {
135 .bLength
= sizeof call_mgmt_descriptor
,
136 .bDescriptorType
= USB_DT_CS_INTERFACE
,
137 .bDescriptorSubType
= USB_CDC_CALL_MANAGEMENT_TYPE
,
139 .bmCapabilities
= 0x00,
140 .bDataInterface
= 0x01,
143 static struct usb_cdc_acm_descriptor rndis_acm_descriptor
= {
144 .bLength
= sizeof rndis_acm_descriptor
,
145 .bDescriptorType
= USB_DT_CS_INTERFACE
,
146 .bDescriptorSubType
= USB_CDC_ACM_TYPE
,
148 .bmCapabilities
= 0x00,
151 static struct usb_cdc_union_desc rndis_union_desc
= {
152 .bLength
= sizeof(rndis_union_desc
),
153 .bDescriptorType
= USB_DT_CS_INTERFACE
,
154 .bDescriptorSubType
= USB_CDC_UNION_TYPE
,
155 /* .bMasterInterface0 = DYNAMIC */
156 /* .bSlaveInterface0 = DYNAMIC */
159 /* the data interface has two bulk endpoints */
161 static struct usb_interface_descriptor rndis_data_intf
= {
162 .bLength
= sizeof rndis_data_intf
,
163 .bDescriptorType
= USB_DT_INTERFACE
,
165 /* .bInterfaceNumber = DYNAMIC */
167 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
168 .bInterfaceSubClass
= 0,
169 .bInterfaceProtocol
= 0,
170 /* .iInterface = DYNAMIC */
174 static struct usb_interface_assoc_descriptor
175 rndis_iad_descriptor
= {
176 .bLength
= sizeof rndis_iad_descriptor
,
177 .bDescriptorType
= USB_DT_INTERFACE_ASSOCIATION
,
179 .bFirstInterface
= 0, /* XXX, hardcoded */
180 .bInterfaceCount
= 2, // control + data
181 .bFunctionClass
= USB_CLASS_COMM
,
182 .bFunctionSubClass
= USB_CDC_SUBCLASS_ETHERNET
,
183 .bFunctionProtocol
= USB_CDC_PROTO_NONE
,
184 /* .iFunction = DYNAMIC */
187 /* full speed support: */
189 static struct usb_endpoint_descriptor fs_notify_desc
= {
190 .bLength
= USB_DT_ENDPOINT_SIZE
,
191 .bDescriptorType
= USB_DT_ENDPOINT
,
193 .bEndpointAddress
= USB_DIR_IN
,
194 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
195 .wMaxPacketSize
= cpu_to_le16(STATUS_BYTECOUNT
),
196 .bInterval
= RNDIS_STATUS_INTERVAL_MS
,
199 static struct usb_endpoint_descriptor fs_in_desc
= {
200 .bLength
= USB_DT_ENDPOINT_SIZE
,
201 .bDescriptorType
= USB_DT_ENDPOINT
,
203 .bEndpointAddress
= USB_DIR_IN
,
204 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
207 static struct usb_endpoint_descriptor fs_out_desc
= {
208 .bLength
= USB_DT_ENDPOINT_SIZE
,
209 .bDescriptorType
= USB_DT_ENDPOINT
,
211 .bEndpointAddress
= USB_DIR_OUT
,
212 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
215 static struct usb_descriptor_header
*eth_fs_function
[] = {
216 (struct usb_descriptor_header
*) &rndis_iad_descriptor
,
218 /* control interface matches ACM, not Ethernet */
219 (struct usb_descriptor_header
*) &rndis_control_intf
,
220 (struct usb_descriptor_header
*) &header_desc
,
221 (struct usb_descriptor_header
*) &call_mgmt_descriptor
,
222 (struct usb_descriptor_header
*) &rndis_acm_descriptor
,
223 (struct usb_descriptor_header
*) &rndis_union_desc
,
224 (struct usb_descriptor_header
*) &fs_notify_desc
,
226 /* data interface has no altsetting */
227 (struct usb_descriptor_header
*) &rndis_data_intf
,
228 (struct usb_descriptor_header
*) &fs_in_desc
,
229 (struct usb_descriptor_header
*) &fs_out_desc
,
233 /* high speed support: */
235 static struct usb_endpoint_descriptor hs_notify_desc
= {
236 .bLength
= USB_DT_ENDPOINT_SIZE
,
237 .bDescriptorType
= USB_DT_ENDPOINT
,
239 .bEndpointAddress
= USB_DIR_IN
,
240 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
241 .wMaxPacketSize
= cpu_to_le16(STATUS_BYTECOUNT
),
242 .bInterval
= USB_MS_TO_HS_INTERVAL(RNDIS_STATUS_INTERVAL_MS
)
245 static struct usb_endpoint_descriptor hs_in_desc
= {
246 .bLength
= USB_DT_ENDPOINT_SIZE
,
247 .bDescriptorType
= USB_DT_ENDPOINT
,
249 .bEndpointAddress
= USB_DIR_IN
,
250 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
251 .wMaxPacketSize
= cpu_to_le16(512),
254 static struct usb_endpoint_descriptor hs_out_desc
= {
255 .bLength
= USB_DT_ENDPOINT_SIZE
,
256 .bDescriptorType
= USB_DT_ENDPOINT
,
258 .bEndpointAddress
= USB_DIR_OUT
,
259 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
260 .wMaxPacketSize
= cpu_to_le16(512),
263 static struct usb_descriptor_header
*eth_hs_function
[] = {
264 (struct usb_descriptor_header
*) &rndis_iad_descriptor
,
266 /* control interface matches ACM, not Ethernet */
267 (struct usb_descriptor_header
*) &rndis_control_intf
,
268 (struct usb_descriptor_header
*) &header_desc
,
269 (struct usb_descriptor_header
*) &call_mgmt_descriptor
,
270 (struct usb_descriptor_header
*) &rndis_acm_descriptor
,
271 (struct usb_descriptor_header
*) &rndis_union_desc
,
272 (struct usb_descriptor_header
*) &hs_notify_desc
,
274 /* data interface has no altsetting */
275 (struct usb_descriptor_header
*) &rndis_data_intf
,
276 (struct usb_descriptor_header
*) &hs_in_desc
,
277 (struct usb_descriptor_header
*) &hs_out_desc
,
281 /* super speed support: */
283 static struct usb_endpoint_descriptor ss_notify_desc
= {
284 .bLength
= USB_DT_ENDPOINT_SIZE
,
285 .bDescriptorType
= USB_DT_ENDPOINT
,
287 .bEndpointAddress
= USB_DIR_IN
,
288 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
289 .wMaxPacketSize
= cpu_to_le16(STATUS_BYTECOUNT
),
290 .bInterval
= USB_MS_TO_HS_INTERVAL(RNDIS_STATUS_INTERVAL_MS
)
293 static struct usb_ss_ep_comp_descriptor ss_intr_comp_desc
= {
294 .bLength
= sizeof ss_intr_comp_desc
,
295 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
297 /* the following 3 values can be tweaked if necessary */
298 /* .bMaxBurst = 0, */
299 /* .bmAttributes = 0, */
300 .wBytesPerInterval
= cpu_to_le16(STATUS_BYTECOUNT
),
303 static struct usb_endpoint_descriptor ss_in_desc
= {
304 .bLength
= USB_DT_ENDPOINT_SIZE
,
305 .bDescriptorType
= USB_DT_ENDPOINT
,
307 .bEndpointAddress
= USB_DIR_IN
,
308 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
309 .wMaxPacketSize
= cpu_to_le16(1024),
312 static struct usb_endpoint_descriptor ss_out_desc
= {
313 .bLength
= USB_DT_ENDPOINT_SIZE
,
314 .bDescriptorType
= USB_DT_ENDPOINT
,
316 .bEndpointAddress
= USB_DIR_OUT
,
317 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
318 .wMaxPacketSize
= cpu_to_le16(1024),
321 static struct usb_ss_ep_comp_descriptor ss_bulk_comp_desc
= {
322 .bLength
= sizeof ss_bulk_comp_desc
,
323 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
325 /* the following 2 values can be tweaked if necessary */
326 /* .bMaxBurst = 0, */
327 /* .bmAttributes = 0, */
330 static struct usb_descriptor_header
*eth_ss_function
[] = {
331 (struct usb_descriptor_header
*) &rndis_iad_descriptor
,
333 /* control interface matches ACM, not Ethernet */
334 (struct usb_descriptor_header
*) &rndis_control_intf
,
335 (struct usb_descriptor_header
*) &header_desc
,
336 (struct usb_descriptor_header
*) &call_mgmt_descriptor
,
337 (struct usb_descriptor_header
*) &rndis_acm_descriptor
,
338 (struct usb_descriptor_header
*) &rndis_union_desc
,
339 (struct usb_descriptor_header
*) &ss_notify_desc
,
340 (struct usb_descriptor_header
*) &ss_intr_comp_desc
,
342 /* data interface has no altsetting */
343 (struct usb_descriptor_header
*) &rndis_data_intf
,
344 (struct usb_descriptor_header
*) &ss_in_desc
,
345 (struct usb_descriptor_header
*) &ss_bulk_comp_desc
,
346 (struct usb_descriptor_header
*) &ss_out_desc
,
347 (struct usb_descriptor_header
*) &ss_bulk_comp_desc
,
351 /* string descriptors: */
353 static struct usb_string rndis_string_defs
[] = {
354 [0].s
= "RNDIS Communications Control",
355 [1].s
= "RNDIS Ethernet Data",
357 { } /* end of list */
360 static struct usb_gadget_strings rndis_string_table
= {
361 .language
= 0x0409, /* en-us */
362 .strings
= rndis_string_defs
,
365 static struct usb_gadget_strings
*rndis_strings
[] = {
370 /*-------------------------------------------------------------------------*/
372 static struct sk_buff
*rndis_add_header(struct gether
*port
,
375 struct sk_buff
*skb2
;
377 skb2
= skb_realloc_headroom(skb
, sizeof(struct rndis_packet_msg_type
));
385 static void rndis_response_available(void *_rndis
)
387 struct f_rndis
*rndis
= _rndis
;
388 struct usb_request
*req
= rndis
->notify_req
;
389 struct usb_composite_dev
*cdev
= rndis
->port
.func
.config
->cdev
;
390 __le32
*data
= req
->buf
;
393 if (atomic_inc_return(&rndis
->notify_count
) != 1)
396 /* Send RNDIS RESPONSE_AVAILABLE notification; a
397 * USB_CDC_NOTIFY_RESPONSE_AVAILABLE "should" work too
399 * This is the only notification defined by RNDIS.
401 data
[0] = cpu_to_le32(1);
402 data
[1] = cpu_to_le32(0);
404 status
= usb_ep_queue(rndis
->notify
, req
, GFP_ATOMIC
);
406 atomic_dec(&rndis
->notify_count
);
407 DBG(cdev
, "notify/0 --> %d\n", status
);
411 static void rndis_response_complete(struct usb_ep
*ep
, struct usb_request
*req
)
413 struct f_rndis
*rndis
= req
->context
;
414 struct usb_composite_dev
*cdev
= rndis
->port
.func
.config
->cdev
;
415 int status
= req
->status
;
418 * - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control)
419 * - RNDIS_RESPONSE_AVAILABLE (status/irq)
424 /* connection gone */
425 atomic_set(&rndis
->notify_count
, 0);
428 DBG(cdev
, "RNDIS %s response error %d, %d/%d\n",
430 req
->actual
, req
->length
);
433 if (ep
!= rndis
->notify
)
436 /* handle multiple pending RNDIS_RESPONSE_AVAILABLE
437 * notifications by resending until we're done
439 if (atomic_dec_and_test(&rndis
->notify_count
))
441 status
= usb_ep_queue(rndis
->notify
, req
, GFP_ATOMIC
);
443 atomic_dec(&rndis
->notify_count
);
444 DBG(cdev
, "notify/1 --> %d\n", status
);
450 static void rndis_command_complete(struct usb_ep
*ep
, struct usb_request
*req
)
452 struct f_rndis
*rndis
= req
->context
;
455 /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
456 // spin_lock(&dev->lock);
457 status
= rndis_msg_parser(rndis
->config
, (u8
*) req
->buf
);
459 pr_err("RNDIS command error %d, %d/%d\n",
460 status
, req
->actual
, req
->length
);
461 // spin_unlock(&dev->lock);
465 rndis_setup(struct usb_function
*f
, const struct usb_ctrlrequest
*ctrl
)
467 struct f_rndis
*rndis
= func_to_rndis(f
);
468 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
469 struct usb_request
*req
= cdev
->req
;
470 int value
= -EOPNOTSUPP
;
471 u16 w_index
= le16_to_cpu(ctrl
->wIndex
);
472 u16 w_value
= le16_to_cpu(ctrl
->wValue
);
473 u16 w_length
= le16_to_cpu(ctrl
->wLength
);
475 /* composite driver infrastructure handles everything except
476 * CDC class messages; interface activation uses set_alt().
478 switch ((ctrl
->bRequestType
<< 8) | ctrl
->bRequest
) {
480 /* RNDIS uses the CDC command encapsulation mechanism to implement
481 * an RPC scheme, with much getting/setting of attributes by OID.
483 case ((USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
) << 8)
484 | USB_CDC_SEND_ENCAPSULATED_COMMAND
:
485 if (w_value
|| w_index
!= rndis
->ctrl_id
)
487 /* read the request; process it later */
489 req
->complete
= rndis_command_complete
;
490 req
->context
= rndis
;
491 /* later, rndis_response_available() sends a notification */
494 case ((USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
) << 8)
495 | USB_CDC_GET_ENCAPSULATED_RESPONSE
:
496 if (w_value
|| w_index
!= rndis
->ctrl_id
)
502 /* return the result */
503 buf
= rndis_get_next_response(rndis
->config
, &n
);
505 memcpy(req
->buf
, buf
, n
);
506 req
->complete
= rndis_response_complete
;
507 req
->context
= rndis
;
508 rndis_free_response(rndis
->config
, buf
);
511 /* else stalls ... spec says to avoid that */
517 VDBG(cdev
, "invalid control req%02x.%02x v%04x i%04x l%d\n",
518 ctrl
->bRequestType
, ctrl
->bRequest
,
519 w_value
, w_index
, w_length
);
522 /* respond with data transfer or status phase? */
524 DBG(cdev
, "rndis req%02x.%02x v%04x i%04x l%d\n",
525 ctrl
->bRequestType
, ctrl
->bRequest
,
526 w_value
, w_index
, w_length
);
527 req
->zero
= (value
< w_length
);
529 value
= usb_ep_queue(cdev
->gadget
->ep0
, req
, GFP_ATOMIC
);
531 ERROR(cdev
, "rndis response on err %d\n", value
);
534 /* device either stalls (value < 0) or reports success */
539 static int rndis_set_alt(struct usb_function
*f
, unsigned intf
, unsigned alt
)
541 struct f_rndis
*rndis
= func_to_rndis(f
);
542 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
544 /* we know alt == 0 */
546 if (intf
== rndis
->ctrl_id
) {
547 if (rndis
->notify
->driver_data
) {
548 VDBG(cdev
, "reset rndis control %d\n", intf
);
549 usb_ep_disable(rndis
->notify
);
551 if (!rndis
->notify
->desc
) {
552 VDBG(cdev
, "init rndis ctrl %d\n", intf
);
553 if (config_ep_by_speed(cdev
->gadget
, f
, rndis
->notify
))
556 usb_ep_enable(rndis
->notify
);
557 rndis
->notify
->driver_data
= rndis
;
559 } else if (intf
== rndis
->data_id
) {
560 struct net_device
*net
;
562 if (rndis
->port
.in_ep
->driver_data
) {
563 DBG(cdev
, "reset rndis\n");
564 gether_disconnect(&rndis
->port
);
567 if (!rndis
->port
.in_ep
->desc
|| !rndis
->port
.out_ep
->desc
) {
568 DBG(cdev
, "init rndis\n");
569 if (config_ep_by_speed(cdev
->gadget
, f
,
570 rndis
->port
.in_ep
) ||
571 config_ep_by_speed(cdev
->gadget
, f
,
572 rndis
->port
.out_ep
)) {
573 rndis
->port
.in_ep
->desc
= NULL
;
574 rndis
->port
.out_ep
->desc
= NULL
;
579 /* Avoid ZLPs; they can be troublesome. */
580 rndis
->port
.is_zlp_ok
= false;
582 /* RNDIS should be in the "RNDIS uninitialized" state,
583 * either never activated or after rndis_uninit().
585 * We don't want data to flow here until a nonzero packet
586 * filter is set, at which point it enters "RNDIS data
587 * initialized" state ... but we do want the endpoints
588 * to be activated. It's a strange little state.
590 * REVISIT the RNDIS gadget code has done this wrong for a
591 * very long time. We need another call to the link layer
592 * code -- gether_updown(...bool) maybe -- to do it right.
594 rndis
->port
.cdc_filter
= 0;
596 DBG(cdev
, "RNDIS RX/TX early activation ... \n");
597 net
= gether_connect(&rndis
->port
);
601 rndis_set_param_dev(rndis
->config
, net
,
602 &rndis
->port
.cdc_filter
);
611 static void rndis_disable(struct usb_function
*f
)
613 struct f_rndis
*rndis
= func_to_rndis(f
);
614 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
616 if (!rndis
->notify
->driver_data
)
619 DBG(cdev
, "rndis deactivated\n");
621 rndis_uninit(rndis
->config
);
622 gether_disconnect(&rndis
->port
);
624 usb_ep_disable(rndis
->notify
);
625 rndis
->notify
->driver_data
= NULL
;
628 /*-------------------------------------------------------------------------*/
631 * This isn't quite the same mechanism as CDC Ethernet, since the
632 * notification scheme passes less data, but the same set of link
633 * states must be tested. A key difference is that altsettings are
634 * not used to tell whether the link should send packets or not.
637 static void rndis_open(struct gether
*geth
)
639 struct f_rndis
*rndis
= func_to_rndis(&geth
->func
);
640 struct usb_composite_dev
*cdev
= geth
->func
.config
->cdev
;
642 DBG(cdev
, "%s\n", __func__
);
644 rndis_set_param_medium(rndis
->config
, RNDIS_MEDIUM_802_3
,
645 bitrate(cdev
->gadget
) / 100);
646 rndis_signal_connect(rndis
->config
);
649 static void rndis_close(struct gether
*geth
)
651 struct f_rndis
*rndis
= func_to_rndis(&geth
->func
);
653 DBG(geth
->func
.config
->cdev
, "%s\n", __func__
);
655 rndis_set_param_medium(rndis
->config
, RNDIS_MEDIUM_802_3
, 0);
656 rndis_signal_disconnect(rndis
->config
);
659 /*-------------------------------------------------------------------------*/
661 /* Some controllers can't support RNDIS ... */
662 static inline bool can_support_rndis(struct usb_configuration
*c
)
664 /* everything else is *presumably* fine */
668 /* ethernet function driver setup/binding */
671 rndis_bind(struct usb_configuration
*c
, struct usb_function
*f
)
673 struct usb_composite_dev
*cdev
= c
->cdev
;
674 struct f_rndis
*rndis
= func_to_rndis(f
);
675 struct usb_string
*us
;
679 struct f_rndis_opts
*rndis_opts
;
681 if (!can_support_rndis(c
))
684 rndis_opts
= container_of(f
->fi
, struct f_rndis_opts
, func_inst
);
686 if (cdev
->use_os_string
) {
687 f
->os_desc_table
= kzalloc(sizeof(*f
->os_desc_table
),
689 if (!f
->os_desc_table
)
690 return PTR_ERR(f
->os_desc_table
);
692 f
->os_desc_table
[0].os_desc
= &rndis_opts
->rndis_os_desc
;
696 * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
697 * configurations are bound in sequence with list_for_each_entry,
698 * in each configuration its functions are bound in sequence
699 * with list_for_each_entry, so we assume no race condition
700 * with regard to rndis_opts->bound access
702 if (!rndis_opts
->bound
) {
703 gether_set_gadget(rndis_opts
->net
, cdev
->gadget
);
704 status
= gether_register_netdev(rndis_opts
->net
);
707 rndis_opts
->bound
= true;
710 us
= usb_gstrings_attach(cdev
, rndis_strings
,
711 ARRAY_SIZE(rndis_string_defs
));
713 status
= PTR_ERR(us
);
716 rndis_control_intf
.iInterface
= us
[0].id
;
717 rndis_data_intf
.iInterface
= us
[1].id
;
718 rndis_iad_descriptor
.iFunction
= us
[2].id
;
720 /* allocate instance-specific interface IDs */
721 status
= usb_interface_id(c
, f
);
724 rndis
->ctrl_id
= status
;
725 rndis_iad_descriptor
.bFirstInterface
= status
;
727 rndis_control_intf
.bInterfaceNumber
= status
;
728 rndis_union_desc
.bMasterInterface0
= status
;
730 status
= usb_interface_id(c
, f
);
733 rndis
->data_id
= status
;
735 rndis_data_intf
.bInterfaceNumber
= status
;
736 rndis_union_desc
.bSlaveInterface0
= status
;
740 /* allocate instance-specific endpoints */
741 ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_in_desc
);
744 rndis
->port
.in_ep
= ep
;
745 ep
->driver_data
= cdev
; /* claim */
747 ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_out_desc
);
750 rndis
->port
.out_ep
= ep
;
751 ep
->driver_data
= cdev
; /* claim */
753 /* NOTE: a status/notification endpoint is, strictly speaking,
754 * optional. We don't treat it that way though! It's simpler,
755 * and some newer profiles don't treat it as optional.
757 ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_notify_desc
);
761 ep
->driver_data
= cdev
; /* claim */
765 /* allocate notification request and buffer */
766 rndis
->notify_req
= usb_ep_alloc_request(ep
, GFP_KERNEL
);
767 if (!rndis
->notify_req
)
769 rndis
->notify_req
->buf
= kmalloc(STATUS_BYTECOUNT
, GFP_KERNEL
);
770 if (!rndis
->notify_req
->buf
)
772 rndis
->notify_req
->length
= STATUS_BYTECOUNT
;
773 rndis
->notify_req
->context
= rndis
;
774 rndis
->notify_req
->complete
= rndis_response_complete
;
776 /* support all relevant hardware speeds... we expect that when
777 * hardware is dual speed, all bulk-capable endpoints work at
780 hs_in_desc
.bEndpointAddress
= fs_in_desc
.bEndpointAddress
;
781 hs_out_desc
.bEndpointAddress
= fs_out_desc
.bEndpointAddress
;
782 hs_notify_desc
.bEndpointAddress
= fs_notify_desc
.bEndpointAddress
;
784 ss_in_desc
.bEndpointAddress
= fs_in_desc
.bEndpointAddress
;
785 ss_out_desc
.bEndpointAddress
= fs_out_desc
.bEndpointAddress
;
786 ss_notify_desc
.bEndpointAddress
= fs_notify_desc
.bEndpointAddress
;
788 status
= usb_assign_descriptors(f
, eth_fs_function
, eth_hs_function
,
793 rndis
->port
.open
= rndis_open
;
794 rndis
->port
.close
= rndis_close
;
796 rndis_set_param_medium(rndis
->config
, RNDIS_MEDIUM_802_3
, 0);
797 rndis_set_host_mac(rndis
->config
, rndis
->ethaddr
);
799 if (rndis
->manufacturer
&& rndis
->vendorID
&&
800 rndis_set_param_vendor(rndis
->config
, rndis
->vendorID
,
801 rndis
->manufacturer
))
804 /* NOTE: all that is done without knowing or caring about
805 * the network link ... which is unavailable to this code
806 * until we're activated via set_alt().
809 DBG(cdev
, "RNDIS: %s speed IN/%s OUT/%s NOTIFY/%s\n",
810 gadget_is_superspeed(c
->cdev
->gadget
) ? "super" :
811 gadget_is_dualspeed(c
->cdev
->gadget
) ? "dual" : "full",
812 rndis
->port
.in_ep
->name
, rndis
->port
.out_ep
->name
,
813 rndis
->notify
->name
);
817 kfree(f
->os_desc_table
);
819 usb_free_all_descriptors(f
);
821 if (rndis
->notify_req
) {
822 kfree(rndis
->notify_req
->buf
);
823 usb_ep_free_request(rndis
->notify
, rndis
->notify_req
);
826 /* we might as well release our claims on endpoints */
828 rndis
->notify
->driver_data
= NULL
;
829 if (rndis
->port
.out_ep
)
830 rndis
->port
.out_ep
->driver_data
= NULL
;
831 if (rndis
->port
.in_ep
)
832 rndis
->port
.in_ep
->driver_data
= NULL
;
834 ERROR(cdev
, "%s: can't bind, err %d\n", f
->name
, status
);
839 void rndis_borrow_net(struct usb_function_instance
*f
, struct net_device
*net
)
841 struct f_rndis_opts
*opts
;
843 opts
= container_of(f
, struct f_rndis_opts
, func_inst
);
845 gether_cleanup(netdev_priv(opts
->net
));
847 free_netdev(opts
->net
);
848 opts
->borrowed_net
= opts
->bound
= true;
851 EXPORT_SYMBOL_GPL(rndis_borrow_net
);
853 static inline struct f_rndis_opts
*to_f_rndis_opts(struct config_item
*item
)
855 return container_of(to_config_group(item
), struct f_rndis_opts
,
859 /* f_rndis_item_ops */
860 USB_ETHERNET_CONFIGFS_ITEM(rndis
);
862 /* f_rndis_opts_dev_addr */
863 USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(rndis
);
865 /* f_rndis_opts_host_addr */
866 USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(rndis
);
868 /* f_rndis_opts_qmult */
869 USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(rndis
);
871 /* f_rndis_opts_ifname */
872 USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(rndis
);
874 static struct configfs_attribute
*rndis_attrs
[] = {
875 &f_rndis_opts_dev_addr
.attr
,
876 &f_rndis_opts_host_addr
.attr
,
877 &f_rndis_opts_qmult
.attr
,
878 &f_rndis_opts_ifname
.attr
,
882 static struct config_item_type rndis_func_type
= {
883 .ct_item_ops
= &rndis_item_ops
,
884 .ct_attrs
= rndis_attrs
,
885 .ct_owner
= THIS_MODULE
,
888 static void rndis_free_inst(struct usb_function_instance
*f
)
890 struct f_rndis_opts
*opts
;
892 opts
= container_of(f
, struct f_rndis_opts
, func_inst
);
893 if (!opts
->borrowed_net
) {
895 gether_cleanup(netdev_priv(opts
->net
));
897 free_netdev(opts
->net
);
900 kfree(opts
->rndis_os_desc
.group
.default_groups
); /* single VLA chunk */
904 static struct usb_function_instance
*rndis_alloc_inst(void)
906 struct f_rndis_opts
*opts
;
907 struct usb_os_desc
*descs
[1];
909 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
911 return ERR_PTR(-ENOMEM
);
912 opts
->rndis_os_desc
.ext_compat_id
= opts
->rndis_ext_compat_id
;
914 mutex_init(&opts
->lock
);
915 opts
->func_inst
.free_func_inst
= rndis_free_inst
;
916 opts
->net
= gether_setup_default();
917 if (IS_ERR(opts
->net
)) {
918 struct net_device
*net
= opts
->net
;
920 return ERR_CAST(net
);
922 INIT_LIST_HEAD(&opts
->rndis_os_desc
.ext_prop
);
924 descs
[0] = &opts
->rndis_os_desc
;
925 usb_os_desc_prepare_interf_dir(&opts
->func_inst
.group
, 1, descs
,
927 config_group_init_type_name(&opts
->func_inst
.group
, "",
930 return &opts
->func_inst
;
933 static void rndis_free(struct usb_function
*f
)
935 struct f_rndis
*rndis
;
936 struct f_rndis_opts
*opts
;
938 rndis
= func_to_rndis(f
);
939 rndis_deregister(rndis
->config
);
940 opts
= container_of(f
->fi
, struct f_rndis_opts
, func_inst
);
942 mutex_lock(&opts
->lock
);
944 mutex_unlock(&opts
->lock
);
947 static void rndis_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
949 struct f_rndis
*rndis
= func_to_rndis(f
);
951 kfree(f
->os_desc_table
);
953 usb_free_all_descriptors(f
);
955 kfree(rndis
->notify_req
->buf
);
956 usb_ep_free_request(rndis
->notify
, rndis
->notify_req
);
959 static struct usb_function
*rndis_alloc(struct usb_function_instance
*fi
)
961 struct f_rndis
*rndis
;
962 struct f_rndis_opts
*opts
;
965 /* allocate and initialize one new instance */
966 rndis
= kzalloc(sizeof(*rndis
), GFP_KERNEL
);
968 return ERR_PTR(-ENOMEM
);
970 opts
= container_of(fi
, struct f_rndis_opts
, func_inst
);
971 mutex_lock(&opts
->lock
);
974 gether_get_host_addr_u8(opts
->net
, rndis
->ethaddr
);
975 rndis
->vendorID
= opts
->vendor_id
;
976 rndis
->manufacturer
= opts
->manufacturer
;
978 rndis
->port
.ioport
= netdev_priv(opts
->net
);
979 mutex_unlock(&opts
->lock
);
980 /* RNDIS activates when the host changes this filter */
981 rndis
->port
.cdc_filter
= 0;
983 /* RNDIS has special (and complex) framing */
984 rndis
->port
.header_len
= sizeof(struct rndis_packet_msg_type
);
985 rndis
->port
.wrap
= rndis_add_header
;
986 rndis
->port
.unwrap
= rndis_rm_hdr
;
988 rndis
->port
.func
.name
= "rndis";
989 /* descriptors are per-instance copies */
990 rndis
->port
.func
.bind
= rndis_bind
;
991 rndis
->port
.func
.unbind
= rndis_unbind
;
992 rndis
->port
.func
.set_alt
= rndis_set_alt
;
993 rndis
->port
.func
.setup
= rndis_setup
;
994 rndis
->port
.func
.disable
= rndis_disable
;
995 rndis
->port
.func
.free_func
= rndis_free
;
997 status
= rndis_register(rndis_response_available
, rndis
);
1000 return ERR_PTR(status
);
1002 rndis
->config
= status
;
1004 return &rndis
->port
.func
;
1007 DECLARE_USB_FUNCTION(rndis
, rndis_alloc_inst
, rndis_alloc
);
1009 static int __init
rndis_mod_init(void)
1017 return usb_function_register(&rndisusb_func
);
1019 module_init(rndis_mod_init
);
1021 static void __exit
rndis_mod_exit(void)
1023 usb_function_unregister(&rndisusb_func
);
1026 module_exit(rndis_mod_exit
);
1028 MODULE_LICENSE("GPL");
1029 MODULE_AUTHOR("David Brownell");