1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/device.h>
23#include <linux/list.h>
24#include <linux/err.h>
25#include <linux/dma-mapping.h>
26#include <linux/workqueue.h>
27
28#include <linux/usb/ch9.h>
29#include <linux/usb/gadget.h>
30#include <linux/usb.h>
31
32
33
34
35
36
37
38
39
40
41
42
43
44struct usb_udc {
45 struct usb_gadget_driver *driver;
46 struct usb_gadget *gadget;
47 struct device dev;
48 struct list_head list;
49 bool vbus;
50};
51
52static struct class *udc_class;
53static LIST_HEAD(udc_list);
54static DEFINE_MUTEX(udc_lock);
55
56
57
58#ifdef CONFIG_HAS_DMA
59
60int usb_gadget_map_request(struct usb_gadget *gadget,
61 struct usb_request *req, int is_in)
62{
63 struct device *dev = gadget->dev.parent;
64
65 if (req->length == 0)
66 return 0;
67
68 if (req->num_sgs) {
69 int mapped;
70
71 mapped = dma_map_sg(dev, req->sg, req->num_sgs,
72 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
73 if (mapped == 0) {
74 dev_err(&gadget->dev, "failed to map SGs\n");
75 return -EFAULT;
76 }
77
78 req->num_mapped_sgs = mapped;
79 } else {
80 req->dma = dma_map_single(dev, req->buf, req->length,
81 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
82
83 if (dma_mapping_error(dev, req->dma)) {
84 dev_err(dev, "failed to map buffer\n");
85 return -EFAULT;
86 }
87 }
88
89 return 0;
90}
91EXPORT_SYMBOL_GPL(usb_gadget_map_request);
92
93void usb_gadget_unmap_request(struct usb_gadget *gadget,
94 struct usb_request *req, int is_in)
95{
96 if (req->length == 0)
97 return;
98
99 if (req->num_mapped_sgs) {
100 dma_unmap_sg(gadget->dev.parent, req->sg, req->num_mapped_sgs,
101 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
102
103 req->num_mapped_sgs = 0;
104 } else {
105 dma_unmap_single(gadget->dev.parent, req->dma, req->length,
106 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
107 }
108}
109EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
110
111#endif
112
113
114
115
116
117
118
119
120
121
122void usb_gadget_giveback_request(struct usb_ep *ep,
123 struct usb_request *req)
124{
125 if (likely(req->status == 0))
126 usb_led_activity(USB_LED_EVENT_GADGET);
127
128 req->complete(ep, req);
129}
130EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
131
132
133
134
135
136
137
138
139
140struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g, const char *name)
141{
142 struct usb_ep *ep;
143
144 gadget_for_each_ep(ep, g) {
145 if (!strcmp(ep->name, name))
146 return ep;
147 }
148
149 return NULL;
150}
151EXPORT_SYMBOL_GPL(gadget_find_ep_by_name);
152
153
154
155int usb_gadget_ep_match_desc(struct usb_gadget *gadget,
156 struct usb_ep *ep, struct usb_endpoint_descriptor *desc,
157 struct usb_ss_ep_comp_descriptor *ep_comp)
158{
159 u8 type;
160 u16 max;
161 int num_req_streams = 0;
162
163
164 if (ep->claimed)
165 return 0;
166
167 type = usb_endpoint_type(desc);
168 max = 0x7ff & usb_endpoint_maxp(desc);
169
170 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
171 return 0;
172 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
173 return 0;
174
175 if (max > ep->maxpacket_limit)
176 return 0;
177
178
179 if (!gadget_is_dualspeed(gadget) && usb_endpoint_maxp(desc) & (3<<11))
180 return 0;
181
182 switch (type) {
183 case USB_ENDPOINT_XFER_CONTROL:
184
185 return 0;
186 case USB_ENDPOINT_XFER_ISOC:
187 if (!ep->caps.type_iso)
188 return 0;
189
190 if (!gadget_is_dualspeed(gadget) && max > 1023)
191 return 0;
192 break;
193 case USB_ENDPOINT_XFER_BULK:
194 if (!ep->caps.type_bulk)
195 return 0;
196 if (ep_comp && gadget_is_superspeed(gadget)) {
197
198
199
200
201 num_req_streams = ep_comp->bmAttributes & 0x1f;
202 if (num_req_streams > ep->max_streams)
203 return 0;
204 }
205 break;
206 case USB_ENDPOINT_XFER_INT:
207
208
209
210 if (!ep->caps.type_int && !ep->caps.type_bulk)
211 return 0;
212
213 if (!gadget_is_dualspeed(gadget) && max > 64)
214 return 0;
215 break;
216 }
217
218 return 1;
219}
220EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc);
221
222
223
224static void usb_gadget_state_work(struct work_struct *work)
225{
226 struct usb_gadget *gadget = work_to_gadget(work);
227 struct usb_udc *udc = gadget->udc;
228
229 if (udc)
230 sysfs_notify(&udc->dev.kobj, NULL, "state");
231}
232
233void usb_gadget_set_state(struct usb_gadget *gadget,
234 enum usb_device_state state)
235{
236 gadget->state = state;
237 schedule_work(&gadget->work);
238}
239EXPORT_SYMBOL_GPL(usb_gadget_set_state);
240
241
242
243static void usb_udc_connect_control(struct usb_udc *udc)
244{
245 if (udc->vbus)
246 usb_gadget_connect(udc->gadget);
247 else
248 usb_gadget_disconnect(udc->gadget);
249}
250
251
252
253
254
255
256
257
258
259
260void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
261{
262 struct usb_udc *udc = gadget->udc;
263
264 if (udc) {
265 udc->vbus = status;
266 usb_udc_connect_control(udc);
267 }
268}
269EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
270
271
272
273
274
275
276
277
278
279
280void usb_gadget_udc_reset(struct usb_gadget *gadget,
281 struct usb_gadget_driver *driver)
282{
283 driver->reset(gadget);
284 usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
285}
286EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301static inline int usb_gadget_udc_start(struct usb_udc *udc)
302{
303 return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
304}
305
306
307
308
309
310
311
312
313
314
315
316
317
318static inline void usb_gadget_udc_stop(struct usb_udc *udc)
319{
320 udc->gadget->ops->udc_stop(udc->gadget);
321}
322
323
324
325
326
327
328
329
330static void usb_udc_release(struct device *dev)
331{
332 struct usb_udc *udc;
333
334 udc = container_of(dev, struct usb_udc, dev);
335 dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
336 kfree(udc);
337}
338
339static const struct attribute_group *usb_udc_attr_groups[];
340
341static void usb_udc_nop_release(struct device *dev)
342{
343 dev_vdbg(dev, "%s\n", __func__);
344}
345
346
347
348
349
350
351
352
353
354
355int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
356 void (*release)(struct device *dev))
357{
358 struct usb_udc *udc;
359 int ret = -ENOMEM;
360
361 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
362 if (!udc)
363 goto err1;
364
365 dev_set_name(&gadget->dev, "gadget");
366 INIT_WORK(&gadget->work, usb_gadget_state_work);
367 gadget->dev.parent = parent;
368
369#ifdef CONFIG_HAS_DMA
370 dma_set_coherent_mask(&gadget->dev, parent->coherent_dma_mask);
371 gadget->dev.dma_parms = parent->dma_parms;
372 gadget->dev.dma_mask = parent->dma_mask;
373#endif
374
375 if (release)
376 gadget->dev.release = release;
377 else
378 gadget->dev.release = usb_udc_nop_release;
379
380 ret = device_register(&gadget->dev);
381 if (ret)
382 goto err2;
383
384 device_initialize(&udc->dev);
385 udc->dev.release = usb_udc_release;
386 udc->dev.class = udc_class;
387 udc->dev.groups = usb_udc_attr_groups;
388 udc->dev.parent = parent;
389 ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
390 if (ret)
391 goto err3;
392
393 udc->gadget = gadget;
394 gadget->udc = udc;
395
396 mutex_lock(&udc_lock);
397 list_add_tail(&udc->list, &udc_list);
398
399 ret = device_add(&udc->dev);
400 if (ret)
401 goto err4;
402
403 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
404 udc->vbus = true;
405
406 mutex_unlock(&udc_lock);
407
408 return 0;
409
410err4:
411 list_del(&udc->list);
412 mutex_unlock(&udc_lock);
413
414err3:
415 put_device(&udc->dev);
416 device_del(&gadget->dev);
417
418err2:
419 put_device(&gadget->dev);
420 kfree(udc);
421
422err1:
423 return ret;
424}
425EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
426
427
428
429
430
431
432
433
434
435int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
436{
437 return usb_add_gadget_udc_release(parent, gadget, NULL);
438}
439EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
440
441static void usb_gadget_remove_driver(struct usb_udc *udc)
442{
443 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
444 udc->driver->function);
445
446 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
447
448 usb_gadget_disconnect(udc->gadget);
449 udc->driver->disconnect(udc->gadget);
450 udc->driver->unbind(udc->gadget);
451 usb_gadget_udc_stop(udc);
452
453 udc->driver = NULL;
454 udc->dev.driver = NULL;
455 udc->gadget->dev.driver = NULL;
456}
457
458
459
460
461
462
463
464
465void usb_del_gadget_udc(struct usb_gadget *gadget)
466{
467 struct usb_udc *udc = gadget->udc;
468
469 if (!udc)
470 return;
471
472 dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
473
474 mutex_lock(&udc_lock);
475 list_del(&udc->list);
476 mutex_unlock(&udc_lock);
477
478 if (udc->driver)
479 usb_gadget_remove_driver(udc);
480
481 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
482 flush_work(&gadget->work);
483 device_unregister(&udc->dev);
484 device_unregister(&gadget->dev);
485}
486EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
487
488
489
490static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
491{
492 int ret;
493
494 dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
495 driver->function);
496
497 udc->driver = driver;
498 udc->dev.driver = &driver->driver;
499 udc->gadget->dev.driver = &driver->driver;
500
501 ret = driver->bind(udc->gadget, driver);
502 if (ret)
503 goto err1;
504 ret = usb_gadget_udc_start(udc);
505 if (ret) {
506 driver->unbind(udc->gadget);
507 goto err1;
508 }
509 usb_udc_connect_control(udc);
510
511 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
512 return 0;
513err1:
514 if (ret != -EISNAM)
515 dev_err(&udc->dev, "failed to start %s: %d\n",
516 udc->driver->function, ret);
517 udc->driver = NULL;
518 udc->dev.driver = NULL;
519 udc->gadget->dev.driver = NULL;
520 return ret;
521}
522
523int usb_udc_attach_driver(const char *name, struct usb_gadget_driver *driver)
524{
525 struct usb_udc *udc = NULL;
526 int ret = -ENODEV;
527
528 mutex_lock(&udc_lock);
529 list_for_each_entry(udc, &udc_list, list) {
530 ret = strcmp(name, dev_name(&udc->dev));
531 if (!ret)
532 break;
533 }
534 if (ret) {
535 ret = -ENODEV;
536 goto out;
537 }
538 if (udc->driver) {
539 ret = -EBUSY;
540 goto out;
541 }
542 ret = udc_bind_to_driver(udc, driver);
543out:
544 mutex_unlock(&udc_lock);
545 return ret;
546}
547EXPORT_SYMBOL_GPL(usb_udc_attach_driver);
548
549int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
550{
551 struct usb_udc *udc = NULL;
552 int ret;
553
554 if (!driver || !driver->bind || !driver->setup)
555 return -EINVAL;
556
557 mutex_lock(&udc_lock);
558 list_for_each_entry(udc, &udc_list, list) {
559
560 if (!udc->driver)
561 goto found;
562 }
563
564 pr_debug("couldn't find an available UDC\n");
565 mutex_unlock(&udc_lock);
566 return -ENODEV;
567found:
568 ret = udc_bind_to_driver(udc, driver);
569 mutex_unlock(&udc_lock);
570 return ret;
571}
572EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
573
574int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
575{
576 struct usb_udc *udc = NULL;
577 int ret = -ENODEV;
578
579 if (!driver || !driver->unbind)
580 return -EINVAL;
581
582 mutex_lock(&udc_lock);
583 list_for_each_entry(udc, &udc_list, list)
584 if (udc->driver == driver) {
585 usb_gadget_remove_driver(udc);
586 usb_gadget_set_state(udc->gadget,
587 USB_STATE_NOTATTACHED);
588 ret = 0;
589 break;
590 }
591
592 mutex_unlock(&udc_lock);
593 return ret;
594}
595EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
596
597
598
599static ssize_t usb_udc_srp_store(struct device *dev,
600 struct device_attribute *attr, const char *buf, size_t n)
601{
602 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
603
604 if (sysfs_streq(buf, "1"))
605 usb_gadget_wakeup(udc->gadget);
606
607 return n;
608}
609static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);
610
611static ssize_t usb_udc_softconn_store(struct device *dev,
612 struct device_attribute *attr, const char *buf, size_t n)
613{
614 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
615
616 if (!udc->driver) {
617 dev_err(dev, "soft-connect without a gadget driver\n");
618 return -EOPNOTSUPP;
619 }
620
621 if (sysfs_streq(buf, "connect")) {
622 usb_gadget_udc_start(udc);
623 usb_gadget_connect(udc->gadget);
624 } else if (sysfs_streq(buf, "disconnect")) {
625 usb_gadget_disconnect(udc->gadget);
626 udc->driver->disconnect(udc->gadget);
627 usb_gadget_udc_stop(udc);
628 } else {
629 dev_err(dev, "unsupported command '%s'\n", buf);
630 return -EINVAL;
631 }
632
633 return n;
634}
635static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);
636
637static ssize_t state_show(struct device *dev, struct device_attribute *attr,
638 char *buf)
639{
640 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
641 struct usb_gadget *gadget = udc->gadget;
642
643 return sprintf(buf, "%s\n", usb_state_string(gadget->state));
644}
645static DEVICE_ATTR_RO(state);
646
647#define USB_UDC_SPEED_ATTR(name, param) \
648ssize_t name##_show(struct device *dev, \
649 struct device_attribute *attr, char *buf) \
650{ \
651 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
652 return snprintf(buf, PAGE_SIZE, "%s\n", \
653 usb_speed_string(udc->gadget->param)); \
654} \
655static DEVICE_ATTR_RO(name)
656
657static USB_UDC_SPEED_ATTR(current_speed, speed);
658static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
659
660#define USB_UDC_ATTR(name) \
661ssize_t name##_show(struct device *dev, \
662 struct device_attribute *attr, char *buf) \
663{ \
664 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
665 struct usb_gadget *gadget = udc->gadget; \
666 \
667 return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
668} \
669static DEVICE_ATTR_RO(name)
670
671static USB_UDC_ATTR(is_otg);
672static USB_UDC_ATTR(is_a_peripheral);
673static USB_UDC_ATTR(b_hnp_enable);
674static USB_UDC_ATTR(a_hnp_support);
675static USB_UDC_ATTR(a_alt_hnp_support);
676static USB_UDC_ATTR(is_selfpowered);
677
678static struct attribute *usb_udc_attrs[] = {
679 &dev_attr_srp.attr,
680 &dev_attr_soft_connect.attr,
681 &dev_attr_state.attr,
682 &dev_attr_current_speed.attr,
683 &dev_attr_maximum_speed.attr,
684
685 &dev_attr_is_otg.attr,
686 &dev_attr_is_a_peripheral.attr,
687 &dev_attr_b_hnp_enable.attr,
688 &dev_attr_a_hnp_support.attr,
689 &dev_attr_a_alt_hnp_support.attr,
690 &dev_attr_is_selfpowered.attr,
691 NULL,
692};
693
694static const struct attribute_group usb_udc_attr_group = {
695 .attrs = usb_udc_attrs,
696};
697
698static const struct attribute_group *usb_udc_attr_groups[] = {
699 &usb_udc_attr_group,
700 NULL,
701};
702
703static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
704{
705 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
706 int ret;
707
708 ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
709 if (ret) {
710 dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
711 return ret;
712 }
713
714 if (udc->driver) {
715 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
716 udc->driver->function);
717 if (ret) {
718 dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
719 return ret;
720 }
721 }
722
723 return 0;
724}
725
726static int __init usb_udc_init(void)
727{
728 udc_class = class_create(THIS_MODULE, "udc");
729 if (IS_ERR(udc_class)) {
730 pr_err("failed to create udc class --> %ld\n",
731 PTR_ERR(udc_class));
732 return PTR_ERR(udc_class);
733 }
734
735 udc_class->dev_uevent = usb_udc_uevent;
736 return 0;
737}
738subsys_initcall(usb_udc_init);
739
740static void __exit usb_udc_exit(void)
741{
742 class_destroy(udc_class);
743}
744module_exit(usb_udc_exit);
745
746MODULE_DESCRIPTION("UDC Framework");
747MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
748MODULE_LICENSE("GPL v2");
749