1 // SPDX-License-Identifier: GPL-2.0
3 * udc.c - Core UDC Framework
5 * Copyright (C) 2010 Texas Instruments
6 * Author: Felipe Balbi <balbi@ti.com>
9 #define pr_fmt(fmt) "UDC core: " fmt
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/device.h>
14 #include <linux/list.h>
15 #include <linux/idr.h>
16 #include <linux/err.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/sched/task_stack.h>
19 #include <linux/workqueue.h>
21 #include <linux/usb/ch9.h>
22 #include <linux/usb/gadget.h>
23 #include <linux/usb.h>
27 static DEFINE_IDA(gadget_id_numbers);
29 static const struct bus_type gadget_bus_type;
32 * struct usb_udc - describes one usb device controller
33 * @driver: the gadget driver pointer. For use by the class code
34 * @dev: the child device to the actual controller
35 * @gadget: the gadget. For use by the class code
36 * @list: for use by the udc class driver
37 * @vbus: for udcs who care about vbus status, this value is real vbus status;
38 * for udcs who do not care about vbus status, this value is always true
39 * @started: the UDC's started state. True if the UDC had started.
40 * @connect_lock: protects udc->vbus, udc->started, gadget->connect, gadget->deactivate related
41 * functions. usb_gadget_connect_locked, usb_gadget_disconnect_locked,
42 * usb_udc_connect_control_locked, usb_gadget_udc_start_locked, usb_gadget_udc_stop_locked are
43 * called with this lock held.
45 * This represents the internal data structure which is used by the UDC-class
46 * to hold information about udc driver and gadget together.
49 struct usb_gadget_driver *driver;
50 struct usb_gadget *gadget;
52 struct list_head list;
55 struct mutex connect_lock;
58 static struct class *udc_class;
59 static LIST_HEAD(udc_list);
61 /* Protects udc_list, udc->driver, driver->is_bound, and related calls */
62 static DEFINE_MUTEX(udc_lock);
64 /* ------------------------------------------------------------------------- */
67 * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
68 * @ep:the endpoint being configured
69 * @maxpacket_limit:value of maximum packet size limit
71 * This function should be used only in UDC drivers to initialize endpoint
72 * (usually in probe function).
74 void usb_ep_set_maxpacket_limit(struct usb_ep *ep,
75 unsigned maxpacket_limit)
77 ep->maxpacket_limit = maxpacket_limit;
78 ep->maxpacket = maxpacket_limit;
80 trace_usb_ep_set_maxpacket_limit(ep, 0);
82 EXPORT_SYMBOL_GPL(usb_ep_set_maxpacket_limit);
85 * usb_ep_enable - configure endpoint, making it usable
86 * @ep:the endpoint being configured. may not be the endpoint named "ep0".
87 * drivers discover endpoints through the ep_list of a usb_gadget.
89 * When configurations are set, or when interface settings change, the driver
90 * will enable or disable the relevant endpoints. while it is enabled, an
91 * endpoint may be used for i/o until the driver receives a disconnect() from
92 * the host or until the endpoint is disabled.
94 * the ep0 implementation (which calls this routine) must ensure that the
95 * hardware capabilities of each endpoint match the descriptor provided
96 * for it. for example, an endpoint named "ep2in-bulk" would be usable
97 * for interrupt transfers as well as bulk, but it likely couldn't be used
98 * for iso transfers or for endpoint 14. some endpoints are fully
99 * configurable, with more generic names like "ep-a". (remember that for
100 * USB, "in" means "towards the USB host".)
102 * This routine may be called in an atomic (interrupt) context.
104 * returns zero, or a negative error code.
106 int usb_ep_enable(struct usb_ep *ep)
113 /* UDC drivers can't handle endpoints with maxpacket size 0 */
114 if (usb_endpoint_maxp(ep->desc) == 0) {
116 * We should log an error message here, but we can't call
117 * dev_err() because there's no way to find the gadget
124 ret = ep->ops->enable(ep, ep->desc);
131 trace_usb_ep_enable(ep, ret);
135 EXPORT_SYMBOL_GPL(usb_ep_enable);
138 * usb_ep_disable - endpoint is no longer usable
139 * @ep:the endpoint being unconfigured. may not be the endpoint named "ep0".
141 * no other task may be using this endpoint when this is called.
142 * any pending and uncompleted requests will complete with status
143 * indicating disconnect (-ESHUTDOWN) before this call returns.
144 * gadget drivers must call usb_ep_enable() again before queueing
145 * requests to the endpoint.
147 * This routine may be called in an atomic (interrupt) context.
149 * returns zero, or a negative error code.
151 int usb_ep_disable(struct usb_ep *ep)
158 ret = ep->ops->disable(ep);
165 trace_usb_ep_disable(ep, ret);
169 EXPORT_SYMBOL_GPL(usb_ep_disable);
172 * usb_ep_alloc_request - allocate a request object to use with this endpoint
173 * @ep:the endpoint to be used with with the request
174 * @gfp_flags:GFP_* flags to use
176 * Request objects must be allocated with this call, since they normally
177 * need controller-specific setup and may even need endpoint-specific
178 * resources such as allocation of DMA descriptors.
179 * Requests may be submitted with usb_ep_queue(), and receive a single
180 * completion callback. Free requests with usb_ep_free_request(), when
181 * they are no longer needed.
183 * Returns the request, or null if one could not be allocated.
185 struct usb_request *usb_ep_alloc_request(struct usb_ep *ep,
188 struct usb_request *req = NULL;
190 req = ep->ops->alloc_request(ep, gfp_flags);
192 trace_usb_ep_alloc_request(ep, req, req ? 0 : -ENOMEM);
196 EXPORT_SYMBOL_GPL(usb_ep_alloc_request);
199 * usb_ep_free_request - frees a request object
200 * @ep:the endpoint associated with the request
201 * @req:the request being freed
203 * Reverses the effect of usb_ep_alloc_request().
204 * Caller guarantees the request is not queued, and that it will
205 * no longer be requeued (or otherwise used).
207 void usb_ep_free_request(struct usb_ep *ep,
208 struct usb_request *req)
210 trace_usb_ep_free_request(ep, req, 0);
211 ep->ops->free_request(ep, req);
213 EXPORT_SYMBOL_GPL(usb_ep_free_request);
216 * usb_ep_queue - queues (submits) an I/O request to an endpoint.
217 * @ep:the endpoint associated with the request
218 * @req:the request being submitted
219 * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
220 * pre-allocate all necessary memory with the request.
222 * This tells the device controller to perform the specified request through
223 * that endpoint (reading or writing a buffer). When the request completes,
224 * including being canceled by usb_ep_dequeue(), the request's completion
225 * routine is called to return the request to the driver. Any endpoint
226 * (except control endpoints like ep0) may have more than one transfer
227 * request queued; they complete in FIFO order. Once a gadget driver
228 * submits a request, that request may not be examined or modified until it
229 * is given back to that driver through the completion callback.
231 * Each request is turned into one or more packets. The controller driver
232 * never merges adjacent requests into the same packet. OUT transfers
233 * will sometimes use data that's already buffered in the hardware.
234 * Drivers can rely on the fact that the first byte of the request's buffer
235 * always corresponds to the first byte of some USB packet, for both
236 * IN and OUT transfers.
238 * Bulk endpoints can queue any amount of data; the transfer is packetized
239 * automatically. The last packet will be short if the request doesn't fill it
240 * out completely. Zero length packets (ZLPs) should be avoided in portable
241 * protocols since not all usb hardware can successfully handle zero length
242 * packets. (ZLPs may be explicitly written, and may be implicitly written if
243 * the request 'zero' flag is set.) Bulk endpoints may also be used
244 * for interrupt transfers; but the reverse is not true, and some endpoints
245 * won't support every interrupt transfer. (Such as 768 byte packets.)
247 * Interrupt-only endpoints are less functional than bulk endpoints, for
248 * example by not supporting queueing or not handling buffers that are
249 * larger than the endpoint's maxpacket size. They may also treat data
250 * toggle differently.
252 * Control endpoints ... after getting a setup() callback, the driver queues
253 * one response (even if it would be zero length). That enables the
254 * status ack, after transferring data as specified in the response. Setup
255 * functions may return negative error codes to generate protocol stalls.
256 * (Note that some USB device controllers disallow protocol stall responses
257 * in some cases.) When control responses are deferred (the response is
258 * written after the setup callback returns), then usb_ep_set_halt() may be
259 * used on ep0 to trigger protocol stalls. Depending on the controller,
260 * it may not be possible to trigger a status-stage protocol stall when the
261 * data stage is over, that is, from within the response's completion
264 * For periodic endpoints, like interrupt or isochronous ones, the usb host
265 * arranges to poll once per interval, and the gadget driver usually will
266 * have queued some data to transfer at that time.
268 * Note that @req's ->complete() callback must never be called from
269 * within usb_ep_queue() as that can create deadlock situations.
271 * This routine may be called in interrupt context.
273 * Returns zero, or a negative error code. Endpoints that are not enabled
274 * report errors; errors will also be
275 * reported when the usb peripheral is disconnected.
277 * If and only if @req is successfully queued (the return value is zero),
278 * @req->complete() will be called exactly once, when the Gadget core and
279 * UDC are finished with the request. When the completion function is called,
280 * control of the request is returned to the device driver which submitted it.
281 * The completion handler may then immediately free or reuse @req.
283 int usb_ep_queue(struct usb_ep *ep,
284 struct usb_request *req, gfp_t gfp_flags)
288 if (WARN_ON_ONCE(!ep->enabled && ep->address)) {
293 ret = ep->ops->queue(ep, req, gfp_flags);
296 trace_usb_ep_queue(ep, req, ret);
300 EXPORT_SYMBOL_GPL(usb_ep_queue);
303 * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
304 * @ep:the endpoint associated with the request
305 * @req:the request being canceled
307 * If the request is still active on the endpoint, it is dequeued and
308 * eventually its completion routine is called (with status -ECONNRESET);
309 * else a negative error code is returned. This routine is asynchronous,
310 * that is, it may return before the completion routine runs.
312 * Note that some hardware can't clear out write fifos (to unlink the request
313 * at the head of the queue) except as part of disconnecting from usb. Such
314 * restrictions prevent drivers from supporting configuration changes,
315 * even to configuration zero (a "chapter 9" requirement).
317 * This routine may be called in interrupt context.
319 int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
323 ret = ep->ops->dequeue(ep, req);
324 trace_usb_ep_dequeue(ep, req, ret);
328 EXPORT_SYMBOL_GPL(usb_ep_dequeue);
331 * usb_ep_set_halt - sets the endpoint halt feature.
332 * @ep: the non-isochronous endpoint being stalled
334 * Use this to stall an endpoint, perhaps as an error report.
335 * Except for control endpoints,
336 * the endpoint stays halted (will not stream any data) until the host
337 * clears this feature; drivers may need to empty the endpoint's request
338 * queue first, to make sure no inappropriate transfers happen.
340 * Note that while an endpoint CLEAR_FEATURE will be invisible to the
341 * gadget driver, a SET_INTERFACE will not be. To reset endpoints for the
342 * current altsetting, see usb_ep_clear_halt(). When switching altsettings,
343 * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
345 * This routine may be called in interrupt context.
347 * Returns zero, or a negative error code. On success, this call sets
348 * underlying hardware state that blocks data transfers.
349 * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
350 * transfer requests are still queued, or if the controller hardware
351 * (usually a FIFO) still holds bytes that the host hasn't collected.
353 int usb_ep_set_halt(struct usb_ep *ep)
357 ret = ep->ops->set_halt(ep, 1);
358 trace_usb_ep_set_halt(ep, ret);
362 EXPORT_SYMBOL_GPL(usb_ep_set_halt);
365 * usb_ep_clear_halt - clears endpoint halt, and resets toggle
366 * @ep:the bulk or interrupt endpoint being reset
368 * Use this when responding to the standard usb "set interface" request,
369 * for endpoints that aren't reconfigured, after clearing any other state
370 * in the endpoint's i/o queue.
372 * This routine may be called in interrupt context.
374 * Returns zero, or a negative error code. On success, this call clears
375 * the underlying hardware state reflecting endpoint halt and data toggle.
376 * Note that some hardware can't support this request (like pxa2xx_udc),
377 * and accordingly can't correctly implement interface altsettings.
379 int usb_ep_clear_halt(struct usb_ep *ep)
383 ret = ep->ops->set_halt(ep, 0);
384 trace_usb_ep_clear_halt(ep, ret);
388 EXPORT_SYMBOL_GPL(usb_ep_clear_halt);
391 * usb_ep_set_wedge - sets the halt feature and ignores clear requests
392 * @ep: the endpoint being wedged
394 * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT)
395 * requests. If the gadget driver clears the halt status, it will
396 * automatically unwedge the endpoint.
398 * This routine may be called in interrupt context.
400 * Returns zero on success, else negative errno.
402 int usb_ep_set_wedge(struct usb_ep *ep)
406 if (ep->ops->set_wedge)
407 ret = ep->ops->set_wedge(ep);
409 ret = ep->ops->set_halt(ep, 1);
411 trace_usb_ep_set_wedge(ep, ret);
415 EXPORT_SYMBOL_GPL(usb_ep_set_wedge);
418 * usb_ep_fifo_status - returns number of bytes in fifo, or error
419 * @ep: the endpoint whose fifo status is being checked.
421 * FIFO endpoints may have "unclaimed data" in them in certain cases,
422 * such as after aborted transfers. Hosts may not have collected all
423 * the IN data written by the gadget driver (and reported by a request
424 * completion). The gadget driver may not have collected all the data
425 * written OUT to it by the host. Drivers that need precise handling for
426 * fault reporting or recovery may need to use this call.
428 * This routine may be called in interrupt context.
430 * This returns the number of such bytes in the fifo, or a negative
431 * errno if the endpoint doesn't use a FIFO or doesn't support such
434 int usb_ep_fifo_status(struct usb_ep *ep)
438 if (ep->ops->fifo_status)
439 ret = ep->ops->fifo_status(ep);
443 trace_usb_ep_fifo_status(ep, ret);
447 EXPORT_SYMBOL_GPL(usb_ep_fifo_status);
450 * usb_ep_fifo_flush - flushes contents of a fifo
451 * @ep: the endpoint whose fifo is being flushed.
453 * This call may be used to flush the "unclaimed data" that may exist in
454 * an endpoint fifo after abnormal transaction terminations. The call
455 * must never be used except when endpoint is not being used for any
456 * protocol translation.
458 * This routine may be called in interrupt context.
460 void usb_ep_fifo_flush(struct usb_ep *ep)
462 if (ep->ops->fifo_flush)
463 ep->ops->fifo_flush(ep);
465 trace_usb_ep_fifo_flush(ep, 0);
467 EXPORT_SYMBOL_GPL(usb_ep_fifo_flush);
469 /* ------------------------------------------------------------------------- */
472 * usb_gadget_frame_number - returns the current frame number
473 * @gadget: controller that reports the frame number
475 * Returns the usb frame number, normally eleven bits from a SOF packet,
476 * or negative errno if this device doesn't support this capability.
478 int usb_gadget_frame_number(struct usb_gadget *gadget)
482 ret = gadget->ops->get_frame(gadget);
484 trace_usb_gadget_frame_number(gadget, ret);
488 EXPORT_SYMBOL_GPL(usb_gadget_frame_number);
491 * usb_gadget_wakeup - tries to wake up the host connected to this gadget
492 * @gadget: controller used to wake up the host
494 * Returns zero on success, else negative error code if the hardware
495 * doesn't support such attempts, or its support has not been enabled
496 * by the usb host. Drivers must return device descriptors that report
497 * their ability to support this, or hosts won't enable it.
499 * This may also try to use SRP to wake the host and start enumeration,
500 * even if OTG isn't otherwise in use. OTG devices may also start
501 * remote wakeup even when hosts don't explicitly enable it.
503 int usb_gadget_wakeup(struct usb_gadget *gadget)
507 if (!gadget->ops->wakeup) {
512 ret = gadget->ops->wakeup(gadget);
515 trace_usb_gadget_wakeup(gadget, ret);
519 EXPORT_SYMBOL_GPL(usb_gadget_wakeup);
522 * usb_gadget_set_remote_wakeup - configures the device remote wakeup feature.
523 * @gadget:the device being configured for remote wakeup
524 * @set:value to be configured.
526 * set to one to enable remote wakeup feature and zero to disable it.
528 * returns zero on success, else negative errno.
530 int usb_gadget_set_remote_wakeup(struct usb_gadget *gadget, int set)
534 if (!gadget->ops->set_remote_wakeup) {
539 ret = gadget->ops->set_remote_wakeup(gadget, set);
542 trace_usb_gadget_set_remote_wakeup(gadget, ret);
546 EXPORT_SYMBOL_GPL(usb_gadget_set_remote_wakeup);
549 * usb_gadget_set_selfpowered - sets the device selfpowered feature.
550 * @gadget:the device being declared as self-powered
552 * this affects the device status reported by the hardware driver
553 * to reflect that it now has a local power supply.
555 * returns zero on success, else negative errno.
557 int usb_gadget_set_selfpowered(struct usb_gadget *gadget)
561 if (!gadget->ops->set_selfpowered) {
566 ret = gadget->ops->set_selfpowered(gadget, 1);
569 trace_usb_gadget_set_selfpowered(gadget, ret);
573 EXPORT_SYMBOL_GPL(usb_gadget_set_selfpowered);
576 * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
577 * @gadget:the device being declared as bus-powered
579 * this affects the device status reported by the hardware driver.
580 * some hardware may not support bus-powered operation, in which
581 * case this feature's value can never change.
583 * returns zero on success, else negative errno.
585 int usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
589 if (!gadget->ops->set_selfpowered) {
594 ret = gadget->ops->set_selfpowered(gadget, 0);
597 trace_usb_gadget_clear_selfpowered(gadget, ret);
601 EXPORT_SYMBOL_GPL(usb_gadget_clear_selfpowered);
604 * usb_gadget_vbus_connect - Notify controller that VBUS is powered
605 * @gadget:The device which now has VBUS power.
608 * This call is used by a driver for an external transceiver (or GPIO)
609 * that detects a VBUS power session starting. Common responses include
610 * resuming the controller, activating the D+ (or D-) pullup to let the
611 * host detect that a USB device is attached, and starting to draw power
612 * (8mA or possibly more, especially after SET_CONFIGURATION).
614 * Returns zero on success, else negative errno.
616 int usb_gadget_vbus_connect(struct usb_gadget *gadget)
620 if (!gadget->ops->vbus_session) {
625 ret = gadget->ops->vbus_session(gadget, 1);
628 trace_usb_gadget_vbus_connect(gadget, ret);
632 EXPORT_SYMBOL_GPL(usb_gadget_vbus_connect);
635 * usb_gadget_vbus_draw - constrain controller's VBUS power usage
636 * @gadget:The device whose VBUS usage is being described
637 * @mA:How much current to draw, in milliAmperes. This should be twice
638 * the value listed in the configuration descriptor bMaxPower field.
640 * This call is used by gadget drivers during SET_CONFIGURATION calls,
641 * reporting how much power the device may consume. For example, this
642 * could affect how quickly batteries are recharged.
644 * Returns zero on success, else negative errno.
646 int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
650 if (!gadget->ops->vbus_draw) {
655 ret = gadget->ops->vbus_draw(gadget, mA);
660 trace_usb_gadget_vbus_draw(gadget, ret);
664 EXPORT_SYMBOL_GPL(usb_gadget_vbus_draw);
667 * usb_gadget_vbus_disconnect - notify controller about VBUS session end
668 * @gadget:the device whose VBUS supply is being described
671 * This call is used by a driver for an external transceiver (or GPIO)
672 * that detects a VBUS power session ending. Common responses include
673 * reversing everything done in usb_gadget_vbus_connect().
675 * Returns zero on success, else negative errno.
677 int usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
681 if (!gadget->ops->vbus_session) {
686 ret = gadget->ops->vbus_session(gadget, 0);
689 trace_usb_gadget_vbus_disconnect(gadget, ret);
693 EXPORT_SYMBOL_GPL(usb_gadget_vbus_disconnect);
695 /* Internal version of usb_gadget_connect needs to be called with connect_lock held. */
696 static int usb_gadget_connect_locked(struct usb_gadget *gadget)
697 __must_hold(&gadget->udc->connect_lock)
701 if (!gadget->ops->pullup) {
706 if (gadget->deactivated || !gadget->udc->started) {
708 * If gadget is deactivated we only save new state.
709 * Gadget will be connected automatically after activation.
711 * udc first needs to be started before gadget can be pulled up.
713 gadget->connected = true;
717 ret = gadget->ops->pullup(gadget, 1);
719 gadget->connected = 1;
722 trace_usb_gadget_connect(gadget, ret);
728 * usb_gadget_connect - software-controlled connect to USB host
729 * @gadget:the peripheral being connected
731 * Enables the D+ (or potentially D-) pullup. The host will start
732 * enumerating this gadget when the pullup is active and a VBUS session
733 * is active (the link is powered).
735 * Returns zero on success, else negative errno.
737 int usb_gadget_connect(struct usb_gadget *gadget)
741 mutex_lock(&gadget->udc->connect_lock);
742 ret = usb_gadget_connect_locked(gadget);
743 mutex_unlock(&gadget->udc->connect_lock);
747 EXPORT_SYMBOL_GPL(usb_gadget_connect);
749 /* Internal version of usb_gadget_disconnect needs to be called with connect_lock held. */
750 static int usb_gadget_disconnect_locked(struct usb_gadget *gadget)
751 __must_hold(&gadget->udc->connect_lock)
755 if (!gadget->ops->pullup) {
760 if (!gadget->connected)
763 if (gadget->deactivated || !gadget->udc->started) {
765 * If gadget is deactivated we only save new state.
766 * Gadget will stay disconnected after activation.
768 * udc should have been started before gadget being pulled down.
770 gadget->connected = false;
774 ret = gadget->ops->pullup(gadget, 0);
776 gadget->connected = 0;
778 mutex_lock(&udc_lock);
779 if (gadget->udc->driver)
780 gadget->udc->driver->disconnect(gadget);
781 mutex_unlock(&udc_lock);
784 trace_usb_gadget_disconnect(gadget, ret);
790 * usb_gadget_disconnect - software-controlled disconnect from USB host
791 * @gadget:the peripheral being disconnected
793 * Disables the D+ (or potentially D-) pullup, which the host may see
794 * as a disconnect (when a VBUS session is active). Not all systems
795 * support software pullup controls.
797 * Following a successful disconnect, invoke the ->disconnect() callback
798 * for the current gadget driver so that UDC drivers don't need to.
800 * Returns zero on success, else negative errno.
802 int usb_gadget_disconnect(struct usb_gadget *gadget)
806 mutex_lock(&gadget->udc->connect_lock);
807 ret = usb_gadget_disconnect_locked(gadget);
808 mutex_unlock(&gadget->udc->connect_lock);
812 EXPORT_SYMBOL_GPL(usb_gadget_disconnect);
815 * usb_gadget_deactivate - deactivate function which is not ready to work
816 * @gadget: the peripheral being deactivated
818 * This routine may be used during the gadget driver bind() call to prevent
819 * the peripheral from ever being visible to the USB host, unless later
820 * usb_gadget_activate() is called. For example, user mode components may
821 * need to be activated before the system can talk to hosts.
823 * Returns zero on success, else negative errno.
825 int usb_gadget_deactivate(struct usb_gadget *gadget)
829 if (gadget->deactivated)
832 mutex_lock(&gadget->udc->connect_lock);
833 if (gadget->connected) {
834 ret = usb_gadget_disconnect_locked(gadget);
839 * If gadget was being connected before deactivation, we want
840 * to reconnect it in usb_gadget_activate().
842 gadget->connected = true;
844 gadget->deactivated = true;
847 mutex_unlock(&gadget->udc->connect_lock);
849 trace_usb_gadget_deactivate(gadget, ret);
853 EXPORT_SYMBOL_GPL(usb_gadget_deactivate);
856 * usb_gadget_activate - activate function which is not ready to work
857 * @gadget: the peripheral being activated
859 * This routine activates gadget which was previously deactivated with
860 * usb_gadget_deactivate() call. It calls usb_gadget_connect() if needed.
862 * Returns zero on success, else negative errno.
864 int usb_gadget_activate(struct usb_gadget *gadget)
868 if (!gadget->deactivated)
871 mutex_lock(&gadget->udc->connect_lock);
872 gadget->deactivated = false;
875 * If gadget has been connected before deactivation, or became connected
876 * while it was being deactivated, we call usb_gadget_connect().
878 if (gadget->connected)
879 ret = usb_gadget_connect_locked(gadget);
880 mutex_unlock(&gadget->udc->connect_lock);
883 trace_usb_gadget_activate(gadget, ret);
887 EXPORT_SYMBOL_GPL(usb_gadget_activate);
889 /* ------------------------------------------------------------------------- */
891 #ifdef CONFIG_HAS_DMA
893 int usb_gadget_map_request_by_dev(struct device *dev,
894 struct usb_request *req, int is_in)
896 if (req->length == 0)
902 mapped = dma_map_sg(dev, req->sg, req->num_sgs,
903 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
905 dev_err(dev, "failed to map SGs\n");
909 req->num_mapped_sgs = mapped;
911 if (is_vmalloc_addr(req->buf)) {
912 dev_err(dev, "buffer is not dma capable\n");
914 } else if (object_is_on_stack(req->buf)) {
915 dev_err(dev, "buffer is on stack\n");
919 req->dma = dma_map_single(dev, req->buf, req->length,
920 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
922 if (dma_mapping_error(dev, req->dma)) {
923 dev_err(dev, "failed to map buffer\n");
932 EXPORT_SYMBOL_GPL(usb_gadget_map_request_by_dev);
934 int usb_gadget_map_request(struct usb_gadget *gadget,
935 struct usb_request *req, int is_in)
937 return usb_gadget_map_request_by_dev(gadget->dev.parent, req, is_in);
939 EXPORT_SYMBOL_GPL(usb_gadget_map_request);
941 void usb_gadget_unmap_request_by_dev(struct device *dev,
942 struct usb_request *req, int is_in)
944 if (req->length == 0)
947 if (req->num_mapped_sgs) {
948 dma_unmap_sg(dev, req->sg, req->num_sgs,
949 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
951 req->num_mapped_sgs = 0;
952 } else if (req->dma_mapped) {
953 dma_unmap_single(dev, req->dma, req->length,
954 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
958 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request_by_dev);
960 void usb_gadget_unmap_request(struct usb_gadget *gadget,
961 struct usb_request *req, int is_in)
963 usb_gadget_unmap_request_by_dev(gadget->dev.parent, req, is_in);
965 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
967 #endif /* CONFIG_HAS_DMA */
969 /* ------------------------------------------------------------------------- */
972 * usb_gadget_giveback_request - give the request back to the gadget layer
973 * @ep: the endpoint to be used with with the request
974 * @req: the request being given back
976 * This is called by device controller drivers in order to return the
977 * completed request back to the gadget layer.
979 void usb_gadget_giveback_request(struct usb_ep *ep,
980 struct usb_request *req)
982 if (likely(req->status == 0))
983 usb_led_activity(USB_LED_EVENT_GADGET);
985 trace_usb_gadget_giveback_request(ep, req, 0);
987 req->complete(ep, req);
989 EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
991 /* ------------------------------------------------------------------------- */
994 * gadget_find_ep_by_name - returns ep whose name is the same as sting passed
995 * in second parameter or NULL if searched endpoint not found
996 * @g: controller to check for quirk
997 * @name: name of searched endpoint
999 struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g, const char *name)
1003 gadget_for_each_ep(ep, g) {
1004 if (!strcmp(ep->name, name))
1010 EXPORT_SYMBOL_GPL(gadget_find_ep_by_name);
1012 /* ------------------------------------------------------------------------- */
1014 int usb_gadget_ep_match_desc(struct usb_gadget *gadget,
1015 struct usb_ep *ep, struct usb_endpoint_descriptor *desc,
1016 struct usb_ss_ep_comp_descriptor *ep_comp)
1020 int num_req_streams = 0;
1022 /* endpoint already claimed? */
1026 type = usb_endpoint_type(desc);
1027 max = usb_endpoint_maxp(desc);
1029 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
1031 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
1034 if (max > ep->maxpacket_limit)
1037 /* "high bandwidth" works only at high speed */
1038 if (!gadget_is_dualspeed(gadget) && usb_endpoint_maxp_mult(desc) > 1)
1042 case USB_ENDPOINT_XFER_CONTROL:
1043 /* only support ep0 for portable CONTROL traffic */
1045 case USB_ENDPOINT_XFER_ISOC:
1046 if (!ep->caps.type_iso)
1048 /* ISO: limit 1023 bytes full speed, 1024 high/super speed */
1049 if (!gadget_is_dualspeed(gadget) && max > 1023)
1052 case USB_ENDPOINT_XFER_BULK:
1053 if (!ep->caps.type_bulk)
1055 if (ep_comp && gadget_is_superspeed(gadget)) {
1056 /* Get the number of required streams from the
1057 * EP companion descriptor and see if the EP
1060 num_req_streams = ep_comp->bmAttributes & 0x1f;
1061 if (num_req_streams > ep->max_streams)
1065 case USB_ENDPOINT_XFER_INT:
1066 /* Bulk endpoints handle interrupt transfers,
1067 * except the toggle-quirky iso-synch kind
1069 if (!ep->caps.type_int && !ep->caps.type_bulk)
1071 /* INT: limit 64 bytes full speed, 1024 high/super speed */
1072 if (!gadget_is_dualspeed(gadget) && max > 64)
1079 EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc);
1082 * usb_gadget_check_config - checks if the UDC can support the binded
1084 * @gadget: controller to check the USB configuration
1086 * Ensure that a UDC is able to support the requested resources by a
1087 * configuration, and that there are no resource limitations, such as
1088 * internal memory allocated to all requested endpoints.
1090 * Returns zero on success, else a negative errno.
1092 int usb_gadget_check_config(struct usb_gadget *gadget)
1094 if (gadget->ops->check_config)
1095 return gadget->ops->check_config(gadget);
1098 EXPORT_SYMBOL_GPL(usb_gadget_check_config);
1100 /* ------------------------------------------------------------------------- */
1102 static void usb_gadget_state_work(struct work_struct *work)
1104 struct usb_gadget *gadget = work_to_gadget(work);
1105 struct usb_udc *udc = gadget->udc;
1108 sysfs_notify(&udc->dev.kobj, NULL, "state");
1111 void usb_gadget_set_state(struct usb_gadget *gadget,
1112 enum usb_device_state state)
1114 gadget->state = state;
1115 schedule_work(&gadget->work);
1117 EXPORT_SYMBOL_GPL(usb_gadget_set_state);
1119 /* ------------------------------------------------------------------------- */
1121 /* Acquire connect_lock before calling this function. */
1122 static void usb_udc_connect_control_locked(struct usb_udc *udc) __must_hold(&udc->connect_lock)
1124 if (udc->vbus && udc->started)
1125 usb_gadget_connect_locked(udc->gadget);
1127 usb_gadget_disconnect_locked(udc->gadget);
1131 * usb_udc_vbus_handler - updates the udc core vbus status, and try to
1132 * connect or disconnect gadget
1133 * @gadget: The gadget which vbus change occurs
1134 * @status: The vbus status
1136 * The udc driver calls it when it wants to connect or disconnect gadget
1137 * according to vbus status.
1139 void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
1141 struct usb_udc *udc = gadget->udc;
1143 mutex_lock(&udc->connect_lock);
1146 usb_udc_connect_control_locked(udc);
1148 mutex_unlock(&udc->connect_lock);
1150 EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
1153 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
1154 * @gadget: The gadget which bus reset occurs
1155 * @driver: The gadget driver we want to notify
1157 * If the udc driver has bus reset handler, it needs to call this when the bus
1158 * reset occurs, it notifies the gadget driver that the bus reset occurs as
1159 * well as updates gadget state.
1161 void usb_gadget_udc_reset(struct usb_gadget *gadget,
1162 struct usb_gadget_driver *driver)
1164 driver->reset(gadget);
1165 usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
1167 EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
1170 * usb_gadget_udc_start_locked - tells usb device controller to start up
1171 * @udc: The UDC to be started
1173 * This call is issued by the UDC Class driver when it's about
1174 * to register a gadget driver to the device controller, before
1175 * calling gadget driver's bind() method.
1177 * It allows the controller to be powered off until strictly
1178 * necessary to have it powered on.
1180 * Returns zero on success, else negative errno.
1182 * Caller should acquire connect_lock before invoking this function.
1184 static inline int usb_gadget_udc_start_locked(struct usb_udc *udc)
1185 __must_hold(&udc->connect_lock)
1190 dev_err(&udc->dev, "UDC had already started\n");
1194 ret = udc->gadget->ops->udc_start(udc->gadget, udc->driver);
1196 udc->started = true;
1202 * usb_gadget_udc_stop_locked - tells usb device controller we don't need it anymore
1203 * @udc: The UDC to be stopped
1205 * This call is issued by the UDC Class driver after calling
1206 * gadget driver's unbind() method.
1208 * The details are implementation specific, but it can go as
1209 * far as powering off UDC completely and disable its data
1212 * Caller should acquire connect lock before invoking this function.
1214 static inline void usb_gadget_udc_stop_locked(struct usb_udc *udc)
1215 __must_hold(&udc->connect_lock)
1217 if (!udc->started) {
1218 dev_err(&udc->dev, "UDC had already stopped\n");
1222 udc->gadget->ops->udc_stop(udc->gadget);
1223 udc->started = false;
1227 * usb_gadget_udc_set_speed - tells usb device controller speed supported by
1229 * @udc: The device we want to set maximum speed
1230 * @speed: The maximum speed to allowed to run
1232 * This call is issued by the UDC Class driver before calling
1233 * usb_gadget_udc_start() in order to make sure that we don't try to
1234 * connect on speeds the gadget driver doesn't support.
1236 static inline void usb_gadget_udc_set_speed(struct usb_udc *udc,
1237 enum usb_device_speed speed)
1239 struct usb_gadget *gadget = udc->gadget;
1240 enum usb_device_speed s;
1242 if (speed == USB_SPEED_UNKNOWN)
1243 s = gadget->max_speed;
1245 s = min(speed, gadget->max_speed);
1247 if (s == USB_SPEED_SUPER_PLUS && gadget->ops->udc_set_ssp_rate)
1248 gadget->ops->udc_set_ssp_rate(gadget, gadget->max_ssp_rate);
1249 else if (gadget->ops->udc_set_speed)
1250 gadget->ops->udc_set_speed(gadget, s);
1254 * usb_gadget_enable_async_callbacks - tell usb device controller to enable asynchronous callbacks
1255 * @udc: The UDC which should enable async callbacks
1257 * This routine is used when binding gadget drivers. It undoes the effect
1258 * of usb_gadget_disable_async_callbacks(); the UDC driver should enable IRQs
1259 * (if necessary) and resume issuing callbacks.
1261 * This routine will always be called in process context.
1263 static inline void usb_gadget_enable_async_callbacks(struct usb_udc *udc)
1265 struct usb_gadget *gadget = udc->gadget;
1267 if (gadget->ops->udc_async_callbacks)
1268 gadget->ops->udc_async_callbacks(gadget, true);
1272 * usb_gadget_disable_async_callbacks - tell usb device controller to disable asynchronous callbacks
1273 * @udc: The UDC which should disable async callbacks
1275 * This routine is used when unbinding gadget drivers. It prevents a race:
1276 * The UDC driver doesn't know when the gadget driver's ->unbind callback
1277 * runs, so unless it is told to disable asynchronous callbacks, it might
1278 * issue a callback (such as ->disconnect) after the unbind has completed.
1280 * After this function runs, the UDC driver must suppress all ->suspend,
1281 * ->resume, ->disconnect, ->reset, and ->setup callbacks to the gadget driver
1282 * until async callbacks are again enabled. A simple-minded but effective
1283 * way to accomplish this is to tell the UDC hardware not to generate any
1286 * Request completion callbacks must still be issued. However, it's okay
1287 * to defer them until the request is cancelled, since the pull-up will be
1288 * turned off during the time period when async callbacks are disabled.
1290 * This routine will always be called in process context.
1292 static inline void usb_gadget_disable_async_callbacks(struct usb_udc *udc)
1294 struct usb_gadget *gadget = udc->gadget;
1296 if (gadget->ops->udc_async_callbacks)
1297 gadget->ops->udc_async_callbacks(gadget, false);
1301 * usb_udc_release - release the usb_udc struct
1302 * @dev: the dev member within usb_udc
1304 * This is called by driver's core in order to free memory once the last
1305 * reference is released.
1307 static void usb_udc_release(struct device *dev)
1309 struct usb_udc *udc;
1311 udc = container_of(dev, struct usb_udc, dev);
1312 dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
1316 static const struct attribute_group *usb_udc_attr_groups[];
1318 static void usb_udc_nop_release(struct device *dev)
1320 dev_vdbg(dev, "%s\n", __func__);
1324 * usb_initialize_gadget - initialize a gadget and its embedded struct device
1325 * @parent: the parent device to this udc. Usually the controller driver's
1327 * @gadget: the gadget to be initialized.
1328 * @release: a gadget release function.
1330 void usb_initialize_gadget(struct device *parent, struct usb_gadget *gadget,
1331 void (*release)(struct device *dev))
1333 INIT_WORK(&gadget->work, usb_gadget_state_work);
1334 gadget->dev.parent = parent;
1337 gadget->dev.release = release;
1339 gadget->dev.release = usb_udc_nop_release;
1341 device_initialize(&gadget->dev);
1342 gadget->dev.bus = &gadget_bus_type;
1344 EXPORT_SYMBOL_GPL(usb_initialize_gadget);
1347 * usb_add_gadget - adds a new gadget to the udc class driver list
1348 * @gadget: the gadget to be added to the list.
1350 * Returns zero on success, negative errno otherwise.
1351 * Does not do a final usb_put_gadget() if an error occurs.
1353 int usb_add_gadget(struct usb_gadget *gadget)
1355 struct usb_udc *udc;
1358 udc = kzalloc(sizeof(*udc), GFP_KERNEL);
1362 device_initialize(&udc->dev);
1363 udc->dev.release = usb_udc_release;
1364 udc->dev.class = udc_class;
1365 udc->dev.groups = usb_udc_attr_groups;
1366 udc->dev.parent = gadget->dev.parent;
1367 ret = dev_set_name(&udc->dev, "%s",
1368 kobject_name(&gadget->dev.parent->kobj));
1372 udc->gadget = gadget;
1374 mutex_init(&udc->connect_lock);
1376 udc->started = false;
1378 mutex_lock(&udc_lock);
1379 list_add_tail(&udc->list, &udc_list);
1380 mutex_unlock(&udc_lock);
1382 ret = device_add(&udc->dev);
1384 goto err_unlist_udc;
1386 usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
1389 ret = ida_alloc(&gadget_id_numbers, GFP_KERNEL);
1392 gadget->id_number = ret;
1393 dev_set_name(&gadget->dev, "gadget.%d", ret);
1395 ret = device_add(&gadget->dev);
1402 ida_free(&gadget_id_numbers, gadget->id_number);
1405 flush_work(&gadget->work);
1406 device_del(&udc->dev);
1409 mutex_lock(&udc_lock);
1410 list_del(&udc->list);
1411 mutex_unlock(&udc_lock);
1414 put_device(&udc->dev);
1419 EXPORT_SYMBOL_GPL(usb_add_gadget);
1422 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
1423 * @parent: the parent device to this udc. Usually the controller driver's
1425 * @gadget: the gadget to be added to the list.
1426 * @release: a gadget release function.
1428 * Returns zero on success, negative errno otherwise.
1429 * Calls the gadget release function in the latter case.
1431 int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
1432 void (*release)(struct device *dev))
1436 usb_initialize_gadget(parent, gadget, release);
1437 ret = usb_add_gadget(gadget);
1439 usb_put_gadget(gadget);
1442 EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
1445 * usb_get_gadget_udc_name - get the name of the first UDC controller
1446 * This functions returns the name of the first UDC controller in the system.
1447 * Please note that this interface is usefull only for legacy drivers which
1448 * assume that there is only one UDC controller in the system and they need to
1449 * get its name before initialization. There is no guarantee that the UDC
1450 * of the returned name will be still available, when gadget driver registers
1453 * Returns pointer to string with UDC controller name on success, NULL
1454 * otherwise. Caller should kfree() returned string.
1456 char *usb_get_gadget_udc_name(void)
1458 struct usb_udc *udc;
1461 /* For now we take the first available UDC */
1462 mutex_lock(&udc_lock);
1463 list_for_each_entry(udc, &udc_list, list) {
1465 name = kstrdup(udc->gadget->name, GFP_KERNEL);
1469 mutex_unlock(&udc_lock);
1472 EXPORT_SYMBOL_GPL(usb_get_gadget_udc_name);
1475 * usb_add_gadget_udc - adds a new gadget to the udc class driver list
1476 * @parent: the parent device to this udc. Usually the controller
1478 * @gadget: the gadget to be added to the list
1480 * Returns zero on success, negative errno otherwise.
1482 int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
1484 return usb_add_gadget_udc_release(parent, gadget, NULL);
1486 EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
1489 * usb_del_gadget - deletes a gadget and unregisters its udc
1490 * @gadget: the gadget to be deleted.
1492 * This will unbind @gadget, if it is bound.
1493 * It will not do a final usb_put_gadget().
1495 void usb_del_gadget(struct usb_gadget *gadget)
1497 struct usb_udc *udc = gadget->udc;
1502 dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
1504 mutex_lock(&udc_lock);
1505 list_del(&udc->list);
1506 mutex_unlock(&udc_lock);
1508 kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
1509 flush_work(&gadget->work);
1510 device_del(&gadget->dev);
1511 ida_free(&gadget_id_numbers, gadget->id_number);
1512 device_unregister(&udc->dev);
1514 EXPORT_SYMBOL_GPL(usb_del_gadget);
1517 * usb_del_gadget_udc - unregisters a gadget
1518 * @gadget: the gadget to be unregistered.
1520 * Calls usb_del_gadget() and does a final usb_put_gadget().
1522 void usb_del_gadget_udc(struct usb_gadget *gadget)
1524 usb_del_gadget(gadget);
1525 usb_put_gadget(gadget);
1527 EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
1529 /* ------------------------------------------------------------------------- */
1531 static int gadget_match_driver(struct device *dev, struct device_driver *drv)
1533 struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1534 struct usb_udc *udc = gadget->udc;
1535 struct usb_gadget_driver *driver = container_of(drv,
1536 struct usb_gadget_driver, driver);
1538 /* If the driver specifies a udc_name, it must match the UDC's name */
1539 if (driver->udc_name &&
1540 strcmp(driver->udc_name, dev_name(&udc->dev)) != 0)
1543 /* If the driver is already bound to a gadget, it doesn't match */
1544 if (driver->is_bound)
1547 /* Otherwise any gadget driver matches any UDC */
1551 static int gadget_bind_driver(struct device *dev)
1553 struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1554 struct usb_udc *udc = gadget->udc;
1555 struct usb_gadget_driver *driver = container_of(dev->driver,
1556 struct usb_gadget_driver, driver);
1559 mutex_lock(&udc_lock);
1560 if (driver->is_bound) {
1561 mutex_unlock(&udc_lock);
1562 return -ENXIO; /* Driver binds to only one gadget */
1564 driver->is_bound = true;
1565 udc->driver = driver;
1566 mutex_unlock(&udc_lock);
1568 dev_dbg(&udc->dev, "binding gadget driver [%s]\n", driver->function);
1570 usb_gadget_udc_set_speed(udc, driver->max_speed);
1572 ret = driver->bind(udc->gadget, driver);
1576 mutex_lock(&udc->connect_lock);
1577 ret = usb_gadget_udc_start_locked(udc);
1579 mutex_unlock(&udc->connect_lock);
1582 usb_gadget_enable_async_callbacks(udc);
1583 usb_udc_connect_control_locked(udc);
1584 mutex_unlock(&udc->connect_lock);
1586 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
1590 driver->unbind(udc->gadget);
1594 dev_err(&udc->dev, "failed to start %s: %d\n",
1595 driver->function, ret);
1597 mutex_lock(&udc_lock);
1599 driver->is_bound = false;
1600 mutex_unlock(&udc_lock);
1605 static void gadget_unbind_driver(struct device *dev)
1607 struct usb_gadget *gadget = dev_to_usb_gadget(dev);
1608 struct usb_udc *udc = gadget->udc;
1609 struct usb_gadget_driver *driver = udc->driver;
1611 dev_dbg(&udc->dev, "unbinding gadget driver [%s]\n", driver->function);
1613 kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
1615 mutex_lock(&udc->connect_lock);
1616 usb_gadget_disconnect_locked(gadget);
1617 usb_gadget_disable_async_callbacks(udc);
1619 synchronize_irq(gadget->irq);
1620 udc->driver->unbind(gadget);
1621 usb_gadget_udc_stop_locked(udc);
1622 mutex_unlock(&udc->connect_lock);
1624 mutex_lock(&udc_lock);
1625 driver->is_bound = false;
1627 mutex_unlock(&udc_lock);
1630 /* ------------------------------------------------------------------------- */
1632 int usb_gadget_register_driver_owner(struct usb_gadget_driver *driver,
1633 struct module *owner, const char *mod_name)
1637 if (!driver || !driver->bind || !driver->setup)
1640 driver->driver.bus = &gadget_bus_type;
1641 driver->driver.owner = owner;
1642 driver->driver.mod_name = mod_name;
1643 ret = driver_register(&driver->driver);
1645 pr_warn("%s: driver registration failed: %d\n",
1646 driver->function, ret);
1650 mutex_lock(&udc_lock);
1651 if (!driver->is_bound) {
1652 if (driver->match_existing_only) {
1653 pr_warn("%s: couldn't find an available UDC or it's busy\n",
1657 pr_info("%s: couldn't find an available UDC\n",
1662 mutex_unlock(&udc_lock);
1665 driver_unregister(&driver->driver);
1668 EXPORT_SYMBOL_GPL(usb_gadget_register_driver_owner);
1670 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1672 if (!driver || !driver->unbind)
1675 driver_unregister(&driver->driver);
1678 EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
1680 /* ------------------------------------------------------------------------- */
1682 static ssize_t srp_store(struct device *dev,
1683 struct device_attribute *attr, const char *buf, size_t n)
1685 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1687 if (sysfs_streq(buf, "1"))
1688 usb_gadget_wakeup(udc->gadget);
1692 static DEVICE_ATTR_WO(srp);
1694 static ssize_t soft_connect_store(struct device *dev,
1695 struct device_attribute *attr, const char *buf, size_t n)
1697 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1700 device_lock(&udc->gadget->dev);
1702 dev_err(dev, "soft-connect without a gadget driver\n");
1707 if (sysfs_streq(buf, "connect")) {
1708 mutex_lock(&udc->connect_lock);
1709 usb_gadget_udc_start_locked(udc);
1710 usb_gadget_connect_locked(udc->gadget);
1711 mutex_unlock(&udc->connect_lock);
1712 } else if (sysfs_streq(buf, "disconnect")) {
1713 mutex_lock(&udc->connect_lock);
1714 usb_gadget_disconnect_locked(udc->gadget);
1715 usb_gadget_udc_stop_locked(udc);
1716 mutex_unlock(&udc->connect_lock);
1718 dev_err(dev, "unsupported command '%s'\n", buf);
1725 device_unlock(&udc->gadget->dev);
1728 static DEVICE_ATTR_WO(soft_connect);
1730 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
1733 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1734 struct usb_gadget *gadget = udc->gadget;
1736 return sprintf(buf, "%s\n", usb_state_string(gadget->state));
1738 static DEVICE_ATTR_RO(state);
1740 static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1743 struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1744 struct usb_gadget_driver *drv;
1747 mutex_lock(&udc_lock);
1749 if (drv && drv->function)
1750 rc = scnprintf(buf, PAGE_SIZE, "%s\n", drv->function);
1751 mutex_unlock(&udc_lock);
1754 static DEVICE_ATTR_RO(function);
1756 #define USB_UDC_SPEED_ATTR(name, param) \
1757 ssize_t name##_show(struct device *dev, \
1758 struct device_attribute *attr, char *buf) \
1760 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
1761 return scnprintf(buf, PAGE_SIZE, "%s\n", \
1762 usb_speed_string(udc->gadget->param)); \
1764 static DEVICE_ATTR_RO(name)
1766 static USB_UDC_SPEED_ATTR(current_speed, speed);
1767 static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
1769 #define USB_UDC_ATTR(name) \
1770 ssize_t name##_show(struct device *dev, \
1771 struct device_attribute *attr, char *buf) \
1773 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
1774 struct usb_gadget *gadget = udc->gadget; \
1776 return scnprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
1778 static DEVICE_ATTR_RO(name)
1780 static USB_UDC_ATTR(is_otg);
1781 static USB_UDC_ATTR(is_a_peripheral);
1782 static USB_UDC_ATTR(b_hnp_enable);
1783 static USB_UDC_ATTR(a_hnp_support);
1784 static USB_UDC_ATTR(a_alt_hnp_support);
1785 static USB_UDC_ATTR(is_selfpowered);
1787 static struct attribute *usb_udc_attrs[] = {
1789 &dev_attr_soft_connect.attr,
1790 &dev_attr_state.attr,
1791 &dev_attr_function.attr,
1792 &dev_attr_current_speed.attr,
1793 &dev_attr_maximum_speed.attr,
1795 &dev_attr_is_otg.attr,
1796 &dev_attr_is_a_peripheral.attr,
1797 &dev_attr_b_hnp_enable.attr,
1798 &dev_attr_a_hnp_support.attr,
1799 &dev_attr_a_alt_hnp_support.attr,
1800 &dev_attr_is_selfpowered.attr,
1804 static const struct attribute_group usb_udc_attr_group = {
1805 .attrs = usb_udc_attrs,
1808 static const struct attribute_group *usb_udc_attr_groups[] = {
1809 &usb_udc_attr_group,
1813 static int usb_udc_uevent(const struct device *dev, struct kobj_uevent_env *env)
1815 const struct usb_udc *udc = container_of(dev, struct usb_udc, dev);
1818 ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
1820 dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
1824 mutex_lock(&udc_lock);
1826 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
1827 udc->driver->function);
1828 mutex_unlock(&udc_lock);
1830 dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
1837 static const struct bus_type gadget_bus_type = {
1839 .probe = gadget_bind_driver,
1840 .remove = gadget_unbind_driver,
1841 .match = gadget_match_driver,
1844 static int __init usb_udc_init(void)
1848 udc_class = class_create("udc");
1849 if (IS_ERR(udc_class)) {
1850 pr_err("failed to create udc class --> %ld\n",
1851 PTR_ERR(udc_class));
1852 return PTR_ERR(udc_class);
1855 udc_class->dev_uevent = usb_udc_uevent;
1857 rc = bus_register(&gadget_bus_type);
1859 class_destroy(udc_class);
1862 subsys_initcall(usb_udc_init);
1864 static void __exit usb_udc_exit(void)
1866 bus_unregister(&gadget_bus_type);
1867 class_destroy(udc_class);
1869 module_exit(usb_udc_exit);
1871 MODULE_DESCRIPTION("UDC Framework");
1872 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
1873 MODULE_LICENSE("GPL v2");