1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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>
23
24#include <linux/atomic.h>
25
26#include "u_ether.h"
27#include "u_ether_configfs.h"
28#include "u_rndis.h"
29#include "rndis.h"
30#include "configfs.h"
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73struct f_rndis {
74 struct gether port;
75 u8 ctrl_id, data_id;
76 u8 ethaddr[ETH_ALEN];
77 u32 vendorID;
78 const char *manufacturer;
79 struct rndis_params *params;
80
81 struct usb_ep *notify;
82 struct usb_request *notify_req;
83 atomic_t notify_count;
84};
85
86static inline struct f_rndis *func_to_rndis(struct usb_function *f)
87{
88 return container_of(f, struct f_rndis, port.func);
89}
90
91
92static unsigned int bitrate(struct usb_gadget *g)
93{
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;
98 else
99 return 19 * 64 * 1 * 1000 * 8;
100}
101
102
103
104
105
106
107#define RNDIS_STATUS_INTERVAL_MS 32
108#define STATUS_BYTECOUNT 8
109
110
111
112
113static struct usb_interface_descriptor rndis_control_intf = {
114 .bLength = sizeof rndis_control_intf,
115 .bDescriptorType = USB_DT_INTERFACE,
116
117
118
119 .bNumEndpoints = 1,
120 .bInterfaceClass = USB_CLASS_COMM,
121 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
122 .bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,
123
124};
125
126static struct usb_cdc_header_desc header_desc = {
127 .bLength = sizeof header_desc,
128 .bDescriptorType = USB_DT_CS_INTERFACE,
129 .bDescriptorSubType = USB_CDC_HEADER_TYPE,
130
131 .bcdCDC = cpu_to_le16(0x0110),
132};
133
134static 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,
138
139 .bmCapabilities = 0x00,
140 .bDataInterface = 0x01,
141};
142
143static 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,
147
148 .bmCapabilities = 0x00,
149};
150
151static 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
156
157};
158
159
160
161static struct usb_interface_descriptor rndis_data_intf = {
162 .bLength = sizeof rndis_data_intf,
163 .bDescriptorType = USB_DT_INTERFACE,
164
165
166 .bNumEndpoints = 2,
167 .bInterfaceClass = USB_CLASS_CDC_DATA,
168 .bInterfaceSubClass = 0,
169 .bInterfaceProtocol = 0,
170
171};
172
173
174static struct usb_interface_assoc_descriptor
175rndis_iad_descriptor = {
176 .bLength = sizeof rndis_iad_descriptor,
177 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
178
179 .bFirstInterface = 0,
180 .bInterfaceCount = 2,
181 .bFunctionClass = USB_CLASS_COMM,
182 .bFunctionSubClass = USB_CDC_SUBCLASS_ETHERNET,
183 .bFunctionProtocol = USB_CDC_PROTO_NONE,
184
185};
186
187
188
189static struct usb_endpoint_descriptor fs_notify_desc = {
190 .bLength = USB_DT_ENDPOINT_SIZE,
191 .bDescriptorType = USB_DT_ENDPOINT,
192
193 .bEndpointAddress = USB_DIR_IN,
194 .bmAttributes = USB_ENDPOINT_XFER_INT,
195 .wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
196 .bInterval = RNDIS_STATUS_INTERVAL_MS,
197};
198
199static struct usb_endpoint_descriptor fs_in_desc = {
200 .bLength = USB_DT_ENDPOINT_SIZE,
201 .bDescriptorType = USB_DT_ENDPOINT,
202
203 .bEndpointAddress = USB_DIR_IN,
204 .bmAttributes = USB_ENDPOINT_XFER_BULK,
205};
206
207static struct usb_endpoint_descriptor fs_out_desc = {
208 .bLength = USB_DT_ENDPOINT_SIZE,
209 .bDescriptorType = USB_DT_ENDPOINT,
210
211 .bEndpointAddress = USB_DIR_OUT,
212 .bmAttributes = USB_ENDPOINT_XFER_BULK,
213};
214
215static struct usb_descriptor_header *eth_fs_function[] = {
216 (struct usb_descriptor_header *) &rndis_iad_descriptor,
217
218
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,
225
226
227 (struct usb_descriptor_header *) &rndis_data_intf,
228 (struct usb_descriptor_header *) &fs_in_desc,
229 (struct usb_descriptor_header *) &fs_out_desc,
230 NULL,
231};
232
233
234
235static struct usb_endpoint_descriptor hs_notify_desc = {
236 .bLength = USB_DT_ENDPOINT_SIZE,
237 .bDescriptorType = USB_DT_ENDPOINT,
238
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)
243};
244
245static struct usb_endpoint_descriptor hs_in_desc = {
246 .bLength = USB_DT_ENDPOINT_SIZE,
247 .bDescriptorType = USB_DT_ENDPOINT,
248
249 .bEndpointAddress = USB_DIR_IN,
250 .bmAttributes = USB_ENDPOINT_XFER_BULK,
251 .wMaxPacketSize = cpu_to_le16(512),
252};
253
254static struct usb_endpoint_descriptor hs_out_desc = {
255 .bLength = USB_DT_ENDPOINT_SIZE,
256 .bDescriptorType = USB_DT_ENDPOINT,
257
258 .bEndpointAddress = USB_DIR_OUT,
259 .bmAttributes = USB_ENDPOINT_XFER_BULK,
260 .wMaxPacketSize = cpu_to_le16(512),
261};
262
263static struct usb_descriptor_header *eth_hs_function[] = {
264 (struct usb_descriptor_header *) &rndis_iad_descriptor,
265
266
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,
273
274
275 (struct usb_descriptor_header *) &rndis_data_intf,
276 (struct usb_descriptor_header *) &hs_in_desc,
277 (struct usb_descriptor_header *) &hs_out_desc,
278 NULL,
279};
280
281
282
283static struct usb_endpoint_descriptor ss_notify_desc = {
284 .bLength = USB_DT_ENDPOINT_SIZE,
285 .bDescriptorType = USB_DT_ENDPOINT,
286
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)
291};
292
293static struct usb_ss_ep_comp_descriptor ss_intr_comp_desc = {
294 .bLength = sizeof ss_intr_comp_desc,
295 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
296
297
298
299
300 .wBytesPerInterval = cpu_to_le16(STATUS_BYTECOUNT),
301};
302
303static struct usb_endpoint_descriptor ss_in_desc = {
304 .bLength = USB_DT_ENDPOINT_SIZE,
305 .bDescriptorType = USB_DT_ENDPOINT,
306
307 .bEndpointAddress = USB_DIR_IN,
308 .bmAttributes = USB_ENDPOINT_XFER_BULK,
309 .wMaxPacketSize = cpu_to_le16(1024),
310};
311
312static struct usb_endpoint_descriptor ss_out_desc = {
313 .bLength = USB_DT_ENDPOINT_SIZE,
314 .bDescriptorType = USB_DT_ENDPOINT,
315
316 .bEndpointAddress = USB_DIR_OUT,
317 .bmAttributes = USB_ENDPOINT_XFER_BULK,
318 .wMaxPacketSize = cpu_to_le16(1024),
319};
320
321static struct usb_ss_ep_comp_descriptor ss_bulk_comp_desc = {
322 .bLength = sizeof ss_bulk_comp_desc,
323 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
324
325
326
327
328};
329
330static struct usb_descriptor_header *eth_ss_function[] = {
331 (struct usb_descriptor_header *) &rndis_iad_descriptor,
332
333
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,
341
342
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,
348 NULL,
349};
350
351
352
353static struct usb_string rndis_string_defs[] = {
354 [0].s = "RNDIS Communications Control",
355 [1].s = "RNDIS Ethernet Data",
356 [2].s = "RNDIS",
357 { }
358};
359
360static struct usb_gadget_strings rndis_string_table = {
361 .language = 0x0409,
362 .strings = rndis_string_defs,
363};
364
365static struct usb_gadget_strings *rndis_strings[] = {
366 &rndis_string_table,
367 NULL,
368};
369
370
371
372static struct sk_buff *rndis_add_header(struct gether *port,
373 struct sk_buff *skb)
374{
375 struct sk_buff *skb2;
376
377 skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
378 rndis_add_hdr(skb2);
379
380 dev_kfree_skb(skb);
381 return skb2;
382}
383
384static void rndis_response_available(void *_rndis)
385{
386 struct f_rndis *rndis = _rndis;
387 struct usb_request *req = rndis->notify_req;
388 struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
389 __le32 *data = req->buf;
390 int status;
391
392 if (atomic_inc_return(&rndis->notify_count) != 1)
393 return;
394
395
396
397
398
399
400 data[0] = cpu_to_le32(1);
401 data[1] = cpu_to_le32(0);
402
403 status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
404 if (status) {
405 atomic_dec(&rndis->notify_count);
406 DBG(cdev, "notify/0 --> %d\n", status);
407 }
408}
409
410static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
411{
412 struct f_rndis *rndis = req->context;
413 struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
414 int status = req->status;
415
416
417
418
419
420 switch (status) {
421 case -ECONNRESET:
422 case -ESHUTDOWN:
423
424 atomic_set(&rndis->notify_count, 0);
425 break;
426 default:
427 DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
428 ep->name, status,
429 req->actual, req->length);
430
431 case 0:
432 if (ep != rndis->notify)
433 break;
434
435
436
437
438 if (atomic_dec_and_test(&rndis->notify_count))
439 break;
440 status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
441 if (status) {
442 atomic_dec(&rndis->notify_count);
443 DBG(cdev, "notify/1 --> %d\n", status);
444 }
445 break;
446 }
447}
448
449static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
450{
451 struct f_rndis *rndis = req->context;
452 int status;
453
454
455
456 status = rndis_msg_parser(rndis->params, (u8 *) req->buf);
457 if (status < 0)
458 pr_err("RNDIS command error %d, %d/%d\n",
459 status, req->actual, req->length);
460
461}
462
463static int
464rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
465{
466 struct f_rndis *rndis = func_to_rndis(f);
467 struct usb_composite_dev *cdev = f->config->cdev;
468 struct usb_request *req = cdev->req;
469 int value = -EOPNOTSUPP;
470 u16 w_index = le16_to_cpu(ctrl->wIndex);
471 u16 w_value = le16_to_cpu(ctrl->wValue);
472 u16 w_length = le16_to_cpu(ctrl->wLength);
473
474
475
476
477 switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
478
479
480
481
482 case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
483 | USB_CDC_SEND_ENCAPSULATED_COMMAND:
484 if (w_value || w_index != rndis->ctrl_id)
485 goto invalid;
486
487 value = w_length;
488 req->complete = rndis_command_complete;
489 req->context = rndis;
490
491 break;
492
493 case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
494 | USB_CDC_GET_ENCAPSULATED_RESPONSE:
495 if (w_value || w_index != rndis->ctrl_id)
496 goto invalid;
497 else {
498 u8 *buf;
499 u32 n;
500
501
502 buf = rndis_get_next_response(rndis->params, &n);
503 if (buf) {
504 memcpy(req->buf, buf, n);
505 req->complete = rndis_response_complete;
506 req->context = rndis;
507 rndis_free_response(rndis->params, buf);
508 value = n;
509 }
510
511 }
512 break;
513
514 default:
515invalid:
516 VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
517 ctrl->bRequestType, ctrl->bRequest,
518 w_value, w_index, w_length);
519 }
520
521
522 if (value >= 0) {
523 DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d\n",
524 ctrl->bRequestType, ctrl->bRequest,
525 w_value, w_index, w_length);
526 req->zero = (value < w_length);
527 req->length = value;
528 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
529 if (value < 0)
530 ERROR(cdev, "rndis response on err %d\n", value);
531 }
532
533
534 return value;
535}
536
537
538static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
539{
540 struct f_rndis *rndis = func_to_rndis(f);
541 struct usb_composite_dev *cdev = f->config->cdev;
542
543
544
545 if (intf == rndis->ctrl_id) {
546 VDBG(cdev, "reset rndis control %d\n", intf);
547 usb_ep_disable(rndis->notify);
548
549 if (!rndis->notify->desc) {
550 VDBG(cdev, "init rndis ctrl %d\n", intf);
551 if (config_ep_by_speed(cdev->gadget, f, rndis->notify))
552 goto fail;
553 }
554 usb_ep_enable(rndis->notify);
555
556 } else if (intf == rndis->data_id) {
557 struct net_device *net;
558
559 if (rndis->port.in_ep->enabled) {
560 DBG(cdev, "reset rndis\n");
561 gether_disconnect(&rndis->port);
562 }
563
564 if (!rndis->port.in_ep->desc || !rndis->port.out_ep->desc) {
565 DBG(cdev, "init rndis\n");
566 if (config_ep_by_speed(cdev->gadget, f,
567 rndis->port.in_ep) ||
568 config_ep_by_speed(cdev->gadget, f,
569 rndis->port.out_ep)) {
570 rndis->port.in_ep->desc = NULL;
571 rndis->port.out_ep->desc = NULL;
572 goto fail;
573 }
574 }
575
576
577 rndis->port.is_zlp_ok = false;
578
579
580
581
582
583
584
585
586
587
588
589
590
591 rndis->port.cdc_filter = 0;
592
593 DBG(cdev, "RNDIS RX/TX early activation ... \n");
594 net = gether_connect(&rndis->port);
595 if (IS_ERR(net))
596 return PTR_ERR(net);
597
598 rndis_set_param_dev(rndis->params, net,
599 &rndis->port.cdc_filter);
600 } else
601 goto fail;
602
603 return 0;
604fail:
605 return -EINVAL;
606}
607
608static void rndis_disable(struct usb_function *f)
609{
610 struct f_rndis *rndis = func_to_rndis(f);
611 struct usb_composite_dev *cdev = f->config->cdev;
612
613 if (!rndis->notify->enabled)
614 return;
615
616 DBG(cdev, "rndis deactivated\n");
617
618 rndis_uninit(rndis->params);
619 gether_disconnect(&rndis->port);
620
621 usb_ep_disable(rndis->notify);
622}
623
624
625
626
627
628
629
630
631
632
633static void rndis_open(struct gether *geth)
634{
635 struct f_rndis *rndis = func_to_rndis(&geth->func);
636 struct usb_composite_dev *cdev = geth->func.config->cdev;
637
638 DBG(cdev, "%s\n", __func__);
639
640 rndis_set_param_medium(rndis->params, RNDIS_MEDIUM_802_3,
641 bitrate(cdev->gadget) / 100);
642 rndis_signal_connect(rndis->params);
643}
644
645static void rndis_close(struct gether *geth)
646{
647 struct f_rndis *rndis = func_to_rndis(&geth->func);
648
649 DBG(geth->func.config->cdev, "%s\n", __func__);
650
651 rndis_set_param_medium(rndis->params, RNDIS_MEDIUM_802_3, 0);
652 rndis_signal_disconnect(rndis->params);
653}
654
655
656
657
658static inline bool can_support_rndis(struct usb_configuration *c)
659{
660
661 return true;
662}
663
664
665
666static int
667rndis_bind(struct usb_configuration *c, struct usb_function *f)
668{
669 struct usb_composite_dev *cdev = c->cdev;
670 struct f_rndis *rndis = func_to_rndis(f);
671 struct usb_string *us;
672 int status;
673 struct usb_ep *ep;
674
675 struct f_rndis_opts *rndis_opts;
676
677 if (!can_support_rndis(c))
678 return -EINVAL;
679
680 rndis_opts = container_of(f->fi, struct f_rndis_opts, func_inst);
681
682 if (cdev->use_os_string) {
683 f->os_desc_table = kzalloc(sizeof(*f->os_desc_table),
684 GFP_KERNEL);
685 if (!f->os_desc_table)
686 return -ENOMEM;
687 f->os_desc_n = 1;
688 f->os_desc_table[0].os_desc = &rndis_opts->rndis_os_desc;
689 }
690
691
692
693
694
695
696
697
698 if (!rndis_opts->bound) {
699 gether_set_gadget(rndis_opts->net, cdev->gadget);
700 status = gether_register_netdev(rndis_opts->net);
701 if (status)
702 goto fail;
703 rndis_opts->bound = true;
704 }
705
706 us = usb_gstrings_attach(cdev, rndis_strings,
707 ARRAY_SIZE(rndis_string_defs));
708 if (IS_ERR(us)) {
709 status = PTR_ERR(us);
710 goto fail;
711 }
712 rndis_control_intf.iInterface = us[0].id;
713 rndis_data_intf.iInterface = us[1].id;
714 rndis_iad_descriptor.iFunction = us[2].id;
715
716
717 status = usb_interface_id(c, f);
718 if (status < 0)
719 goto fail;
720 rndis->ctrl_id = status;
721 rndis_iad_descriptor.bFirstInterface = status;
722
723 rndis_control_intf.bInterfaceNumber = status;
724 rndis_union_desc.bMasterInterface0 = status;
725
726 if (cdev->use_os_string)
727 f->os_desc_table[0].if_id =
728 rndis_iad_descriptor.bFirstInterface;
729
730 status = usb_interface_id(c, f);
731 if (status < 0)
732 goto fail;
733 rndis->data_id = status;
734
735 rndis_data_intf.bInterfaceNumber = status;
736 rndis_union_desc.bSlaveInterface0 = status;
737
738 status = -ENODEV;
739
740
741 ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
742 if (!ep)
743 goto fail;
744 rndis->port.in_ep = ep;
745
746 ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
747 if (!ep)
748 goto fail;
749 rndis->port.out_ep = ep;
750
751
752
753
754
755 ep = usb_ep_autoconfig(cdev->gadget, &fs_notify_desc);
756 if (!ep)
757 goto fail;
758 rndis->notify = ep;
759
760 status = -ENOMEM;
761
762
763 rndis->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
764 if (!rndis->notify_req)
765 goto fail;
766 rndis->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
767 if (!rndis->notify_req->buf)
768 goto fail;
769 rndis->notify_req->length = STATUS_BYTECOUNT;
770 rndis->notify_req->context = rndis;
771 rndis->notify_req->complete = rndis_response_complete;
772
773
774
775
776
777 hs_in_desc.bEndpointAddress = fs_in_desc.bEndpointAddress;
778 hs_out_desc.bEndpointAddress = fs_out_desc.bEndpointAddress;
779 hs_notify_desc.bEndpointAddress = fs_notify_desc.bEndpointAddress;
780
781 ss_in_desc.bEndpointAddress = fs_in_desc.bEndpointAddress;
782 ss_out_desc.bEndpointAddress = fs_out_desc.bEndpointAddress;
783 ss_notify_desc.bEndpointAddress = fs_notify_desc.bEndpointAddress;
784
785 status = usb_assign_descriptors(f, eth_fs_function, eth_hs_function,
786 eth_ss_function, NULL);
787 if (status)
788 goto fail;
789
790 rndis->port.open = rndis_open;
791 rndis->port.close = rndis_close;
792
793 rndis_set_param_medium(rndis->params, RNDIS_MEDIUM_802_3, 0);
794 rndis_set_host_mac(rndis->params, rndis->ethaddr);
795
796 if (rndis->manufacturer && rndis->vendorID &&
797 rndis_set_param_vendor(rndis->params, rndis->vendorID,
798 rndis->manufacturer)) {
799 status = -EINVAL;
800 goto fail_free_descs;
801 }
802
803
804
805
806
807
808 DBG(cdev, "RNDIS: %s speed IN/%s OUT/%s NOTIFY/%s\n",
809 gadget_is_superspeed(c->cdev->gadget) ? "super" :
810 gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
811 rndis->port.in_ep->name, rndis->port.out_ep->name,
812 rndis->notify->name);
813 return 0;
814
815fail_free_descs:
816 usb_free_all_descriptors(f);
817fail:
818 kfree(f->os_desc_table);
819 f->os_desc_n = 0;
820
821 if (rndis->notify_req) {
822 kfree(rndis->notify_req->buf);
823 usb_ep_free_request(rndis->notify, rndis->notify_req);
824 }
825
826 ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
827
828 return status;
829}
830
831void rndis_borrow_net(struct usb_function_instance *f, struct net_device *net)
832{
833 struct f_rndis_opts *opts;
834
835 opts = container_of(f, struct f_rndis_opts, func_inst);
836 if (opts->bound)
837 gether_cleanup(netdev_priv(opts->net));
838 else
839 free_netdev(opts->net);
840 opts->borrowed_net = opts->bound = true;
841 opts->net = net;
842}
843EXPORT_SYMBOL_GPL(rndis_borrow_net);
844
845static inline struct f_rndis_opts *to_f_rndis_opts(struct config_item *item)
846{
847 return container_of(to_config_group(item), struct f_rndis_opts,
848 func_inst.group);
849}
850
851
852USB_ETHERNET_CONFIGFS_ITEM(rndis);
853
854
855USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(rndis);
856
857
858USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(rndis);
859
860
861USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(rndis);
862
863
864USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(rndis);
865
866static struct configfs_attribute *rndis_attrs[] = {
867 &rndis_opts_attr_dev_addr,
868 &rndis_opts_attr_host_addr,
869 &rndis_opts_attr_qmult,
870 &rndis_opts_attr_ifname,
871 NULL,
872};
873
874static struct config_item_type rndis_func_type = {
875 .ct_item_ops = &rndis_item_ops,
876 .ct_attrs = rndis_attrs,
877 .ct_owner = THIS_MODULE,
878};
879
880static void rndis_free_inst(struct usb_function_instance *f)
881{
882 struct f_rndis_opts *opts;
883
884 opts = container_of(f, struct f_rndis_opts, func_inst);
885 if (!opts->borrowed_net) {
886 if (opts->bound)
887 gether_cleanup(netdev_priv(opts->net));
888 else
889 free_netdev(opts->net);
890 }
891
892 kfree(opts);
893}
894
895static struct usb_function_instance *rndis_alloc_inst(void)
896{
897 struct f_rndis_opts *opts;
898 struct usb_os_desc *descs[1];
899 char *names[1];
900
901 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
902 if (!opts)
903 return ERR_PTR(-ENOMEM);
904 opts->rndis_os_desc.ext_compat_id = opts->rndis_ext_compat_id;
905
906 mutex_init(&opts->lock);
907 opts->func_inst.free_func_inst = rndis_free_inst;
908 opts->net = gether_setup_default();
909 if (IS_ERR(opts->net)) {
910 struct net_device *net = opts->net;
911 kfree(opts);
912 return ERR_CAST(net);
913 }
914 INIT_LIST_HEAD(&opts->rndis_os_desc.ext_prop);
915
916 descs[0] = &opts->rndis_os_desc;
917 names[0] = "rndis";
918 config_group_init_type_name(&opts->func_inst.group, "",
919 &rndis_func_type);
920 usb_os_desc_prepare_interf_dir(&opts->func_inst.group, 1, descs,
921 names, THIS_MODULE);
922
923 return &opts->func_inst;
924}
925
926static void rndis_free(struct usb_function *f)
927{
928 struct f_rndis *rndis;
929 struct f_rndis_opts *opts;
930
931 rndis = func_to_rndis(f);
932 rndis_deregister(rndis->params);
933 opts = container_of(f->fi, struct f_rndis_opts, func_inst);
934 kfree(rndis);
935 mutex_lock(&opts->lock);
936 opts->refcnt--;
937 mutex_unlock(&opts->lock);
938}
939
940static void rndis_unbind(struct usb_configuration *c, struct usb_function *f)
941{
942 struct f_rndis *rndis = func_to_rndis(f);
943
944 kfree(f->os_desc_table);
945 f->os_desc_n = 0;
946 usb_free_all_descriptors(f);
947
948 kfree(rndis->notify_req->buf);
949 usb_ep_free_request(rndis->notify, rndis->notify_req);
950}
951
952static struct usb_function *rndis_alloc(struct usb_function_instance *fi)
953{
954 struct f_rndis *rndis;
955 struct f_rndis_opts *opts;
956 struct rndis_params *params;
957
958
959 rndis = kzalloc(sizeof(*rndis), GFP_KERNEL);
960 if (!rndis)
961 return ERR_PTR(-ENOMEM);
962
963 opts = container_of(fi, struct f_rndis_opts, func_inst);
964 mutex_lock(&opts->lock);
965 opts->refcnt++;
966
967 gether_get_host_addr_u8(opts->net, rndis->ethaddr);
968 rndis->vendorID = opts->vendor_id;
969 rndis->manufacturer = opts->manufacturer;
970
971 rndis->port.ioport = netdev_priv(opts->net);
972 mutex_unlock(&opts->lock);
973
974 rndis->port.cdc_filter = 0;
975
976
977 rndis->port.header_len = sizeof(struct rndis_packet_msg_type);
978 rndis->port.wrap = rndis_add_header;
979 rndis->port.unwrap = rndis_rm_hdr;
980
981 rndis->port.func.name = "rndis";
982
983 rndis->port.func.bind = rndis_bind;
984 rndis->port.func.unbind = rndis_unbind;
985 rndis->port.func.set_alt = rndis_set_alt;
986 rndis->port.func.setup = rndis_setup;
987 rndis->port.func.disable = rndis_disable;
988 rndis->port.func.free_func = rndis_free;
989
990 params = rndis_register(rndis_response_available, rndis);
991 if (IS_ERR(params)) {
992 kfree(rndis);
993 return ERR_CAST(params);
994 }
995 rndis->params = params;
996
997 return &rndis->port.func;
998}
999
1000DECLARE_USB_FUNCTION_INIT(rndis, rndis_alloc_inst, rndis_alloc);
1001MODULE_LICENSE("GPL");
1002MODULE_AUTHOR("David Brownell");
1003