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
134static void usb_gadget_state_work(struct work_struct *work)
135{
136 struct usb_gadget *gadget = work_to_gadget(work);
137 struct usb_udc *udc = gadget->udc;
138
139 if (udc)
140 sysfs_notify(&udc->dev.kobj, NULL, "state");
141}
142
143void usb_gadget_set_state(struct usb_gadget *gadget,
144 enum usb_device_state state)
145{
146 gadget->state = state;
147 schedule_work(&gadget->work);
148}
149EXPORT_SYMBOL_GPL(usb_gadget_set_state);
150
151
152
153static void usb_udc_connect_control(struct usb_udc *udc)
154{
155 if (udc->vbus)
156 usb_gadget_connect(udc->gadget);
157 else
158 usb_gadget_disconnect(udc->gadget);
159}
160
161
162
163
164
165
166
167
168
169
170void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
171{
172 struct usb_udc *udc = gadget->udc;
173
174 if (udc) {
175 udc->vbus = status;
176 usb_udc_connect_control(udc);
177 }
178}
179EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
180
181
182
183
184
185
186
187
188
189
190void usb_gadget_udc_reset(struct usb_gadget *gadget,
191 struct usb_gadget_driver *driver)
192{
193 driver->reset(gadget);
194 usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
195}
196EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211static inline int usb_gadget_udc_start(struct usb_udc *udc)
212{
213 return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
214}
215
216
217
218
219
220
221
222
223
224
225
226
227
228static inline void usb_gadget_udc_stop(struct usb_udc *udc)
229{
230 udc->gadget->ops->udc_stop(udc->gadget);
231}
232
233
234
235
236
237
238
239
240static void usb_udc_release(struct device *dev)
241{
242 struct usb_udc *udc;
243
244 udc = container_of(dev, struct usb_udc, dev);
245 dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
246 kfree(udc);
247}
248
249static const struct attribute_group *usb_udc_attr_groups[];
250
251static void usb_udc_nop_release(struct device *dev)
252{
253 dev_vdbg(dev, "%s\n", __func__);
254}
255
256
257
258
259
260
261
262
263
264
265int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
266 void (*release)(struct device *dev))
267{
268 struct usb_udc *udc;
269 int ret = -ENOMEM;
270
271 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
272 if (!udc)
273 goto err1;
274
275 dev_set_name(&gadget->dev, "gadget");
276 INIT_WORK(&gadget->work, usb_gadget_state_work);
277 gadget->dev.parent = parent;
278
279#ifdef CONFIG_HAS_DMA
280 dma_set_coherent_mask(&gadget->dev, parent->coherent_dma_mask);
281 gadget->dev.dma_parms = parent->dma_parms;
282 gadget->dev.dma_mask = parent->dma_mask;
283#endif
284
285 if (release)
286 gadget->dev.release = release;
287 else
288 gadget->dev.release = usb_udc_nop_release;
289
290 ret = device_register(&gadget->dev);
291 if (ret)
292 goto err2;
293
294 device_initialize(&udc->dev);
295 udc->dev.release = usb_udc_release;
296 udc->dev.class = udc_class;
297 udc->dev.groups = usb_udc_attr_groups;
298 udc->dev.parent = parent;
299 ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
300 if (ret)
301 goto err3;
302
303 udc->gadget = gadget;
304 gadget->udc = udc;
305
306 mutex_lock(&udc_lock);
307 list_add_tail(&udc->list, &udc_list);
308
309 ret = device_add(&udc->dev);
310 if (ret)
311 goto err4;
312
313 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
314 udc->vbus = true;
315
316 mutex_unlock(&udc_lock);
317
318 return 0;
319
320err4:
321 list_del(&udc->list);
322 mutex_unlock(&udc_lock);
323
324err3:
325 put_device(&udc->dev);
326 device_del(&gadget->dev);
327
328err2:
329 put_device(&gadget->dev);
330 kfree(udc);
331
332err1:
333 return ret;
334}
335EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
336
337
338
339
340
341
342
343
344
345int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
346{
347 return usb_add_gadget_udc_release(parent, gadget, NULL);
348}
349EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
350
351static void usb_gadget_remove_driver(struct usb_udc *udc)
352{
353 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
354 udc->driver->function);
355
356 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
357
358 usb_gadget_disconnect(udc->gadget);
359 udc->driver->disconnect(udc->gadget);
360 udc->driver->unbind(udc->gadget);
361 usb_gadget_udc_stop(udc);
362
363 udc->driver = NULL;
364 udc->dev.driver = NULL;
365 udc->gadget->dev.driver = NULL;
366}
367
368
369
370
371
372
373
374
375void usb_del_gadget_udc(struct usb_gadget *gadget)
376{
377 struct usb_udc *udc = gadget->udc;
378
379 if (!udc)
380 return;
381
382 dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
383
384 mutex_lock(&udc_lock);
385 list_del(&udc->list);
386 mutex_unlock(&udc_lock);
387
388 if (udc->driver)
389 usb_gadget_remove_driver(udc);
390
391 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
392 flush_work(&gadget->work);
393 device_unregister(&udc->dev);
394 device_unregister(&gadget->dev);
395}
396EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
397
398
399
400static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
401{
402 int ret;
403
404 dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
405 driver->function);
406
407 udc->driver = driver;
408 udc->dev.driver = &driver->driver;
409 udc->gadget->dev.driver = &driver->driver;
410
411 ret = driver->bind(udc->gadget, driver);
412 if (ret)
413 goto err1;
414 ret = usb_gadget_udc_start(udc);
415 if (ret) {
416 driver->unbind(udc->gadget);
417 goto err1;
418 }
419 usb_udc_connect_control(udc);
420
421 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
422 return 0;
423err1:
424 if (ret != -EISNAM)
425 dev_err(&udc->dev, "failed to start %s: %d\n",
426 udc->driver->function, ret);
427 udc->driver = NULL;
428 udc->dev.driver = NULL;
429 udc->gadget->dev.driver = NULL;
430 return ret;
431}
432
433int usb_udc_attach_driver(const char *name, struct usb_gadget_driver *driver)
434{
435 struct usb_udc *udc = NULL;
436 int ret = -ENODEV;
437
438 mutex_lock(&udc_lock);
439 list_for_each_entry(udc, &udc_list, list) {
440 ret = strcmp(name, dev_name(&udc->dev));
441 if (!ret)
442 break;
443 }
444 if (ret) {
445 ret = -ENODEV;
446 goto out;
447 }
448 if (udc->driver) {
449 ret = -EBUSY;
450 goto out;
451 }
452 ret = udc_bind_to_driver(udc, driver);
453out:
454 mutex_unlock(&udc_lock);
455 return ret;
456}
457EXPORT_SYMBOL_GPL(usb_udc_attach_driver);
458
459int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
460{
461 struct usb_udc *udc = NULL;
462 int ret;
463
464 if (!driver || !driver->bind || !driver->setup)
465 return -EINVAL;
466
467 mutex_lock(&udc_lock);
468 list_for_each_entry(udc, &udc_list, list) {
469
470 if (!udc->driver)
471 goto found;
472 }
473
474 pr_debug("couldn't find an available UDC\n");
475 mutex_unlock(&udc_lock);
476 return -ENODEV;
477found:
478 ret = udc_bind_to_driver(udc, driver);
479 mutex_unlock(&udc_lock);
480 return ret;
481}
482EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
483
484int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
485{
486 struct usb_udc *udc = NULL;
487 int ret = -ENODEV;
488
489 if (!driver || !driver->unbind)
490 return -EINVAL;
491
492 mutex_lock(&udc_lock);
493 list_for_each_entry(udc, &udc_list, list)
494 if (udc->driver == driver) {
495 usb_gadget_remove_driver(udc);
496 usb_gadget_set_state(udc->gadget,
497 USB_STATE_NOTATTACHED);
498 ret = 0;
499 break;
500 }
501
502 mutex_unlock(&udc_lock);
503 return ret;
504}
505EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
506
507
508
509static ssize_t usb_udc_srp_store(struct device *dev,
510 struct device_attribute *attr, const char *buf, size_t n)
511{
512 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
513
514 if (sysfs_streq(buf, "1"))
515 usb_gadget_wakeup(udc->gadget);
516
517 return n;
518}
519static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);
520
521static ssize_t usb_udc_softconn_store(struct device *dev,
522 struct device_attribute *attr, const char *buf, size_t n)
523{
524 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
525
526 if (!udc->driver) {
527 dev_err(dev, "soft-connect without a gadget driver\n");
528 return -EOPNOTSUPP;
529 }
530
531 if (sysfs_streq(buf, "connect")) {
532 usb_gadget_udc_start(udc);
533 usb_gadget_connect(udc->gadget);
534 } else if (sysfs_streq(buf, "disconnect")) {
535 usb_gadget_disconnect(udc->gadget);
536 udc->driver->disconnect(udc->gadget);
537 usb_gadget_udc_stop(udc);
538 } else {
539 dev_err(dev, "unsupported command '%s'\n", buf);
540 return -EINVAL;
541 }
542
543 return n;
544}
545static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);
546
547static ssize_t state_show(struct device *dev, struct device_attribute *attr,
548 char *buf)
549{
550 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
551 struct usb_gadget *gadget = udc->gadget;
552
553 return sprintf(buf, "%s\n", usb_state_string(gadget->state));
554}
555static DEVICE_ATTR_RO(state);
556
557#define USB_UDC_SPEED_ATTR(name, param) \
558ssize_t name##_show(struct device *dev, \
559 struct device_attribute *attr, char *buf) \
560{ \
561 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
562 return snprintf(buf, PAGE_SIZE, "%s\n", \
563 usb_speed_string(udc->gadget->param)); \
564} \
565static DEVICE_ATTR_RO(name)
566
567static USB_UDC_SPEED_ATTR(current_speed, speed);
568static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
569
570#define USB_UDC_ATTR(name) \
571ssize_t name##_show(struct device *dev, \
572 struct device_attribute *attr, char *buf) \
573{ \
574 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
575 struct usb_gadget *gadget = udc->gadget; \
576 \
577 return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
578} \
579static DEVICE_ATTR_RO(name)
580
581static USB_UDC_ATTR(is_otg);
582static USB_UDC_ATTR(is_a_peripheral);
583static USB_UDC_ATTR(b_hnp_enable);
584static USB_UDC_ATTR(a_hnp_support);
585static USB_UDC_ATTR(a_alt_hnp_support);
586static USB_UDC_ATTR(is_selfpowered);
587
588static struct attribute *usb_udc_attrs[] = {
589 &dev_attr_srp.attr,
590 &dev_attr_soft_connect.attr,
591 &dev_attr_state.attr,
592 &dev_attr_current_speed.attr,
593 &dev_attr_maximum_speed.attr,
594
595 &dev_attr_is_otg.attr,
596 &dev_attr_is_a_peripheral.attr,
597 &dev_attr_b_hnp_enable.attr,
598 &dev_attr_a_hnp_support.attr,
599 &dev_attr_a_alt_hnp_support.attr,
600 &dev_attr_is_selfpowered.attr,
601 NULL,
602};
603
604static const struct attribute_group usb_udc_attr_group = {
605 .attrs = usb_udc_attrs,
606};
607
608static const struct attribute_group *usb_udc_attr_groups[] = {
609 &usb_udc_attr_group,
610 NULL,
611};
612
613static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
614{
615 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
616 int ret;
617
618 ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
619 if (ret) {
620 dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
621 return ret;
622 }
623
624 if (udc->driver) {
625 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
626 udc->driver->function);
627 if (ret) {
628 dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
629 return ret;
630 }
631 }
632
633 return 0;
634}
635
636static int __init usb_udc_init(void)
637{
638 udc_class = class_create(THIS_MODULE, "udc");
639 if (IS_ERR(udc_class)) {
640 pr_err("failed to create udc class --> %ld\n",
641 PTR_ERR(udc_class));
642 return PTR_ERR(udc_class);
643 }
644
645 udc_class->dev_uevent = usb_udc_uevent;
646 return 0;
647}
648subsys_initcall(usb_udc_init);
649
650static void __exit usb_udc_exit(void)
651{
652 class_destroy(udc_class);
653}
654module_exit(usb_udc_exit);
655
656MODULE_DESCRIPTION("UDC Framework");
657MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
658MODULE_LICENSE("GPL v2");
659