1
2
3
4
5
6
7
8
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/device.h>
12#include <linux/list.h>
13#include <linux/err.h>
14#include <linux/dma-mapping.h>
15#include <linux/sched/task_stack.h>
16#include <linux/workqueue.h>
17
18#include <linux/usb/ch9.h>
19#include <linux/usb/gadget.h>
20#include <linux/usb.h>
21
22#include "trace.h"
23
24
25
26
27
28
29
30
31
32
33
34
35
36struct usb_udc {
37 struct usb_gadget_driver *driver;
38 struct usb_gadget *gadget;
39 struct device dev;
40 struct list_head list;
41 bool vbus;
42};
43
44static struct class *udc_class;
45static LIST_HEAD(udc_list);
46static LIST_HEAD(gadget_driver_pending_list);
47static DEFINE_MUTEX(udc_lock);
48
49static int udc_bind_to_driver(struct usb_udc *udc,
50 struct usb_gadget_driver *driver);
51
52
53
54
55
56
57
58
59
60
61
62void usb_ep_set_maxpacket_limit(struct usb_ep *ep,
63 unsigned maxpacket_limit)
64{
65 ep->maxpacket_limit = maxpacket_limit;
66 ep->maxpacket = maxpacket_limit;
67
68 trace_usb_ep_set_maxpacket_limit(ep, 0);
69}
70EXPORT_SYMBOL_GPL(usb_ep_set_maxpacket_limit);
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94int usb_ep_enable(struct usb_ep *ep)
95{
96 int ret = 0;
97
98 if (ep->enabled)
99 goto out;
100
101
102 if (usb_endpoint_maxp(ep->desc) == 0) {
103
104
105
106
107
108 ret = -EINVAL;
109 goto out;
110 }
111
112 ret = ep->ops->enable(ep, ep->desc);
113 if (ret)
114 goto out;
115
116 ep->enabled = true;
117
118out:
119 trace_usb_ep_enable(ep, ret);
120
121 return ret;
122}
123EXPORT_SYMBOL_GPL(usb_ep_enable);
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139int usb_ep_disable(struct usb_ep *ep)
140{
141 int ret = 0;
142
143 if (!ep->enabled)
144 goto out;
145
146 ret = ep->ops->disable(ep);
147 if (ret)
148 goto out;
149
150 ep->enabled = false;
151
152out:
153 trace_usb_ep_disable(ep, ret);
154
155 return ret;
156}
157EXPORT_SYMBOL_GPL(usb_ep_disable);
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173struct usb_request *usb_ep_alloc_request(struct usb_ep *ep,
174 gfp_t gfp_flags)
175{
176 struct usb_request *req = NULL;
177
178 req = ep->ops->alloc_request(ep, gfp_flags);
179
180 trace_usb_ep_alloc_request(ep, req, req ? 0 : -ENOMEM);
181
182 return req;
183}
184EXPORT_SYMBOL_GPL(usb_ep_alloc_request);
185
186
187
188
189
190
191
192
193
194
195void usb_ep_free_request(struct usb_ep *ep,
196 struct usb_request *req)
197{
198 trace_usb_ep_free_request(ep, req, 0);
199 ep->ops->free_request(ep, req);
200}
201EXPORT_SYMBOL_GPL(usb_ep_free_request);
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271int usb_ep_queue(struct usb_ep *ep,
272 struct usb_request *req, gfp_t gfp_flags)
273{
274 int ret = 0;
275
276 if (WARN_ON_ONCE(!ep->enabled && ep->address)) {
277 ret = -ESHUTDOWN;
278 goto out;
279 }
280
281 ret = ep->ops->queue(ep, req, gfp_flags);
282
283out:
284 trace_usb_ep_queue(ep, req, ret);
285
286 return ret;
287}
288EXPORT_SYMBOL_GPL(usb_ep_queue);
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
308{
309 int ret;
310
311 ret = ep->ops->dequeue(ep, req);
312 trace_usb_ep_dequeue(ep, req, ret);
313
314 return ret;
315}
316EXPORT_SYMBOL_GPL(usb_ep_dequeue);
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341int usb_ep_set_halt(struct usb_ep *ep)
342{
343 int ret;
344
345 ret = ep->ops->set_halt(ep, 1);
346 trace_usb_ep_set_halt(ep, ret);
347
348 return ret;
349}
350EXPORT_SYMBOL_GPL(usb_ep_set_halt);
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367int usb_ep_clear_halt(struct usb_ep *ep)
368{
369 int ret;
370
371 ret = ep->ops->set_halt(ep, 0);
372 trace_usb_ep_clear_halt(ep, ret);
373
374 return ret;
375}
376EXPORT_SYMBOL_GPL(usb_ep_clear_halt);
377
378
379
380
381
382
383
384
385
386
387
388
389
390int usb_ep_set_wedge(struct usb_ep *ep)
391{
392 int ret;
393
394 if (ep->ops->set_wedge)
395 ret = ep->ops->set_wedge(ep);
396 else
397 ret = ep->ops->set_halt(ep, 1);
398
399 trace_usb_ep_set_wedge(ep, ret);
400
401 return ret;
402}
403EXPORT_SYMBOL_GPL(usb_ep_set_wedge);
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422int usb_ep_fifo_status(struct usb_ep *ep)
423{
424 int ret;
425
426 if (ep->ops->fifo_status)
427 ret = ep->ops->fifo_status(ep);
428 else
429 ret = -EOPNOTSUPP;
430
431 trace_usb_ep_fifo_status(ep, ret);
432
433 return ret;
434}
435EXPORT_SYMBOL_GPL(usb_ep_fifo_status);
436
437
438
439
440
441
442
443
444
445
446
447
448void usb_ep_fifo_flush(struct usb_ep *ep)
449{
450 if (ep->ops->fifo_flush)
451 ep->ops->fifo_flush(ep);
452
453 trace_usb_ep_fifo_flush(ep, 0);
454}
455EXPORT_SYMBOL_GPL(usb_ep_fifo_flush);
456
457
458
459
460
461
462
463
464
465
466int usb_gadget_frame_number(struct usb_gadget *gadget)
467{
468 int ret;
469
470 ret = gadget->ops->get_frame(gadget);
471
472 trace_usb_gadget_frame_number(gadget, ret);
473
474 return ret;
475}
476EXPORT_SYMBOL_GPL(usb_gadget_frame_number);
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491int usb_gadget_wakeup(struct usb_gadget *gadget)
492{
493 int ret = 0;
494
495 if (!gadget->ops->wakeup) {
496 ret = -EOPNOTSUPP;
497 goto out;
498 }
499
500 ret = gadget->ops->wakeup(gadget);
501
502out:
503 trace_usb_gadget_wakeup(gadget, ret);
504
505 return ret;
506}
507EXPORT_SYMBOL_GPL(usb_gadget_wakeup);
508
509
510
511
512
513
514
515
516
517
518int usb_gadget_set_selfpowered(struct usb_gadget *gadget)
519{
520 int ret = 0;
521
522 if (!gadget->ops->set_selfpowered) {
523 ret = -EOPNOTSUPP;
524 goto out;
525 }
526
527 ret = gadget->ops->set_selfpowered(gadget, 1);
528
529out:
530 trace_usb_gadget_set_selfpowered(gadget, ret);
531
532 return ret;
533}
534EXPORT_SYMBOL_GPL(usb_gadget_set_selfpowered);
535
536
537
538
539
540
541
542
543
544
545
546int usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
547{
548 int ret = 0;
549
550 if (!gadget->ops->set_selfpowered) {
551 ret = -EOPNOTSUPP;
552 goto out;
553 }
554
555 ret = gadget->ops->set_selfpowered(gadget, 0);
556
557out:
558 trace_usb_gadget_clear_selfpowered(gadget, ret);
559
560 return ret;
561}
562EXPORT_SYMBOL_GPL(usb_gadget_clear_selfpowered);
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577int usb_gadget_vbus_connect(struct usb_gadget *gadget)
578{
579 int ret = 0;
580
581 if (!gadget->ops->vbus_session) {
582 ret = -EOPNOTSUPP;
583 goto out;
584 }
585
586 ret = gadget->ops->vbus_session(gadget, 1);
587
588out:
589 trace_usb_gadget_vbus_connect(gadget, ret);
590
591 return ret;
592}
593EXPORT_SYMBOL_GPL(usb_gadget_vbus_connect);
594
595
596
597
598
599
600
601
602
603
604
605
606
607int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
608{
609 int ret = 0;
610
611 if (!gadget->ops->vbus_draw) {
612 ret = -EOPNOTSUPP;
613 goto out;
614 }
615
616 ret = gadget->ops->vbus_draw(gadget, mA);
617 if (!ret)
618 gadget->mA = mA;
619
620out:
621 trace_usb_gadget_vbus_draw(gadget, ret);
622
623 return ret;
624}
625EXPORT_SYMBOL_GPL(usb_gadget_vbus_draw);
626
627
628
629
630
631
632
633
634
635
636
637
638int usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
639{
640 int ret = 0;
641
642 if (!gadget->ops->vbus_session) {
643 ret = -EOPNOTSUPP;
644 goto out;
645 }
646
647 ret = gadget->ops->vbus_session(gadget, 0);
648
649out:
650 trace_usb_gadget_vbus_disconnect(gadget, ret);
651
652 return ret;
653}
654EXPORT_SYMBOL_GPL(usb_gadget_vbus_disconnect);
655
656
657
658
659
660
661
662
663
664
665
666
667int usb_gadget_connect(struct usb_gadget *gadget)
668{
669 int ret = 0;
670
671 if (!gadget->ops->pullup) {
672 ret = -EOPNOTSUPP;
673 goto out;
674 }
675
676 if (gadget->deactivated) {
677
678
679
680
681 gadget->connected = true;
682 goto out;
683 }
684
685 ret = gadget->ops->pullup(gadget, 1);
686 if (!ret)
687 gadget->connected = 1;
688
689out:
690 trace_usb_gadget_connect(gadget, ret);
691
692 return ret;
693}
694EXPORT_SYMBOL_GPL(usb_gadget_connect);
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709int usb_gadget_disconnect(struct usb_gadget *gadget)
710{
711 int ret = 0;
712
713 if (!gadget->ops->pullup) {
714 ret = -EOPNOTSUPP;
715 goto out;
716 }
717
718 if (gadget->deactivated) {
719
720
721
722
723 gadget->connected = false;
724 goto out;
725 }
726
727 ret = gadget->ops->pullup(gadget, 0);
728 if (!ret) {
729 gadget->connected = 0;
730 gadget->udc->driver->disconnect(gadget);
731 }
732
733out:
734 trace_usb_gadget_disconnect(gadget, ret);
735
736 return ret;
737}
738EXPORT_SYMBOL_GPL(usb_gadget_disconnect);
739
740
741
742
743
744
745
746
747
748
749
750
751int usb_gadget_deactivate(struct usb_gadget *gadget)
752{
753 int ret = 0;
754
755 if (gadget->deactivated)
756 goto out;
757
758 if (gadget->connected) {
759 ret = usb_gadget_disconnect(gadget);
760 if (ret)
761 goto out;
762
763
764
765
766
767 gadget->connected = true;
768 }
769 gadget->deactivated = true;
770
771out:
772 trace_usb_gadget_deactivate(gadget, ret);
773
774 return ret;
775}
776EXPORT_SYMBOL_GPL(usb_gadget_deactivate);
777
778
779
780
781
782
783
784
785
786
787int usb_gadget_activate(struct usb_gadget *gadget)
788{
789 int ret = 0;
790
791 if (!gadget->deactivated)
792 goto out;
793
794 gadget->deactivated = false;
795
796
797
798
799
800 if (gadget->connected)
801 ret = usb_gadget_connect(gadget);
802
803out:
804 trace_usb_gadget_activate(gadget, ret);
805
806 return ret;
807}
808EXPORT_SYMBOL_GPL(usb_gadget_activate);
809
810
811
812#ifdef CONFIG_HAS_DMA
813
814int usb_gadget_map_request_by_dev(struct device *dev,
815 struct usb_request *req, int is_in)
816{
817 if (req->length == 0)
818 return 0;
819
820 if (req->num_sgs) {
821 int mapped;
822
823 mapped = dma_map_sg(dev, req->sg, req->num_sgs,
824 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
825 if (mapped == 0) {
826 dev_err(dev, "failed to map SGs\n");
827 return -EFAULT;
828 }
829
830 req->num_mapped_sgs = mapped;
831 } else {
832 if (is_vmalloc_addr(req->buf)) {
833 dev_err(dev, "buffer is not dma capable\n");
834 return -EFAULT;
835 } else if (object_is_on_stack(req->buf)) {
836 dev_err(dev, "buffer is on stack\n");
837 return -EFAULT;
838 }
839
840 req->dma = dma_map_single(dev, req->buf, req->length,
841 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
842
843 if (dma_mapping_error(dev, req->dma)) {
844 dev_err(dev, "failed to map buffer\n");
845 return -EFAULT;
846 }
847
848 req->dma_mapped = 1;
849 }
850
851 return 0;
852}
853EXPORT_SYMBOL_GPL(usb_gadget_map_request_by_dev);
854
855int usb_gadget_map_request(struct usb_gadget *gadget,
856 struct usb_request *req, int is_in)
857{
858 return usb_gadget_map_request_by_dev(gadget->dev.parent, req, is_in);
859}
860EXPORT_SYMBOL_GPL(usb_gadget_map_request);
861
862void usb_gadget_unmap_request_by_dev(struct device *dev,
863 struct usb_request *req, int is_in)
864{
865 if (req->length == 0)
866 return;
867
868 if (req->num_mapped_sgs) {
869 dma_unmap_sg(dev, req->sg, req->num_sgs,
870 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
871
872 req->num_mapped_sgs = 0;
873 } else if (req->dma_mapped) {
874 dma_unmap_single(dev, req->dma, req->length,
875 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
876 req->dma_mapped = 0;
877 }
878}
879EXPORT_SYMBOL_GPL(usb_gadget_unmap_request_by_dev);
880
881void usb_gadget_unmap_request(struct usb_gadget *gadget,
882 struct usb_request *req, int is_in)
883{
884 usb_gadget_unmap_request_by_dev(gadget->dev.parent, req, is_in);
885}
886EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
887
888#endif
889
890
891
892
893
894
895
896
897
898
899
900
901
902void usb_gadget_giveback_request(struct usb_ep *ep,
903 struct usb_request *req)
904{
905 if (likely(req->status == 0))
906 usb_led_activity(USB_LED_EVENT_GADGET);
907
908 trace_usb_gadget_giveback_request(ep, req, 0);
909
910 req->complete(ep, req);
911}
912EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
913
914
915
916
917
918
919
920
921
922struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g, const char *name)
923{
924 struct usb_ep *ep;
925
926 gadget_for_each_ep(ep, g) {
927 if (!strcmp(ep->name, name))
928 return ep;
929 }
930
931 return NULL;
932}
933EXPORT_SYMBOL_GPL(gadget_find_ep_by_name);
934
935
936
937int usb_gadget_ep_match_desc(struct usb_gadget *gadget,
938 struct usb_ep *ep, struct usb_endpoint_descriptor *desc,
939 struct usb_ss_ep_comp_descriptor *ep_comp)
940{
941 u8 type;
942 u16 max;
943 int num_req_streams = 0;
944
945
946 if (ep->claimed)
947 return 0;
948
949 type = usb_endpoint_type(desc);
950 max = usb_endpoint_maxp(desc);
951
952 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
953 return 0;
954 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
955 return 0;
956
957 if (max > ep->maxpacket_limit)
958 return 0;
959
960
961 if (!gadget_is_dualspeed(gadget) && usb_endpoint_maxp_mult(desc) > 1)
962 return 0;
963
964 switch (type) {
965 case USB_ENDPOINT_XFER_CONTROL:
966
967 return 0;
968 case USB_ENDPOINT_XFER_ISOC:
969 if (!ep->caps.type_iso)
970 return 0;
971
972 if (!gadget_is_dualspeed(gadget) && max > 1023)
973 return 0;
974 break;
975 case USB_ENDPOINT_XFER_BULK:
976 if (!ep->caps.type_bulk)
977 return 0;
978 if (ep_comp && gadget_is_superspeed(gadget)) {
979
980
981
982
983 num_req_streams = ep_comp->bmAttributes & 0x1f;
984 if (num_req_streams > ep->max_streams)
985 return 0;
986 }
987 break;
988 case USB_ENDPOINT_XFER_INT:
989
990
991
992 if (!ep->caps.type_int && !ep->caps.type_bulk)
993 return 0;
994
995 if (!gadget_is_dualspeed(gadget) && max > 64)
996 return 0;
997 break;
998 }
999
1000 return 1;
1001}
1002EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc);
1003
1004
1005
1006static void usb_gadget_state_work(struct work_struct *work)
1007{
1008 struct usb_gadget *gadget = work_to_gadget(work);
1009 struct usb_udc *udc = gadget->udc;
1010
1011 if (udc)
1012 sysfs_notify(&udc->dev.kobj, NULL, "state");
1013}
1014
1015void usb_gadget_set_state(struct usb_gadget *gadget,
1016 enum usb_device_state state)
1017{
1018 gadget->state = state;
1019 schedule_work(&gadget->work);
1020}
1021EXPORT_SYMBOL_GPL(usb_gadget_set_state);
1022
1023
1024
1025static void usb_udc_connect_control(struct usb_udc *udc)
1026{
1027 if (udc->vbus)
1028 usb_gadget_connect(udc->gadget);
1029 else
1030 usb_gadget_disconnect(udc->gadget);
1031}
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
1043{
1044 struct usb_udc *udc = gadget->udc;
1045
1046 if (udc) {
1047 udc->vbus = status;
1048 usb_udc_connect_control(udc);
1049 }
1050}
1051EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062void usb_gadget_udc_reset(struct usb_gadget *gadget,
1063 struct usb_gadget_driver *driver)
1064{
1065 driver->reset(gadget);
1066 usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
1067}
1068EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083static inline int usb_gadget_udc_start(struct usb_udc *udc)
1084{
1085 return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
1086}
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099static inline void usb_gadget_udc_stop(struct usb_udc *udc)
1100{
1101 udc->gadget->ops->udc_stop(udc->gadget);
1102}
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114static inline void usb_gadget_udc_set_speed(struct usb_udc *udc,
1115 enum usb_device_speed speed)
1116{
1117 if (udc->gadget->ops->udc_set_speed) {
1118 enum usb_device_speed s;
1119
1120 s = min(speed, udc->gadget->max_speed);
1121 udc->gadget->ops->udc_set_speed(udc->gadget, s);
1122 }
1123}
1124
1125
1126
1127
1128
1129
1130
1131
1132static void usb_udc_release(struct device *dev)
1133{
1134 struct usb_udc *udc;
1135
1136 udc = container_of(dev, struct usb_udc, dev);
1137 dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
1138 kfree(udc);
1139}
1140
1141static const struct attribute_group *usb_udc_attr_groups[];
1142
1143static void usb_udc_nop_release(struct device *dev)
1144{
1145 dev_vdbg(dev, "%s\n", __func__);
1146}
1147
1148
1149static int check_pending_gadget_drivers(struct usb_udc *udc)
1150{
1151 struct usb_gadget_driver *driver;
1152 int ret = 0;
1153
1154 list_for_each_entry(driver, &gadget_driver_pending_list, pending)
1155 if (!driver->udc_name || strcmp(driver->udc_name,
1156 dev_name(&udc->dev)) == 0) {
1157 ret = udc_bind_to_driver(udc, driver);
1158 if (ret != -EPROBE_DEFER)
1159 list_del_init(&driver->pending);
1160 break;
1161 }
1162
1163 return ret;
1164}
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
1177 void (*release)(struct device *dev))
1178{
1179 struct usb_udc *udc;
1180 int ret = -ENOMEM;
1181
1182 dev_set_name(&gadget->dev, "gadget");
1183 INIT_WORK(&gadget->work, usb_gadget_state_work);
1184 gadget->dev.parent = parent;
1185
1186 if (release)
1187 gadget->dev.release = release;
1188 else
1189 gadget->dev.release = usb_udc_nop_release;
1190
1191 device_initialize(&gadget->dev);
1192
1193 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
1194 if (!udc)
1195 goto err_put_gadget;
1196
1197 device_initialize(&udc->dev);
1198 udc->dev.release = usb_udc_release;
1199 udc->dev.class = udc_class;
1200 udc->dev.groups = usb_udc_attr_groups;
1201 udc->dev.parent = parent;
1202 ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
1203 if (ret)
1204 goto err_put_udc;
1205
1206 ret = device_add(&gadget->dev);
1207 if (ret)
1208 goto err_put_udc;
1209
1210 udc->gadget = gadget;
1211 gadget->udc = udc;
1212
1213 mutex_lock(&udc_lock);
1214 list_add_tail(&udc->list, &udc_list);
1215
1216 ret = device_add(&udc->dev);
1217 if (ret)
1218 goto err_unlist_udc;
1219
1220 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
1221 udc->vbus = true;
1222
1223
1224 ret = check_pending_gadget_drivers(udc);
1225 if (ret)
1226 goto err_del_udc;
1227
1228 mutex_unlock(&udc_lock);
1229
1230 return 0;
1231
1232 err_del_udc:
1233 flush_work(&gadget->work);
1234 device_del(&udc->dev);
1235
1236 err_unlist_udc:
1237 list_del(&udc->list);
1238 mutex_unlock(&udc_lock);
1239
1240 device_del(&gadget->dev);
1241
1242 err_put_udc:
1243 put_device(&udc->dev);
1244
1245 err_put_gadget:
1246 put_device(&gadget->dev);
1247 return ret;
1248}
1249EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263char *usb_get_gadget_udc_name(void)
1264{
1265 struct usb_udc *udc;
1266 char *name = NULL;
1267
1268
1269 mutex_lock(&udc_lock);
1270 list_for_each_entry(udc, &udc_list, list) {
1271 if (!udc->driver) {
1272 name = kstrdup(udc->gadget->name, GFP_KERNEL);
1273 break;
1274 }
1275 }
1276 mutex_unlock(&udc_lock);
1277 return name;
1278}
1279EXPORT_SYMBOL_GPL(usb_get_gadget_udc_name);
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
1290{
1291 return usb_add_gadget_udc_release(parent, gadget, NULL);
1292}
1293EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
1294
1295static void usb_gadget_remove_driver(struct usb_udc *udc)
1296{
1297 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
1298 udc->driver->function);
1299
1300 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
1301
1302 usb_gadget_disconnect(udc->gadget);
1303 if (udc->gadget->irq)
1304 synchronize_irq(udc->gadget->irq);
1305 udc->driver->unbind(udc->gadget);
1306 usb_gadget_udc_stop(udc);
1307
1308 udc->driver = NULL;
1309 udc->dev.driver = NULL;
1310 udc->gadget->dev.driver = NULL;
1311}
1312
1313
1314
1315
1316
1317
1318
1319
1320void usb_del_gadget_udc(struct usb_gadget *gadget)
1321{
1322 struct usb_udc *udc = gadget->udc;
1323
1324 if (!udc)
1325 return;
1326
1327 dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
1328
1329 mutex_lock(&udc_lock);
1330 list_del(&udc->list);
1331
1332 if (udc->driver) {
1333 struct usb_gadget_driver *driver = udc->driver;
1334
1335 usb_gadget_remove_driver(udc);
1336 list_add(&driver->pending, &gadget_driver_pending_list);
1337 }
1338 mutex_unlock(&udc_lock);
1339
1340 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
1341 flush_work(&gadget->work);
1342 device_unregister(&udc->dev);
1343 device_unregister(&gadget->dev);
1344 memset(&gadget->dev, 0x00, sizeof(gadget->dev));
1345}
1346EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
1347
1348
1349
1350static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
1351{
1352 int ret;
1353
1354 dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
1355 driver->function);
1356
1357 udc->driver = driver;
1358 udc->dev.driver = &driver->driver;
1359 udc->gadget->dev.driver = &driver->driver;
1360
1361 usb_gadget_udc_set_speed(udc, driver->max_speed);
1362
1363 ret = driver->bind(udc->gadget, driver);
1364 if (ret)
1365 goto err1;
1366 ret = usb_gadget_udc_start(udc);
1367 if (ret) {
1368 driver->unbind(udc->gadget);
1369 goto err1;
1370 }
1371 usb_udc_connect_control(udc);
1372
1373 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
1374 return 0;
1375err1:
1376 if (ret != -EISNAM)
1377 dev_err(&udc->dev, "failed to start %s: %d\n",
1378 udc->driver->function, ret);
1379 udc->driver = NULL;
1380 udc->dev.driver = NULL;
1381 udc->gadget->dev.driver = NULL;
1382 return ret;
1383}
1384
1385int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
1386{
1387 struct usb_udc *udc = NULL;
1388 int ret = -ENODEV;
1389
1390 if (!driver || !driver->bind || !driver->setup)
1391 return -EINVAL;
1392
1393 mutex_lock(&udc_lock);
1394 if (driver->udc_name) {
1395 list_for_each_entry(udc, &udc_list, list) {
1396 ret = strcmp(driver->udc_name, dev_name(&udc->dev));
1397 if (!ret)
1398 break;
1399 }
1400 if (ret)
1401 ret = -ENODEV;
1402 else if (udc->driver)
1403 ret = -EBUSY;
1404 else
1405 goto found;
1406 } else {
1407 list_for_each_entry(udc, &udc_list, list) {
1408
1409 if (!udc->driver)
1410 goto found;
1411 }
1412 }
1413
1414 if (!driver->match_existing_only) {
1415 list_add_tail(&driver->pending, &gadget_driver_pending_list);
1416 pr_info("udc-core: couldn't find an available UDC - added [%s] to list of pending drivers\n",
1417 driver->function);
1418 ret = 0;
1419 }
1420
1421 mutex_unlock(&udc_lock);
1422 if (ret)
1423 pr_warn("udc-core: couldn't find an available UDC or it's busy\n");
1424 return ret;
1425found:
1426 ret = udc_bind_to_driver(udc, driver);
1427 mutex_unlock(&udc_lock);
1428 return ret;
1429}
1430EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
1431
1432int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1433{
1434 struct usb_udc *udc = NULL;
1435 int ret = -ENODEV;
1436
1437 if (!driver || !driver->unbind)
1438 return -EINVAL;
1439
1440 mutex_lock(&udc_lock);
1441 list_for_each_entry(udc, &udc_list, list) {
1442 if (udc->driver == driver) {
1443 usb_gadget_remove_driver(udc);
1444 usb_gadget_set_state(udc->gadget,
1445 USB_STATE_NOTATTACHED);
1446
1447
1448 check_pending_gadget_drivers(udc);
1449
1450
1451
1452
1453 ret = 0;
1454 break;
1455 }
1456 }
1457
1458 if (ret) {
1459 list_del(&driver->pending);
1460 ret = 0;
1461 }
1462 mutex_unlock(&udc_lock);
1463 return ret;
1464}
1465EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
1466
1467
1468
1469static ssize_t srp_store(struct device *dev,
1470 struct device_attribute *attr, const char *buf, size_t n)
1471{
1472 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1473
1474 if (sysfs_streq(buf, "1"))
1475 usb_gadget_wakeup(udc->gadget);
1476
1477 return n;
1478}
1479static DEVICE_ATTR_WO(srp);
1480
1481static ssize_t soft_connect_store(struct device *dev,
1482 struct device_attribute *attr, const char *buf, size_t n)
1483{
1484 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1485
1486 if (!udc->driver) {
1487 dev_err(dev, "soft-connect without a gadget driver\n");
1488 return -EOPNOTSUPP;
1489 }
1490
1491 if (sysfs_streq(buf, "connect")) {
1492 usb_gadget_udc_start(udc);
1493 usb_gadget_connect(udc->gadget);
1494 } else if (sysfs_streq(buf, "disconnect")) {
1495 usb_gadget_disconnect(udc->gadget);
1496 usb_gadget_udc_stop(udc);
1497 } else {
1498 dev_err(dev, "unsupported command '%s'\n", buf);
1499 return -EINVAL;
1500 }
1501
1502 return n;
1503}
1504static DEVICE_ATTR_WO(soft_connect);
1505
1506static ssize_t state_show(struct device *dev, struct device_attribute *attr,
1507 char *buf)
1508{
1509 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1510 struct usb_gadget *gadget = udc->gadget;
1511
1512 return sprintf(buf, "%s\n", usb_state_string(gadget->state));
1513}
1514static DEVICE_ATTR_RO(state);
1515
1516static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1517 char *buf)
1518{
1519 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1520 struct usb_gadget_driver *drv = udc->driver;
1521
1522 if (!drv || !drv->function)
1523 return 0;
1524 return scnprintf(buf, PAGE_SIZE, "%s\n", drv->function);
1525}
1526static DEVICE_ATTR_RO(function);
1527
1528#define USB_UDC_SPEED_ATTR(name, param) \
1529ssize_t name##_show(struct device *dev, \
1530 struct device_attribute *attr, char *buf) \
1531{ \
1532 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
1533 return scnprintf(buf, PAGE_SIZE, "%s\n", \
1534 usb_speed_string(udc->gadget->param)); \
1535} \
1536static DEVICE_ATTR_RO(name)
1537
1538static USB_UDC_SPEED_ATTR(current_speed, speed);
1539static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
1540
1541#define USB_UDC_ATTR(name) \
1542ssize_t name##_show(struct device *dev, \
1543 struct device_attribute *attr, char *buf) \
1544{ \
1545 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
1546 struct usb_gadget *gadget = udc->gadget; \
1547 \
1548 return scnprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
1549} \
1550static DEVICE_ATTR_RO(name)
1551
1552static USB_UDC_ATTR(is_otg);
1553static USB_UDC_ATTR(is_a_peripheral);
1554static USB_UDC_ATTR(b_hnp_enable);
1555static USB_UDC_ATTR(a_hnp_support);
1556static USB_UDC_ATTR(a_alt_hnp_support);
1557static USB_UDC_ATTR(is_selfpowered);
1558
1559static struct attribute *usb_udc_attrs[] = {
1560 &dev_attr_srp.attr,
1561 &dev_attr_soft_connect.attr,
1562 &dev_attr_state.attr,
1563 &dev_attr_function.attr,
1564 &dev_attr_current_speed.attr,
1565 &dev_attr_maximum_speed.attr,
1566
1567 &dev_attr_is_otg.attr,
1568 &dev_attr_is_a_peripheral.attr,
1569 &dev_attr_b_hnp_enable.attr,
1570 &dev_attr_a_hnp_support.attr,
1571 &dev_attr_a_alt_hnp_support.attr,
1572 &dev_attr_is_selfpowered.attr,
1573 NULL,
1574};
1575
1576static const struct attribute_group usb_udc_attr_group = {
1577 .attrs = usb_udc_attrs,
1578};
1579
1580static const struct attribute_group *usb_udc_attr_groups[] = {
1581 &usb_udc_attr_group,
1582 NULL,
1583};
1584
1585static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
1586{
1587 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1588 int ret;
1589
1590 ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
1591 if (ret) {
1592 dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
1593 return ret;
1594 }
1595
1596 if (udc->driver) {
1597 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
1598 udc->driver->function);
1599 if (ret) {
1600 dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
1601 return ret;
1602 }
1603 }
1604
1605 return 0;
1606}
1607
1608static int __init usb_udc_init(void)
1609{
1610 udc_class = class_create(THIS_MODULE, "udc");
1611 if (IS_ERR(udc_class)) {
1612 pr_err("failed to create udc class --> %ld\n",
1613 PTR_ERR(udc_class));
1614 return PTR_ERR(udc_class);
1615 }
1616
1617 udc_class->dev_uevent = usb_udc_uevent;
1618 return 0;
1619}
1620subsys_initcall(usb_udc_init);
1621
1622static void __exit usb_udc_exit(void)
1623{
1624 class_destroy(udc_class);
1625}
1626module_exit(usb_udc_exit);
1627
1628MODULE_DESCRIPTION("UDC Framework");
1629MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
1630MODULE_LICENSE("GPL v2");
1631