Loading...
Note: File does not exist in v3.1.
1/**
2 * udc.c - Core UDC Framework
3 *
4 * Copyright (C) 2010 Texas Instruments
5 * Author: Felipe Balbi <balbi@ti.com>
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 of
9 * the License as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
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 * struct usb_udc - describes one usb device controller
34 * @driver - the gadget driver pointer. For use by the class code
35 * @dev - the child device to the actual controller
36 * @gadget - the gadget. For use by the class code
37 * @list - for use by the udc class driver
38 * @vbus - for udcs who care about vbus status, this value is real vbus status;
39 * for udcs who do not care about vbus status, this value is always true
40 *
41 * This represents the internal data structure which is used by the UDC-class
42 * to hold information about udc driver and gadget together.
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 LIST_HEAD(gadget_driver_pending_list);
55static DEFINE_MUTEX(udc_lock);
56
57static int udc_bind_to_driver(struct usb_udc *udc,
58 struct usb_gadget_driver *driver);
59
60/* ------------------------------------------------------------------------- */
61
62#ifdef CONFIG_HAS_DMA
63
64int usb_gadget_map_request(struct usb_gadget *gadget,
65 struct usb_request *req, int is_in)
66{
67 struct device *dev = gadget->dev.parent;
68
69 if (req->length == 0)
70 return 0;
71
72 if (req->num_sgs) {
73 int mapped;
74
75 mapped = dma_map_sg(dev, req->sg, req->num_sgs,
76 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
77 if (mapped == 0) {
78 dev_err(&gadget->dev, "failed to map SGs\n");
79 return -EFAULT;
80 }
81
82 req->num_mapped_sgs = mapped;
83 } else {
84 req->dma = dma_map_single(dev, req->buf, req->length,
85 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
86
87 if (dma_mapping_error(dev, req->dma)) {
88 dev_err(dev, "failed to map buffer\n");
89 return -EFAULT;
90 }
91 }
92
93 return 0;
94}
95EXPORT_SYMBOL_GPL(usb_gadget_map_request);
96
97void usb_gadget_unmap_request(struct usb_gadget *gadget,
98 struct usb_request *req, int is_in)
99{
100 if (req->length == 0)
101 return;
102
103 if (req->num_mapped_sgs) {
104 dma_unmap_sg(gadget->dev.parent, req->sg, req->num_mapped_sgs,
105 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
106
107 req->num_mapped_sgs = 0;
108 } else {
109 dma_unmap_single(gadget->dev.parent, req->dma, req->length,
110 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
111 }
112}
113EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
114
115#endif /* CONFIG_HAS_DMA */
116
117/* ------------------------------------------------------------------------- */
118
119/**
120 * usb_gadget_giveback_request - give the request back to the gadget layer
121 * Context: in_interrupt()
122 *
123 * This is called by device controller drivers in order to return the
124 * completed request back to the gadget layer.
125 */
126void usb_gadget_giveback_request(struct usb_ep *ep,
127 struct usb_request *req)
128{
129 if (likely(req->status == 0))
130 usb_led_activity(USB_LED_EVENT_GADGET);
131
132 req->complete(ep, req);
133}
134EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
135
136/* ------------------------------------------------------------------------- */
137
138/**
139 * gadget_find_ep_by_name - returns ep whose name is the same as sting passed
140 * in second parameter or NULL if searched endpoint not found
141 * @g: controller to check for quirk
142 * @name: name of searched endpoint
143 */
144struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g, const char *name)
145{
146 struct usb_ep *ep;
147
148 gadget_for_each_ep(ep, g) {
149 if (!strcmp(ep->name, name))
150 return ep;
151 }
152
153 return NULL;
154}
155EXPORT_SYMBOL_GPL(gadget_find_ep_by_name);
156
157/* ------------------------------------------------------------------------- */
158
159int usb_gadget_ep_match_desc(struct usb_gadget *gadget,
160 struct usb_ep *ep, struct usb_endpoint_descriptor *desc,
161 struct usb_ss_ep_comp_descriptor *ep_comp)
162{
163 u8 type;
164 u16 max;
165 int num_req_streams = 0;
166
167 /* endpoint already claimed? */
168 if (ep->claimed)
169 return 0;
170
171 type = usb_endpoint_type(desc);
172 max = 0x7ff & usb_endpoint_maxp(desc);
173
174 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
175 return 0;
176 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
177 return 0;
178
179 if (max > ep->maxpacket_limit)
180 return 0;
181
182 /* "high bandwidth" works only at high speed */
183 if (!gadget_is_dualspeed(gadget) && usb_endpoint_maxp(desc) & (3<<11))
184 return 0;
185
186 switch (type) {
187 case USB_ENDPOINT_XFER_CONTROL:
188 /* only support ep0 for portable CONTROL traffic */
189 return 0;
190 case USB_ENDPOINT_XFER_ISOC:
191 if (!ep->caps.type_iso)
192 return 0;
193 /* ISO: limit 1023 bytes full speed, 1024 high/super speed */
194 if (!gadget_is_dualspeed(gadget) && max > 1023)
195 return 0;
196 break;
197 case USB_ENDPOINT_XFER_BULK:
198 if (!ep->caps.type_bulk)
199 return 0;
200 if (ep_comp && gadget_is_superspeed(gadget)) {
201 /* Get the number of required streams from the
202 * EP companion descriptor and see if the EP
203 * matches it
204 */
205 num_req_streams = ep_comp->bmAttributes & 0x1f;
206 if (num_req_streams > ep->max_streams)
207 return 0;
208 }
209 break;
210 case USB_ENDPOINT_XFER_INT:
211 /* Bulk endpoints handle interrupt transfers,
212 * except the toggle-quirky iso-synch kind
213 */
214 if (!ep->caps.type_int && !ep->caps.type_bulk)
215 return 0;
216 /* INT: limit 64 bytes full speed, 1024 high/super speed */
217 if (!gadget_is_dualspeed(gadget) && max > 64)
218 return 0;
219 break;
220 }
221
222 return 1;
223}
224EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc);
225
226/* ------------------------------------------------------------------------- */
227
228static void usb_gadget_state_work(struct work_struct *work)
229{
230 struct usb_gadget *gadget = work_to_gadget(work);
231 struct usb_udc *udc = gadget->udc;
232
233 if (udc)
234 sysfs_notify(&udc->dev.kobj, NULL, "state");
235}
236
237void usb_gadget_set_state(struct usb_gadget *gadget,
238 enum usb_device_state state)
239{
240 gadget->state = state;
241 schedule_work(&gadget->work);
242}
243EXPORT_SYMBOL_GPL(usb_gadget_set_state);
244
245/* ------------------------------------------------------------------------- */
246
247static void usb_udc_connect_control(struct usb_udc *udc)
248{
249 if (udc->vbus)
250 usb_gadget_connect(udc->gadget);
251 else
252 usb_gadget_disconnect(udc->gadget);
253}
254
255/**
256 * usb_udc_vbus_handler - updates the udc core vbus status, and try to
257 * connect or disconnect gadget
258 * @gadget: The gadget which vbus change occurs
259 * @status: The vbus status
260 *
261 * The udc driver calls it when it wants to connect or disconnect gadget
262 * according to vbus status.
263 */
264void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
265{
266 struct usb_udc *udc = gadget->udc;
267
268 if (udc) {
269 udc->vbus = status;
270 usb_udc_connect_control(udc);
271 }
272}
273EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
274
275/**
276 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
277 * @gadget: The gadget which bus reset occurs
278 * @driver: The gadget driver we want to notify
279 *
280 * If the udc driver has bus reset handler, it needs to call this when the bus
281 * reset occurs, it notifies the gadget driver that the bus reset occurs as
282 * well as updates gadget state.
283 */
284void usb_gadget_udc_reset(struct usb_gadget *gadget,
285 struct usb_gadget_driver *driver)
286{
287 driver->reset(gadget);
288 usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
289}
290EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
291
292/**
293 * usb_gadget_udc_start - tells usb device controller to start up
294 * @udc: The UDC to be started
295 *
296 * This call is issued by the UDC Class driver when it's about
297 * to register a gadget driver to the device controller, before
298 * calling gadget driver's bind() method.
299 *
300 * It allows the controller to be powered off until strictly
301 * necessary to have it powered on.
302 *
303 * Returns zero on success, else negative errno.
304 */
305static inline int usb_gadget_udc_start(struct usb_udc *udc)
306{
307 return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
308}
309
310/**
311 * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
312 * @gadget: The device we want to stop activity
313 * @driver: The driver to unbind from @gadget
314 *
315 * This call is issued by the UDC Class driver after calling
316 * gadget driver's unbind() method.
317 *
318 * The details are implementation specific, but it can go as
319 * far as powering off UDC completely and disable its data
320 * line pullups.
321 */
322static inline void usb_gadget_udc_stop(struct usb_udc *udc)
323{
324 udc->gadget->ops->udc_stop(udc->gadget);
325}
326
327/**
328 * usb_udc_release - release the usb_udc struct
329 * @dev: the dev member within usb_udc
330 *
331 * This is called by driver's core in order to free memory once the last
332 * reference is released.
333 */
334static void usb_udc_release(struct device *dev)
335{
336 struct usb_udc *udc;
337
338 udc = container_of(dev, struct usb_udc, dev);
339 dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
340 kfree(udc);
341}
342
343static const struct attribute_group *usb_udc_attr_groups[];
344
345static void usb_udc_nop_release(struct device *dev)
346{
347 dev_vdbg(dev, "%s\n", __func__);
348}
349
350/**
351 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
352 * @parent: the parent device to this udc. Usually the controller driver's
353 * device.
354 * @gadget: the gadget to be added to the list.
355 * @release: a gadget release function.
356 *
357 * Returns zero on success, negative errno otherwise.
358 */
359int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
360 void (*release)(struct device *dev))
361{
362 struct usb_udc *udc;
363 struct usb_gadget_driver *driver;
364 int ret = -ENOMEM;
365
366 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
367 if (!udc)
368 goto err1;
369
370 dev_set_name(&gadget->dev, "gadget");
371 INIT_WORK(&gadget->work, usb_gadget_state_work);
372 gadget->dev.parent = parent;
373
374 if (release)
375 gadget->dev.release = release;
376 else
377 gadget->dev.release = usb_udc_nop_release;
378
379 ret = device_register(&gadget->dev);
380 if (ret)
381 goto err2;
382
383 device_initialize(&udc->dev);
384 udc->dev.release = usb_udc_release;
385 udc->dev.class = udc_class;
386 udc->dev.groups = usb_udc_attr_groups;
387 udc->dev.parent = parent;
388 ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
389 if (ret)
390 goto err3;
391
392 udc->gadget = gadget;
393 gadget->udc = udc;
394
395 mutex_lock(&udc_lock);
396 list_add_tail(&udc->list, &udc_list);
397
398 ret = device_add(&udc->dev);
399 if (ret)
400 goto err4;
401
402 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
403 udc->vbus = true;
404
405 /* pick up one of pending gadget drivers */
406 list_for_each_entry(driver, &gadget_driver_pending_list, pending) {
407 if (!driver->udc_name || strcmp(driver->udc_name,
408 dev_name(&udc->dev)) == 0) {
409 ret = udc_bind_to_driver(udc, driver);
410 if (ret != -EPROBE_DEFER)
411 list_del(&driver->pending);
412 if (ret)
413 goto err4;
414 break;
415 }
416 }
417
418 mutex_unlock(&udc_lock);
419
420 return 0;
421
422err4:
423 list_del(&udc->list);
424 mutex_unlock(&udc_lock);
425
426err3:
427 put_device(&udc->dev);
428 device_del(&gadget->dev);
429
430err2:
431 put_device(&gadget->dev);
432 kfree(udc);
433
434err1:
435 return ret;
436}
437EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
438
439/**
440 * usb_get_gadget_udc_name - get the name of the first UDC controller
441 * This functions returns the name of the first UDC controller in the system.
442 * Please note that this interface is usefull only for legacy drivers which
443 * assume that there is only one UDC controller in the system and they need to
444 * get its name before initialization. There is no guarantee that the UDC
445 * of the returned name will be still available, when gadget driver registers
446 * itself.
447 *
448 * Returns pointer to string with UDC controller name on success, NULL
449 * otherwise. Caller should kfree() returned string.
450 */
451char *usb_get_gadget_udc_name(void)
452{
453 struct usb_udc *udc;
454 char *name = NULL;
455
456 /* For now we take the first available UDC */
457 mutex_lock(&udc_lock);
458 list_for_each_entry(udc, &udc_list, list) {
459 if (!udc->driver) {
460 name = kstrdup(udc->gadget->name, GFP_KERNEL);
461 break;
462 }
463 }
464 mutex_unlock(&udc_lock);
465 return name;
466}
467EXPORT_SYMBOL_GPL(usb_get_gadget_udc_name);
468
469/**
470 * usb_add_gadget_udc - adds a new gadget to the udc class driver list
471 * @parent: the parent device to this udc. Usually the controller
472 * driver's device.
473 * @gadget: the gadget to be added to the list
474 *
475 * Returns zero on success, negative errno otherwise.
476 */
477int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
478{
479 return usb_add_gadget_udc_release(parent, gadget, NULL);
480}
481EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
482
483static void usb_gadget_remove_driver(struct usb_udc *udc)
484{
485 dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
486 udc->driver->function);
487
488 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
489
490 usb_gadget_disconnect(udc->gadget);
491 udc->driver->disconnect(udc->gadget);
492 udc->driver->unbind(udc->gadget);
493 usb_gadget_udc_stop(udc);
494
495 udc->driver = NULL;
496 udc->dev.driver = NULL;
497 udc->gadget->dev.driver = NULL;
498}
499
500/**
501 * usb_del_gadget_udc - deletes @udc from udc_list
502 * @gadget: the gadget to be removed.
503 *
504 * This, will call usb_gadget_unregister_driver() if
505 * the @udc is still busy.
506 */
507void usb_del_gadget_udc(struct usb_gadget *gadget)
508{
509 struct usb_udc *udc = gadget->udc;
510
511 if (!udc)
512 return;
513
514 dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
515
516 mutex_lock(&udc_lock);
517 list_del(&udc->list);
518
519 if (udc->driver) {
520 struct usb_gadget_driver *driver = udc->driver;
521
522 usb_gadget_remove_driver(udc);
523 list_add(&driver->pending, &gadget_driver_pending_list);
524 }
525 mutex_unlock(&udc_lock);
526
527 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
528 flush_work(&gadget->work);
529 device_unregister(&udc->dev);
530 device_unregister(&gadget->dev);
531}
532EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
533
534/* ------------------------------------------------------------------------- */
535
536static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
537{
538 int ret;
539
540 dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
541 driver->function);
542
543 udc->driver = driver;
544 udc->dev.driver = &driver->driver;
545 udc->gadget->dev.driver = &driver->driver;
546
547 ret = driver->bind(udc->gadget, driver);
548 if (ret)
549 goto err1;
550 ret = usb_gadget_udc_start(udc);
551 if (ret) {
552 driver->unbind(udc->gadget);
553 goto err1;
554 }
555 usb_udc_connect_control(udc);
556
557 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
558 return 0;
559err1:
560 if (ret != -EISNAM)
561 dev_err(&udc->dev, "failed to start %s: %d\n",
562 udc->driver->function, ret);
563 udc->driver = NULL;
564 udc->dev.driver = NULL;
565 udc->gadget->dev.driver = NULL;
566 return ret;
567}
568
569int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
570{
571 struct usb_udc *udc = NULL;
572 int ret = -ENODEV;
573
574 if (!driver || !driver->bind || !driver->setup)
575 return -EINVAL;
576
577 mutex_lock(&udc_lock);
578 if (driver->udc_name) {
579 list_for_each_entry(udc, &udc_list, list) {
580 ret = strcmp(driver->udc_name, dev_name(&udc->dev));
581 if (!ret)
582 break;
583 }
584 if (!ret && !udc->driver)
585 goto found;
586 } else {
587 list_for_each_entry(udc, &udc_list, list) {
588 /* For now we take the first one */
589 if (!udc->driver)
590 goto found;
591 }
592 }
593
594 list_add_tail(&driver->pending, &gadget_driver_pending_list);
595 pr_info("udc-core: couldn't find an available UDC - added [%s] to list of pending drivers\n",
596 driver->function);
597 mutex_unlock(&udc_lock);
598 return 0;
599found:
600 ret = udc_bind_to_driver(udc, driver);
601 mutex_unlock(&udc_lock);
602 return ret;
603}
604EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
605
606int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
607{
608 struct usb_udc *udc = NULL;
609 int ret = -ENODEV;
610
611 if (!driver || !driver->unbind)
612 return -EINVAL;
613
614 mutex_lock(&udc_lock);
615 list_for_each_entry(udc, &udc_list, list)
616 if (udc->driver == driver) {
617 usb_gadget_remove_driver(udc);
618 usb_gadget_set_state(udc->gadget,
619 USB_STATE_NOTATTACHED);
620 ret = 0;
621 break;
622 }
623
624 if (ret) {
625 list_del(&driver->pending);
626 ret = 0;
627 }
628 mutex_unlock(&udc_lock);
629 return ret;
630}
631EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
632
633/* ------------------------------------------------------------------------- */
634
635static ssize_t usb_udc_srp_store(struct device *dev,
636 struct device_attribute *attr, const char *buf, size_t n)
637{
638 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
639
640 if (sysfs_streq(buf, "1"))
641 usb_gadget_wakeup(udc->gadget);
642
643 return n;
644}
645static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);
646
647static ssize_t usb_udc_softconn_store(struct device *dev,
648 struct device_attribute *attr, const char *buf, size_t n)
649{
650 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
651
652 if (!udc->driver) {
653 dev_err(dev, "soft-connect without a gadget driver\n");
654 return -EOPNOTSUPP;
655 }
656
657 if (sysfs_streq(buf, "connect")) {
658 usb_gadget_udc_start(udc);
659 usb_gadget_connect(udc->gadget);
660 } else if (sysfs_streq(buf, "disconnect")) {
661 usb_gadget_disconnect(udc->gadget);
662 udc->driver->disconnect(udc->gadget);
663 usb_gadget_udc_stop(udc);
664 } else {
665 dev_err(dev, "unsupported command '%s'\n", buf);
666 return -EINVAL;
667 }
668
669 return n;
670}
671static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);
672
673static ssize_t state_show(struct device *dev, struct device_attribute *attr,
674 char *buf)
675{
676 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
677 struct usb_gadget *gadget = udc->gadget;
678
679 return sprintf(buf, "%s\n", usb_state_string(gadget->state));
680}
681static DEVICE_ATTR_RO(state);
682
683#define USB_UDC_SPEED_ATTR(name, param) \
684ssize_t name##_show(struct device *dev, \
685 struct device_attribute *attr, char *buf) \
686{ \
687 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
688 return snprintf(buf, PAGE_SIZE, "%s\n", \
689 usb_speed_string(udc->gadget->param)); \
690} \
691static DEVICE_ATTR_RO(name)
692
693static USB_UDC_SPEED_ATTR(current_speed, speed);
694static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
695
696#define USB_UDC_ATTR(name) \
697ssize_t name##_show(struct device *dev, \
698 struct device_attribute *attr, char *buf) \
699{ \
700 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
701 struct usb_gadget *gadget = udc->gadget; \
702 \
703 return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
704} \
705static DEVICE_ATTR_RO(name)
706
707static USB_UDC_ATTR(is_otg);
708static USB_UDC_ATTR(is_a_peripheral);
709static USB_UDC_ATTR(b_hnp_enable);
710static USB_UDC_ATTR(a_hnp_support);
711static USB_UDC_ATTR(a_alt_hnp_support);
712static USB_UDC_ATTR(is_selfpowered);
713
714static struct attribute *usb_udc_attrs[] = {
715 &dev_attr_srp.attr,
716 &dev_attr_soft_connect.attr,
717 &dev_attr_state.attr,
718 &dev_attr_current_speed.attr,
719 &dev_attr_maximum_speed.attr,
720
721 &dev_attr_is_otg.attr,
722 &dev_attr_is_a_peripheral.attr,
723 &dev_attr_b_hnp_enable.attr,
724 &dev_attr_a_hnp_support.attr,
725 &dev_attr_a_alt_hnp_support.attr,
726 &dev_attr_is_selfpowered.attr,
727 NULL,
728};
729
730static const struct attribute_group usb_udc_attr_group = {
731 .attrs = usb_udc_attrs,
732};
733
734static const struct attribute_group *usb_udc_attr_groups[] = {
735 &usb_udc_attr_group,
736 NULL,
737};
738
739static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
740{
741 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
742 int ret;
743
744 ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
745 if (ret) {
746 dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
747 return ret;
748 }
749
750 if (udc->driver) {
751 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
752 udc->driver->function);
753 if (ret) {
754 dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
755 return ret;
756 }
757 }
758
759 return 0;
760}
761
762static int __init usb_udc_init(void)
763{
764 udc_class = class_create(THIS_MODULE, "udc");
765 if (IS_ERR(udc_class)) {
766 pr_err("failed to create udc class --> %ld\n",
767 PTR_ERR(udc_class));
768 return PTR_ERR(udc_class);
769 }
770
771 udc_class->dev_uevent = usb_udc_uevent;
772 return 0;
773}
774subsys_initcall(usb_udc_init);
775
776static void __exit usb_udc_exit(void)
777{
778 class_destroy(udc_class);
779}
780module_exit(usb_udc_exit);
781
782MODULE_DESCRIPTION("UDC Framework");
783MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
784MODULE_LICENSE("GPL v2");