2 * udc.c - Core UDC Framework
4 * Copyright (C) 2010 Texas Instruments
5 * Author: Felipe Balbi <balbi@ti.com>
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.
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.
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/>.
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>
28 #include <linux/usb/ch9.h>
29 #include <linux/usb/gadget.h>
30 #include <linux/usb.h>
35 * struct usb_udc - describes one usb device controller
36 * @driver - the gadget driver pointer. For use by the class code
37 * @dev - the child device to the actual controller
38 * @gadget - the gadget. For use by the class code
39 * @list - for use by the udc class driver
40 * @vbus - for udcs who care about vbus status, this value is real vbus status;
41 * for udcs who do not care about vbus status, this value is always true
43 * This represents the internal data structure which is used by the UDC-class
44 * to hold information about udc driver and gadget together.
47 struct usb_gadget_driver
*driver
;
48 struct usb_gadget
*gadget
;
50 struct list_head list
;
54 static struct class *udc_class
;
55 static LIST_HEAD(udc_list
);
56 static LIST_HEAD(gadget_driver_pending_list
);
57 static DEFINE_MUTEX(udc_lock
);
59 static int udc_bind_to_driver(struct usb_udc
*udc
,
60 struct usb_gadget_driver
*driver
);
62 /* ------------------------------------------------------------------------- */
65 * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
66 * @ep:the endpoint being configured
67 * @maxpacket_limit:value of maximum packet size limit
69 * This function should be used only in UDC drivers to initialize endpoint
70 * (usually in probe function).
72 void usb_ep_set_maxpacket_limit(struct usb_ep
*ep
,
73 unsigned maxpacket_limit
)
75 ep
->maxpacket_limit
= maxpacket_limit
;
76 ep
->maxpacket
= maxpacket_limit
;
78 trace_usb_ep_set_maxpacket_limit(ep
, 0);
80 EXPORT_SYMBOL_GPL(usb_ep_set_maxpacket_limit
);
83 * usb_ep_enable - configure endpoint, making it usable
84 * @ep:the endpoint being configured. may not be the endpoint named "ep0".
85 * drivers discover endpoints through the ep_list of a usb_gadget.
87 * When configurations are set, or when interface settings change, the driver
88 * will enable or disable the relevant endpoints. while it is enabled, an
89 * endpoint may be used for i/o until the driver receives a disconnect() from
90 * the host or until the endpoint is disabled.
92 * the ep0 implementation (which calls this routine) must ensure that the
93 * hardware capabilities of each endpoint match the descriptor provided
94 * for it. for example, an endpoint named "ep2in-bulk" would be usable
95 * for interrupt transfers as well as bulk, but it likely couldn't be used
96 * for iso transfers or for endpoint 14. some endpoints are fully
97 * configurable, with more generic names like "ep-a". (remember that for
98 * USB, "in" means "towards the USB master".)
100 * returns zero, or a negative error code.
102 int usb_ep_enable(struct usb_ep
*ep
)
109 ret
= ep
->ops
->enable(ep
, ep
->desc
);
118 trace_usb_ep_enable(ep
, ret
);
122 EXPORT_SYMBOL_GPL(usb_ep_enable
);
125 * usb_ep_disable - endpoint is no longer usable
126 * @ep:the endpoint being unconfigured. may not be the endpoint named "ep0".
128 * no other task may be using this endpoint when this is called.
129 * any pending and uncompleted requests will complete with status
130 * indicating disconnect (-ESHUTDOWN) before this call returns.
131 * gadget drivers must call usb_ep_enable() again before queueing
132 * requests to the endpoint.
134 * returns zero, or a negative error code.
136 int usb_ep_disable(struct usb_ep
*ep
)
143 ret
= ep
->ops
->disable(ep
);
152 trace_usb_ep_disable(ep
, ret
);
156 EXPORT_SYMBOL_GPL(usb_ep_disable
);
159 * usb_ep_alloc_request - allocate a request object to use with this endpoint
160 * @ep:the endpoint to be used with with the request
161 * @gfp_flags:GFP_* flags to use
163 * Request objects must be allocated with this call, since they normally
164 * need controller-specific setup and may even need endpoint-specific
165 * resources such as allocation of DMA descriptors.
166 * Requests may be submitted with usb_ep_queue(), and receive a single
167 * completion callback. Free requests with usb_ep_free_request(), when
168 * they are no longer needed.
170 * Returns the request, or null if one could not be allocated.
172 struct usb_request
*usb_ep_alloc_request(struct usb_ep
*ep
,
175 struct usb_request
*req
= NULL
;
177 req
= ep
->ops
->alloc_request(ep
, gfp_flags
);
179 trace_usb_ep_alloc_request(ep
, req
, req
? 0 : -ENOMEM
);
183 EXPORT_SYMBOL_GPL(usb_ep_alloc_request
);
186 * usb_ep_free_request - frees a request object
187 * @ep:the endpoint associated with the request
188 * @req:the request being freed
190 * Reverses the effect of usb_ep_alloc_request().
191 * Caller guarantees the request is not queued, and that it will
192 * no longer be requeued (or otherwise used).
194 void usb_ep_free_request(struct usb_ep
*ep
,
195 struct usb_request
*req
)
197 ep
->ops
->free_request(ep
, req
);
198 trace_usb_ep_free_request(ep
, req
, 0);
200 EXPORT_SYMBOL_GPL(usb_ep_free_request
);
203 * usb_ep_queue - queues (submits) an I/O request to an endpoint.
204 * @ep:the endpoint associated with the request
205 * @req:the request being submitted
206 * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
207 * pre-allocate all necessary memory with the request.
209 * This tells the device controller to perform the specified request through
210 * that endpoint (reading or writing a buffer). When the request completes,
211 * including being canceled by usb_ep_dequeue(), the request's completion
212 * routine is called to return the request to the driver. Any endpoint
213 * (except control endpoints like ep0) may have more than one transfer
214 * request queued; they complete in FIFO order. Once a gadget driver
215 * submits a request, that request may not be examined or modified until it
216 * is given back to that driver through the completion callback.
218 * Each request is turned into one or more packets. The controller driver
219 * never merges adjacent requests into the same packet. OUT transfers
220 * will sometimes use data that's already buffered in the hardware.
221 * Drivers can rely on the fact that the first byte of the request's buffer
222 * always corresponds to the first byte of some USB packet, for both
223 * IN and OUT transfers.
225 * Bulk endpoints can queue any amount of data; the transfer is packetized
226 * automatically. The last packet will be short if the request doesn't fill it
227 * out completely. Zero length packets (ZLPs) should be avoided in portable
228 * protocols since not all usb hardware can successfully handle zero length
229 * packets. (ZLPs may be explicitly written, and may be implicitly written if
230 * the request 'zero' flag is set.) Bulk endpoints may also be used
231 * for interrupt transfers; but the reverse is not true, and some endpoints
232 * won't support every interrupt transfer. (Such as 768 byte packets.)
234 * Interrupt-only endpoints are less functional than bulk endpoints, for
235 * example by not supporting queueing or not handling buffers that are
236 * larger than the endpoint's maxpacket size. They may also treat data
237 * toggle differently.
239 * Control endpoints ... after getting a setup() callback, the driver queues
240 * one response (even if it would be zero length). That enables the
241 * status ack, after transferring data as specified in the response. Setup
242 * functions may return negative error codes to generate protocol stalls.
243 * (Note that some USB device controllers disallow protocol stall responses
244 * in some cases.) When control responses are deferred (the response is
245 * written after the setup callback returns), then usb_ep_set_halt() may be
246 * used on ep0 to trigger protocol stalls. Depending on the controller,
247 * it may not be possible to trigger a status-stage protocol stall when the
248 * data stage is over, that is, from within the response's completion
251 * For periodic endpoints, like interrupt or isochronous ones, the usb host
252 * arranges to poll once per interval, and the gadget driver usually will
253 * have queued some data to transfer at that time.
255 * Returns zero, or a negative error code. Endpoints that are not enabled
256 * report errors; errors will also be
257 * reported when the usb peripheral is disconnected.
259 int usb_ep_queue(struct usb_ep
*ep
,
260 struct usb_request
*req
, gfp_t gfp_flags
)
264 if (WARN_ON_ONCE(!ep
->enabled
&& ep
->address
)) {
269 ret
= ep
->ops
->queue(ep
, req
, gfp_flags
);
272 trace_usb_ep_queue(ep
, req
, ret
);
276 EXPORT_SYMBOL_GPL(usb_ep_queue
);
279 * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
280 * @ep:the endpoint associated with the request
281 * @req:the request being canceled
283 * If the request is still active on the endpoint, it is dequeued and its
284 * completion routine is called (with status -ECONNRESET); else a negative
285 * error code is returned. This is guaranteed to happen before the call to
286 * usb_ep_dequeue() returns.
288 * Note that some hardware can't clear out write fifos (to unlink the request
289 * at the head of the queue) except as part of disconnecting from usb. Such
290 * restrictions prevent drivers from supporting configuration changes,
291 * even to configuration zero (a "chapter 9" requirement).
293 int usb_ep_dequeue(struct usb_ep
*ep
, struct usb_request
*req
)
297 ret
= ep
->ops
->dequeue(ep
, req
);
298 trace_usb_ep_dequeue(ep
, req
, ret
);
302 EXPORT_SYMBOL_GPL(usb_ep_dequeue
);
305 * usb_ep_set_halt - sets the endpoint halt feature.
306 * @ep: the non-isochronous endpoint being stalled
308 * Use this to stall an endpoint, perhaps as an error report.
309 * Except for control endpoints,
310 * the endpoint stays halted (will not stream any data) until the host
311 * clears this feature; drivers may need to empty the endpoint's request
312 * queue first, to make sure no inappropriate transfers happen.
314 * Note that while an endpoint CLEAR_FEATURE will be invisible to the
315 * gadget driver, a SET_INTERFACE will not be. To reset endpoints for the
316 * current altsetting, see usb_ep_clear_halt(). When switching altsettings,
317 * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
319 * Returns zero, or a negative error code. On success, this call sets
320 * underlying hardware state that blocks data transfers.
321 * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
322 * transfer requests are still queued, or if the controller hardware
323 * (usually a FIFO) still holds bytes that the host hasn't collected.
325 int usb_ep_set_halt(struct usb_ep
*ep
)
329 ret
= ep
->ops
->set_halt(ep
, 1);
330 trace_usb_ep_set_halt(ep
, ret
);
334 EXPORT_SYMBOL_GPL(usb_ep_set_halt
);
337 * usb_ep_clear_halt - clears endpoint halt, and resets toggle
338 * @ep:the bulk or interrupt endpoint being reset
340 * Use this when responding to the standard usb "set interface" request,
341 * for endpoints that aren't reconfigured, after clearing any other state
342 * in the endpoint's i/o queue.
344 * Returns zero, or a negative error code. On success, this call clears
345 * the underlying hardware state reflecting endpoint halt and data toggle.
346 * Note that some hardware can't support this request (like pxa2xx_udc),
347 * and accordingly can't correctly implement interface altsettings.
349 int usb_ep_clear_halt(struct usb_ep
*ep
)
353 ret
= ep
->ops
->set_halt(ep
, 0);
354 trace_usb_ep_clear_halt(ep
, ret
);
358 EXPORT_SYMBOL_GPL(usb_ep_clear_halt
);
361 * usb_ep_set_wedge - sets the halt feature and ignores clear requests
362 * @ep: the endpoint being wedged
364 * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT)
365 * requests. If the gadget driver clears the halt status, it will
366 * automatically unwedge the endpoint.
368 * Returns zero on success, else negative errno.
370 int usb_ep_set_wedge(struct usb_ep
*ep
)
374 if (ep
->ops
->set_wedge
)
375 ret
= ep
->ops
->set_wedge(ep
);
377 ret
= ep
->ops
->set_halt(ep
, 1);
379 trace_usb_ep_set_wedge(ep
, ret
);
383 EXPORT_SYMBOL_GPL(usb_ep_set_wedge
);
386 * usb_ep_fifo_status - returns number of bytes in fifo, or error
387 * @ep: the endpoint whose fifo status is being checked.
389 * FIFO endpoints may have "unclaimed data" in them in certain cases,
390 * such as after aborted transfers. Hosts may not have collected all
391 * the IN data written by the gadget driver (and reported by a request
392 * completion). The gadget driver may not have collected all the data
393 * written OUT to it by the host. Drivers that need precise handling for
394 * fault reporting or recovery may need to use this call.
396 * This returns the number of such bytes in the fifo, or a negative
397 * errno if the endpoint doesn't use a FIFO or doesn't support such
400 int usb_ep_fifo_status(struct usb_ep
*ep
)
404 if (ep
->ops
->fifo_status
)
405 ret
= ep
->ops
->fifo_status(ep
);
409 trace_usb_ep_fifo_status(ep
, ret
);
413 EXPORT_SYMBOL_GPL(usb_ep_fifo_status
);
416 * usb_ep_fifo_flush - flushes contents of a fifo
417 * @ep: the endpoint whose fifo is being flushed.
419 * This call may be used to flush the "unclaimed data" that may exist in
420 * an endpoint fifo after abnormal transaction terminations. The call
421 * must never be used except when endpoint is not being used for any
422 * protocol translation.
424 void usb_ep_fifo_flush(struct usb_ep
*ep
)
426 if (ep
->ops
->fifo_flush
)
427 ep
->ops
->fifo_flush(ep
);
429 trace_usb_ep_fifo_flush(ep
, 0);
431 EXPORT_SYMBOL_GPL(usb_ep_fifo_flush
);
433 /* ------------------------------------------------------------------------- */
436 * usb_gadget_frame_number - returns the current frame number
437 * @gadget: controller that reports the frame number
439 * Returns the usb frame number, normally eleven bits from a SOF packet,
440 * or negative errno if this device doesn't support this capability.
442 int usb_gadget_frame_number(struct usb_gadget
*gadget
)
446 ret
= gadget
->ops
->get_frame(gadget
);
448 trace_usb_gadget_frame_number(gadget
, ret
);
452 EXPORT_SYMBOL_GPL(usb_gadget_frame_number
);
455 * usb_gadget_wakeup - tries to wake up the host connected to this gadget
456 * @gadget: controller used to wake up the host
458 * Returns zero on success, else negative error code if the hardware
459 * doesn't support such attempts, or its support has not been enabled
460 * by the usb host. Drivers must return device descriptors that report
461 * their ability to support this, or hosts won't enable it.
463 * This may also try to use SRP to wake the host and start enumeration,
464 * even if OTG isn't otherwise in use. OTG devices may also start
465 * remote wakeup even when hosts don't explicitly enable it.
467 int usb_gadget_wakeup(struct usb_gadget
*gadget
)
471 if (!gadget
->ops
->wakeup
) {
476 ret
= gadget
->ops
->wakeup(gadget
);
479 trace_usb_gadget_wakeup(gadget
, ret
);
483 EXPORT_SYMBOL_GPL(usb_gadget_wakeup
);
486 * usb_gadget_set_selfpowered - sets the device selfpowered feature.
487 * @gadget:the device being declared as self-powered
489 * this affects the device status reported by the hardware driver
490 * to reflect that it now has a local power supply.
492 * returns zero on success, else negative errno.
494 int usb_gadget_set_selfpowered(struct usb_gadget
*gadget
)
498 if (!gadget
->ops
->set_selfpowered
) {
503 ret
= gadget
->ops
->set_selfpowered(gadget
, 1);
506 trace_usb_gadget_set_selfpowered(gadget
, ret
);
510 EXPORT_SYMBOL_GPL(usb_gadget_set_selfpowered
);
513 * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
514 * @gadget:the device being declared as bus-powered
516 * this affects the device status reported by the hardware driver.
517 * some hardware may not support bus-powered operation, in which
518 * case this feature's value can never change.
520 * returns zero on success, else negative errno.
522 int usb_gadget_clear_selfpowered(struct usb_gadget
*gadget
)
526 if (!gadget
->ops
->set_selfpowered
) {
531 ret
= gadget
->ops
->set_selfpowered(gadget
, 0);
534 trace_usb_gadget_clear_selfpowered(gadget
, ret
);
538 EXPORT_SYMBOL_GPL(usb_gadget_clear_selfpowered
);
541 * usb_gadget_vbus_connect - Notify controller that VBUS is powered
542 * @gadget:The device which now has VBUS power.
545 * This call is used by a driver for an external transceiver (or GPIO)
546 * that detects a VBUS power session starting. Common responses include
547 * resuming the controller, activating the D+ (or D-) pullup to let the
548 * host detect that a USB device is attached, and starting to draw power
549 * (8mA or possibly more, especially after SET_CONFIGURATION).
551 * Returns zero on success, else negative errno.
553 int usb_gadget_vbus_connect(struct usb_gadget
*gadget
)
557 if (!gadget
->ops
->vbus_session
) {
562 ret
= gadget
->ops
->vbus_session(gadget
, 1);
565 trace_usb_gadget_vbus_connect(gadget
, ret
);
569 EXPORT_SYMBOL_GPL(usb_gadget_vbus_connect
);
572 * usb_gadget_vbus_draw - constrain controller's VBUS power usage
573 * @gadget:The device whose VBUS usage is being described
574 * @mA:How much current to draw, in milliAmperes. This should be twice
575 * the value listed in the configuration descriptor bMaxPower field.
577 * This call is used by gadget drivers during SET_CONFIGURATION calls,
578 * reporting how much power the device may consume. For example, this
579 * could affect how quickly batteries are recharged.
581 * Returns zero on success, else negative errno.
583 int usb_gadget_vbus_draw(struct usb_gadget
*gadget
, unsigned mA
)
587 if (!gadget
->ops
->vbus_draw
) {
592 ret
= gadget
->ops
->vbus_draw(gadget
, mA
);
597 trace_usb_gadget_vbus_draw(gadget
, ret
);
601 EXPORT_SYMBOL_GPL(usb_gadget_vbus_draw
);
604 * usb_gadget_vbus_disconnect - notify controller about VBUS session end
605 * @gadget:the device whose VBUS supply is being described
608 * This call is used by a driver for an external transceiver (or GPIO)
609 * that detects a VBUS power session ending. Common responses include
610 * reversing everything done in usb_gadget_vbus_connect().
612 * Returns zero on success, else negative errno.
614 int usb_gadget_vbus_disconnect(struct usb_gadget
*gadget
)
618 if (!gadget
->ops
->vbus_session
) {
623 ret
= gadget
->ops
->vbus_session(gadget
, 0);
626 trace_usb_gadget_vbus_disconnect(gadget
, ret
);
630 EXPORT_SYMBOL_GPL(usb_gadget_vbus_disconnect
);
633 * usb_gadget_connect - software-controlled connect to USB host
634 * @gadget:the peripheral being connected
636 * Enables the D+ (or potentially D-) pullup. The host will start
637 * enumerating this gadget when the pullup is active and a VBUS session
638 * is active (the link is powered). This pullup is always enabled unless
639 * usb_gadget_disconnect() has been used to disable it.
641 * Returns zero on success, else negative errno.
643 int usb_gadget_connect(struct usb_gadget
*gadget
)
647 if (!gadget
->ops
->pullup
) {
652 if (gadget
->deactivated
) {
654 * If gadget is deactivated we only save new state.
655 * Gadget will be connected automatically after activation.
657 gadget
->connected
= true;
661 ret
= gadget
->ops
->pullup(gadget
, 1);
663 gadget
->connected
= 1;
666 trace_usb_gadget_connect(gadget
, ret
);
670 EXPORT_SYMBOL_GPL(usb_gadget_connect
);
673 * usb_gadget_disconnect - software-controlled disconnect from USB host
674 * @gadget:the peripheral being disconnected
676 * Disables the D+ (or potentially D-) pullup, which the host may see
677 * as a disconnect (when a VBUS session is active). Not all systems
678 * support software pullup controls.
680 * Returns zero on success, else negative errno.
682 int usb_gadget_disconnect(struct usb_gadget
*gadget
)
686 if (!gadget
->ops
->pullup
) {
691 if (gadget
->deactivated
) {
693 * If gadget is deactivated we only save new state.
694 * Gadget will stay disconnected after activation.
696 gadget
->connected
= false;
700 ret
= gadget
->ops
->pullup(gadget
, 0);
702 gadget
->connected
= 0;
705 trace_usb_gadget_disconnect(gadget
, ret
);
709 EXPORT_SYMBOL_GPL(usb_gadget_disconnect
);
712 * usb_gadget_deactivate - deactivate function which is not ready to work
713 * @gadget: the peripheral being deactivated
715 * This routine may be used during the gadget driver bind() call to prevent
716 * the peripheral from ever being visible to the USB host, unless later
717 * usb_gadget_activate() is called. For example, user mode components may
718 * need to be activated before the system can talk to hosts.
720 * Returns zero on success, else negative errno.
722 int usb_gadget_deactivate(struct usb_gadget
*gadget
)
726 if (gadget
->deactivated
)
729 if (gadget
->connected
) {
730 ret
= usb_gadget_disconnect(gadget
);
735 * If gadget was being connected before deactivation, we want
736 * to reconnect it in usb_gadget_activate().
738 gadget
->connected
= true;
740 gadget
->deactivated
= true;
743 trace_usb_gadget_deactivate(gadget
, ret
);
747 EXPORT_SYMBOL_GPL(usb_gadget_deactivate
);
750 * usb_gadget_activate - activate function which is not ready to work
751 * @gadget: the peripheral being activated
753 * This routine activates gadget which was previously deactivated with
754 * usb_gadget_deactivate() call. It calls usb_gadget_connect() if needed.
756 * Returns zero on success, else negative errno.
758 int usb_gadget_activate(struct usb_gadget
*gadget
)
762 if (!gadget
->deactivated
)
765 gadget
->deactivated
= false;
768 * If gadget has been connected before deactivation, or became connected
769 * while it was being deactivated, we call usb_gadget_connect().
771 if (gadget
->connected
)
772 ret
= usb_gadget_connect(gadget
);
775 trace_usb_gadget_activate(gadget
, ret
);
779 EXPORT_SYMBOL_GPL(usb_gadget_activate
);
781 /* ------------------------------------------------------------------------- */
783 #ifdef CONFIG_HAS_DMA
785 int usb_gadget_map_request_by_dev(struct device
*dev
,
786 struct usb_request
*req
, int is_in
)
788 if (req
->length
== 0)
794 mapped
= dma_map_sg(dev
, req
->sg
, req
->num_sgs
,
795 is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
797 dev_err(dev
, "failed to map SGs\n");
801 req
->num_mapped_sgs
= mapped
;
803 req
->dma
= dma_map_single(dev
, req
->buf
, req
->length
,
804 is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
806 if (dma_mapping_error(dev
, req
->dma
)) {
807 dev_err(dev
, "failed to map buffer\n");
814 EXPORT_SYMBOL_GPL(usb_gadget_map_request_by_dev
);
816 int usb_gadget_map_request(struct usb_gadget
*gadget
,
817 struct usb_request
*req
, int is_in
)
819 return usb_gadget_map_request_by_dev(gadget
->dev
.parent
, req
, is_in
);
821 EXPORT_SYMBOL_GPL(usb_gadget_map_request
);
823 void usb_gadget_unmap_request_by_dev(struct device
*dev
,
824 struct usb_request
*req
, int is_in
)
826 if (req
->length
== 0)
829 if (req
->num_mapped_sgs
) {
830 dma_unmap_sg(dev
, req
->sg
, req
->num_sgs
,
831 is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
833 req
->num_mapped_sgs
= 0;
835 dma_unmap_single(dev
, req
->dma
, req
->length
,
836 is_in
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
839 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request_by_dev
);
841 void usb_gadget_unmap_request(struct usb_gadget
*gadget
,
842 struct usb_request
*req
, int is_in
)
844 usb_gadget_unmap_request_by_dev(gadget
->dev
.parent
, req
, is_in
);
846 EXPORT_SYMBOL_GPL(usb_gadget_unmap_request
);
848 #endif /* CONFIG_HAS_DMA */
850 /* ------------------------------------------------------------------------- */
853 * usb_gadget_giveback_request - give the request back to the gadget layer
854 * Context: in_interrupt()
856 * This is called by device controller drivers in order to return the
857 * completed request back to the gadget layer.
859 void usb_gadget_giveback_request(struct usb_ep
*ep
,
860 struct usb_request
*req
)
862 if (likely(req
->status
== 0))
863 usb_led_activity(USB_LED_EVENT_GADGET
);
865 trace_usb_gadget_giveback_request(ep
, req
, 0);
867 req
->complete(ep
, req
);
869 EXPORT_SYMBOL_GPL(usb_gadget_giveback_request
);
871 /* ------------------------------------------------------------------------- */
874 * gadget_find_ep_by_name - returns ep whose name is the same as sting passed
875 * in second parameter or NULL if searched endpoint not found
876 * @g: controller to check for quirk
877 * @name: name of searched endpoint
879 struct usb_ep
*gadget_find_ep_by_name(struct usb_gadget
*g
, const char *name
)
883 gadget_for_each_ep(ep
, g
) {
884 if (!strcmp(ep
->name
, name
))
890 EXPORT_SYMBOL_GPL(gadget_find_ep_by_name
);
892 /* ------------------------------------------------------------------------- */
894 int usb_gadget_ep_match_desc(struct usb_gadget
*gadget
,
895 struct usb_ep
*ep
, struct usb_endpoint_descriptor
*desc
,
896 struct usb_ss_ep_comp_descriptor
*ep_comp
)
900 int num_req_streams
= 0;
902 /* endpoint already claimed? */
906 type
= usb_endpoint_type(desc
);
907 max
= 0x7ff & usb_endpoint_maxp(desc
);
909 if (usb_endpoint_dir_in(desc
) && !ep
->caps
.dir_in
)
911 if (usb_endpoint_dir_out(desc
) && !ep
->caps
.dir_out
)
914 if (max
> ep
->maxpacket_limit
)
917 /* "high bandwidth" works only at high speed */
918 if (!gadget_is_dualspeed(gadget
) && usb_endpoint_maxp(desc
) & (3<<11))
922 case USB_ENDPOINT_XFER_CONTROL
:
923 /* only support ep0 for portable CONTROL traffic */
925 case USB_ENDPOINT_XFER_ISOC
:
926 if (!ep
->caps
.type_iso
)
928 /* ISO: limit 1023 bytes full speed, 1024 high/super speed */
929 if (!gadget_is_dualspeed(gadget
) && max
> 1023)
932 case USB_ENDPOINT_XFER_BULK
:
933 if (!ep
->caps
.type_bulk
)
935 if (ep_comp
&& gadget_is_superspeed(gadget
)) {
936 /* Get the number of required streams from the
937 * EP companion descriptor and see if the EP
940 num_req_streams
= ep_comp
->bmAttributes
& 0x1f;
941 if (num_req_streams
> ep
->max_streams
)
945 case USB_ENDPOINT_XFER_INT
:
946 /* Bulk endpoints handle interrupt transfers,
947 * except the toggle-quirky iso-synch kind
949 if (!ep
->caps
.type_int
&& !ep
->caps
.type_bulk
)
951 /* INT: limit 64 bytes full speed, 1024 high/super speed */
952 if (!gadget_is_dualspeed(gadget
) && max
> 64)
959 EXPORT_SYMBOL_GPL(usb_gadget_ep_match_desc
);
961 /* ------------------------------------------------------------------------- */
963 static void usb_gadget_state_work(struct work_struct
*work
)
965 struct usb_gadget
*gadget
= work_to_gadget(work
);
966 struct usb_udc
*udc
= gadget
->udc
;
969 sysfs_notify(&udc
->dev
.kobj
, NULL
, "state");
972 void usb_gadget_set_state(struct usb_gadget
*gadget
,
973 enum usb_device_state state
)
975 gadget
->state
= state
;
976 schedule_work(&gadget
->work
);
978 EXPORT_SYMBOL_GPL(usb_gadget_set_state
);
980 /* ------------------------------------------------------------------------- */
982 static void usb_udc_connect_control(struct usb_udc
*udc
)
985 usb_gadget_connect(udc
->gadget
);
987 usb_gadget_disconnect(udc
->gadget
);
991 * usb_udc_vbus_handler - updates the udc core vbus status, and try to
992 * connect or disconnect gadget
993 * @gadget: The gadget which vbus change occurs
994 * @status: The vbus status
996 * The udc driver calls it when it wants to connect or disconnect gadget
997 * according to vbus status.
999 void usb_udc_vbus_handler(struct usb_gadget
*gadget
, bool status
)
1001 struct usb_udc
*udc
= gadget
->udc
;
1005 usb_udc_connect_control(udc
);
1008 EXPORT_SYMBOL_GPL(usb_udc_vbus_handler
);
1011 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
1012 * @gadget: The gadget which bus reset occurs
1013 * @driver: The gadget driver we want to notify
1015 * If the udc driver has bus reset handler, it needs to call this when the bus
1016 * reset occurs, it notifies the gadget driver that the bus reset occurs as
1017 * well as updates gadget state.
1019 void usb_gadget_udc_reset(struct usb_gadget
*gadget
,
1020 struct usb_gadget_driver
*driver
)
1022 driver
->reset(gadget
);
1023 usb_gadget_set_state(gadget
, USB_STATE_DEFAULT
);
1025 EXPORT_SYMBOL_GPL(usb_gadget_udc_reset
);
1028 * usb_gadget_udc_start - tells usb device controller to start up
1029 * @udc: The UDC to be started
1031 * This call is issued by the UDC Class driver when it's about
1032 * to register a gadget driver to the device controller, before
1033 * calling gadget driver's bind() method.
1035 * It allows the controller to be powered off until strictly
1036 * necessary to have it powered on.
1038 * Returns zero on success, else negative errno.
1040 static inline int usb_gadget_udc_start(struct usb_udc
*udc
)
1042 return udc
->gadget
->ops
->udc_start(udc
->gadget
, udc
->driver
);
1046 * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
1047 * @gadget: The device we want to stop activity
1048 * @driver: The driver to unbind from @gadget
1050 * This call is issued by the UDC Class driver after calling
1051 * gadget driver's unbind() method.
1053 * The details are implementation specific, but it can go as
1054 * far as powering off UDC completely and disable its data
1057 static inline void usb_gadget_udc_stop(struct usb_udc
*udc
)
1059 udc
->gadget
->ops
->udc_stop(udc
->gadget
);
1063 * usb_udc_release - release the usb_udc struct
1064 * @dev: the dev member within usb_udc
1066 * This is called by driver's core in order to free memory once the last
1067 * reference is released.
1069 static void usb_udc_release(struct device
*dev
)
1071 struct usb_udc
*udc
;
1073 udc
= container_of(dev
, struct usb_udc
, dev
);
1074 dev_dbg(dev
, "releasing '%s'\n", dev_name(dev
));
1078 static const struct attribute_group
*usb_udc_attr_groups
[];
1080 static void usb_udc_nop_release(struct device
*dev
)
1082 dev_vdbg(dev
, "%s\n", __func__
);
1086 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
1087 * @parent: the parent device to this udc. Usually the controller driver's
1089 * @gadget: the gadget to be added to the list.
1090 * @release: a gadget release function.
1092 * Returns zero on success, negative errno otherwise.
1094 int usb_add_gadget_udc_release(struct device
*parent
, struct usb_gadget
*gadget
,
1095 void (*release
)(struct device
*dev
))
1097 struct usb_udc
*udc
;
1098 struct usb_gadget_driver
*driver
;
1101 udc
= kzalloc(sizeof(*udc
), GFP_KERNEL
);
1105 dev_set_name(&gadget
->dev
, "gadget");
1106 INIT_WORK(&gadget
->work
, usb_gadget_state_work
);
1107 gadget
->dev
.parent
= parent
;
1110 gadget
->dev
.release
= release
;
1112 gadget
->dev
.release
= usb_udc_nop_release
;
1114 ret
= device_register(&gadget
->dev
);
1118 device_initialize(&udc
->dev
);
1119 udc
->dev
.release
= usb_udc_release
;
1120 udc
->dev
.class = udc_class
;
1121 udc
->dev
.groups
= usb_udc_attr_groups
;
1122 udc
->dev
.parent
= parent
;
1123 ret
= dev_set_name(&udc
->dev
, "%s", kobject_name(&parent
->kobj
));
1127 udc
->gadget
= gadget
;
1130 mutex_lock(&udc_lock
);
1131 list_add_tail(&udc
->list
, &udc_list
);
1133 ret
= device_add(&udc
->dev
);
1137 usb_gadget_set_state(gadget
, USB_STATE_NOTATTACHED
);
1140 /* pick up one of pending gadget drivers */
1141 list_for_each_entry(driver
, &gadget_driver_pending_list
, pending
) {
1142 if (!driver
->udc_name
|| strcmp(driver
->udc_name
,
1143 dev_name(&udc
->dev
)) == 0) {
1144 ret
= udc_bind_to_driver(udc
, driver
);
1145 if (ret
!= -EPROBE_DEFER
)
1146 list_del(&driver
->pending
);
1153 mutex_unlock(&udc_lock
);
1158 device_del(&udc
->dev
);
1161 list_del(&udc
->list
);
1162 mutex_unlock(&udc_lock
);
1165 put_device(&udc
->dev
);
1166 device_del(&gadget
->dev
);
1169 put_device(&gadget
->dev
);
1175 EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release
);
1178 * usb_get_gadget_udc_name - get the name of the first UDC controller
1179 * This functions returns the name of the first UDC controller in the system.
1180 * Please note that this interface is usefull only for legacy drivers which
1181 * assume that there is only one UDC controller in the system and they need to
1182 * get its name before initialization. There is no guarantee that the UDC
1183 * of the returned name will be still available, when gadget driver registers
1186 * Returns pointer to string with UDC controller name on success, NULL
1187 * otherwise. Caller should kfree() returned string.
1189 char *usb_get_gadget_udc_name(void)
1191 struct usb_udc
*udc
;
1194 /* For now we take the first available UDC */
1195 mutex_lock(&udc_lock
);
1196 list_for_each_entry(udc
, &udc_list
, list
) {
1198 name
= kstrdup(udc
->gadget
->name
, GFP_KERNEL
);
1202 mutex_unlock(&udc_lock
);
1205 EXPORT_SYMBOL_GPL(usb_get_gadget_udc_name
);
1208 * usb_add_gadget_udc - adds a new gadget to the udc class driver list
1209 * @parent: the parent device to this udc. Usually the controller
1211 * @gadget: the gadget to be added to the list
1213 * Returns zero on success, negative errno otherwise.
1215 int usb_add_gadget_udc(struct device
*parent
, struct usb_gadget
*gadget
)
1217 return usb_add_gadget_udc_release(parent
, gadget
, NULL
);
1219 EXPORT_SYMBOL_GPL(usb_add_gadget_udc
);
1221 static void usb_gadget_remove_driver(struct usb_udc
*udc
)
1223 dev_dbg(&udc
->dev
, "unregistering UDC driver [%s]\n",
1224 udc
->driver
->function
);
1226 kobject_uevent(&udc
->dev
.kobj
, KOBJ_CHANGE
);
1228 usb_gadget_disconnect(udc
->gadget
);
1229 udc
->driver
->disconnect(udc
->gadget
);
1230 udc
->driver
->unbind(udc
->gadget
);
1231 usb_gadget_udc_stop(udc
);
1234 udc
->dev
.driver
= NULL
;
1235 udc
->gadget
->dev
.driver
= NULL
;
1239 * usb_del_gadget_udc - deletes @udc from udc_list
1240 * @gadget: the gadget to be removed.
1242 * This, will call usb_gadget_unregister_driver() if
1243 * the @udc is still busy.
1245 void usb_del_gadget_udc(struct usb_gadget
*gadget
)
1247 struct usb_udc
*udc
= gadget
->udc
;
1252 dev_vdbg(gadget
->dev
.parent
, "unregistering gadget\n");
1254 mutex_lock(&udc_lock
);
1255 list_del(&udc
->list
);
1258 struct usb_gadget_driver
*driver
= udc
->driver
;
1260 usb_gadget_remove_driver(udc
);
1261 list_add(&driver
->pending
, &gadget_driver_pending_list
);
1263 mutex_unlock(&udc_lock
);
1265 kobject_uevent(&udc
->dev
.kobj
, KOBJ_REMOVE
);
1266 flush_work(&gadget
->work
);
1267 device_unregister(&udc
->dev
);
1268 device_unregister(&gadget
->dev
);
1270 EXPORT_SYMBOL_GPL(usb_del_gadget_udc
);
1272 /* ------------------------------------------------------------------------- */
1274 static int udc_bind_to_driver(struct usb_udc
*udc
, struct usb_gadget_driver
*driver
)
1278 dev_dbg(&udc
->dev
, "registering UDC driver [%s]\n",
1281 udc
->driver
= driver
;
1282 udc
->dev
.driver
= &driver
->driver
;
1283 udc
->gadget
->dev
.driver
= &driver
->driver
;
1285 ret
= driver
->bind(udc
->gadget
, driver
);
1288 ret
= usb_gadget_udc_start(udc
);
1290 driver
->unbind(udc
->gadget
);
1293 usb_udc_connect_control(udc
);
1295 kobject_uevent(&udc
->dev
.kobj
, KOBJ_CHANGE
);
1299 dev_err(&udc
->dev
, "failed to start %s: %d\n",
1300 udc
->driver
->function
, ret
);
1302 udc
->dev
.driver
= NULL
;
1303 udc
->gadget
->dev
.driver
= NULL
;
1307 int usb_gadget_probe_driver(struct usb_gadget_driver
*driver
)
1309 struct usb_udc
*udc
= NULL
;
1312 if (!driver
|| !driver
->bind
|| !driver
->setup
)
1315 mutex_lock(&udc_lock
);
1316 if (driver
->udc_name
) {
1317 list_for_each_entry(udc
, &udc_list
, list
) {
1318 ret
= strcmp(driver
->udc_name
, dev_name(&udc
->dev
));
1322 if (!ret
&& !udc
->driver
)
1325 list_for_each_entry(udc
, &udc_list
, list
) {
1326 /* For now we take the first one */
1332 if (!driver
->match_existing_only
) {
1333 list_add_tail(&driver
->pending
, &gadget_driver_pending_list
);
1334 pr_info("udc-core: couldn't find an available UDC - added [%s] to list of pending drivers\n",
1339 mutex_unlock(&udc_lock
);
1342 ret
= udc_bind_to_driver(udc
, driver
);
1343 mutex_unlock(&udc_lock
);
1346 EXPORT_SYMBOL_GPL(usb_gadget_probe_driver
);
1348 int usb_gadget_unregister_driver(struct usb_gadget_driver
*driver
)
1350 struct usb_udc
*udc
= NULL
;
1353 if (!driver
|| !driver
->unbind
)
1356 mutex_lock(&udc_lock
);
1357 list_for_each_entry(udc
, &udc_list
, list
)
1358 if (udc
->driver
== driver
) {
1359 usb_gadget_remove_driver(udc
);
1360 usb_gadget_set_state(udc
->gadget
,
1361 USB_STATE_NOTATTACHED
);
1367 list_del(&driver
->pending
);
1370 mutex_unlock(&udc_lock
);
1373 EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver
);
1375 /* ------------------------------------------------------------------------- */
1377 static ssize_t
usb_udc_srp_store(struct device
*dev
,
1378 struct device_attribute
*attr
, const char *buf
, size_t n
)
1380 struct usb_udc
*udc
= container_of(dev
, struct usb_udc
, dev
);
1382 if (sysfs_streq(buf
, "1"))
1383 usb_gadget_wakeup(udc
->gadget
);
1387 static DEVICE_ATTR(srp
, S_IWUSR
, NULL
, usb_udc_srp_store
);
1389 static ssize_t
usb_udc_softconn_store(struct device
*dev
,
1390 struct device_attribute
*attr
, const char *buf
, size_t n
)
1392 struct usb_udc
*udc
= container_of(dev
, struct usb_udc
, dev
);
1395 dev_err(dev
, "soft-connect without a gadget driver\n");
1399 if (sysfs_streq(buf
, "connect")) {
1400 usb_gadget_udc_start(udc
);
1401 usb_gadget_connect(udc
->gadget
);
1402 } else if (sysfs_streq(buf
, "disconnect")) {
1403 usb_gadget_disconnect(udc
->gadget
);
1404 udc
->driver
->disconnect(udc
->gadget
);
1405 usb_gadget_udc_stop(udc
);
1407 dev_err(dev
, "unsupported command '%s'\n", buf
);
1413 static DEVICE_ATTR(soft_connect
, S_IWUSR
, NULL
, usb_udc_softconn_store
);
1415 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*attr
,
1418 struct usb_udc
*udc
= container_of(dev
, struct usb_udc
, dev
);
1419 struct usb_gadget
*gadget
= udc
->gadget
;
1421 return sprintf(buf
, "%s\n", usb_state_string(gadget
->state
));
1423 static DEVICE_ATTR_RO(state
);
1425 #define USB_UDC_SPEED_ATTR(name, param) \
1426 ssize_t name##_show(struct device *dev, \
1427 struct device_attribute *attr, char *buf) \
1429 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
1430 return snprintf(buf, PAGE_SIZE, "%s\n", \
1431 usb_speed_string(udc->gadget->param)); \
1433 static DEVICE_ATTR_RO(name)
1435 static USB_UDC_SPEED_ATTR(current_speed
, speed
);
1436 static USB_UDC_SPEED_ATTR(maximum_speed
, max_speed
);
1438 #define USB_UDC_ATTR(name) \
1439 ssize_t name##_show(struct device *dev, \
1440 struct device_attribute *attr, char *buf) \
1442 struct usb_udc *udc = container_of(dev, struct usb_udc, dev); \
1443 struct usb_gadget *gadget = udc->gadget; \
1445 return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name); \
1447 static DEVICE_ATTR_RO(name)
1449 static USB_UDC_ATTR(is_otg
);
1450 static USB_UDC_ATTR(is_a_peripheral
);
1451 static USB_UDC_ATTR(b_hnp_enable
);
1452 static USB_UDC_ATTR(a_hnp_support
);
1453 static USB_UDC_ATTR(a_alt_hnp_support
);
1454 static USB_UDC_ATTR(is_selfpowered
);
1456 static struct attribute
*usb_udc_attrs
[] = {
1458 &dev_attr_soft_connect
.attr
,
1459 &dev_attr_state
.attr
,
1460 &dev_attr_current_speed
.attr
,
1461 &dev_attr_maximum_speed
.attr
,
1463 &dev_attr_is_otg
.attr
,
1464 &dev_attr_is_a_peripheral
.attr
,
1465 &dev_attr_b_hnp_enable
.attr
,
1466 &dev_attr_a_hnp_support
.attr
,
1467 &dev_attr_a_alt_hnp_support
.attr
,
1468 &dev_attr_is_selfpowered
.attr
,
1472 static const struct attribute_group usb_udc_attr_group
= {
1473 .attrs
= usb_udc_attrs
,
1476 static const struct attribute_group
*usb_udc_attr_groups
[] = {
1477 &usb_udc_attr_group
,
1481 static int usb_udc_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
1483 struct usb_udc
*udc
= container_of(dev
, struct usb_udc
, dev
);
1486 ret
= add_uevent_var(env
, "USB_UDC_NAME=%s", udc
->gadget
->name
);
1488 dev_err(dev
, "failed to add uevent USB_UDC_NAME\n");
1493 ret
= add_uevent_var(env
, "USB_UDC_DRIVER=%s",
1494 udc
->driver
->function
);
1496 dev_err(dev
, "failed to add uevent USB_UDC_DRIVER\n");
1504 static int __init
usb_udc_init(void)
1506 udc_class
= class_create(THIS_MODULE
, "udc");
1507 if (IS_ERR(udc_class
)) {
1508 pr_err("failed to create udc class --> %ld\n",
1509 PTR_ERR(udc_class
));
1510 return PTR_ERR(udc_class
);
1513 udc_class
->dev_uevent
= usb_udc_uevent
;
1516 subsys_initcall(usb_udc_init
);
1518 static void __exit
usb_udc_exit(void)
1520 class_destroy(udc_class
);
1522 module_exit(usb_udc_exit
);
1524 MODULE_DESCRIPTION("UDC Framework");
1525 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
1526 MODULE_LICENSE("GPL v2");