gadget.h 45.2 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * <linux/usb/gadget.h>
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * We call the USB code inside a Linux-based peripheral device a "gadget"
 * driver, except for the hardware-specific bus glue.  One USB host can
 * master many USB gadgets, but the gadgets are only slaved to one host.
 *
 *
 * (C) Copyright 2002-2004 by David Brownell
 * All Rights Reserved.
 *
 * This software is licensed under the GNU GPL version 2.
 */

#ifndef __LINUX_USB_GADGET_H
#define __LINUX_USB_GADGET_H

18 19 20 21
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/list.h>
22
#include <linux/slab.h>
23
#include <linux/scatterlist.h>
24
#include <linux/types.h>
25
#include <linux/workqueue.h>
26
#include <linux/usb/ch9.h>
27

L
Linus Torvalds 已提交
28 29 30 31 32
struct usb_ep;

/**
 * struct usb_request - describes one i/o request
 * @buf: Buffer used for data.  Always provide this; some controllers
33
 *	only use PIO, or don't use DMA for some endpoints.
L
Linus Torvalds 已提交
34
 * @dma: DMA address corresponding to 'buf'.  If you don't set this
35 36
 *	field, and the usb controller needs one, it is responsible
 *	for mapping and unmapping the buffer.
37 38 39
 * @sg: a scatterlist for SG-capable controllers.
 * @num_sgs: number of SG entries
 * @num_mapped_sgs: number of SG entries mapped to DMA (internal)
L
Linus Torvalds 已提交
40
 * @length: Length of that data
41
 * @stream_id: The stream id, when USB3.0 bulk streams are being used
L
Linus Torvalds 已提交
42 43 44 45 46 47 48 49
 * @no_interrupt: If true, hints that no completion irq is needed.
 *	Helpful sometimes with deep request queues that are handled
 *	directly by DMA controllers.
 * @zero: If true, when writing data, makes the last packet be "short"
 *     by adding a zero length packet as needed;
 * @short_not_ok: When reading data, makes short packets be
 *     treated as errors (queue stops advancing till cleanup).
 * @complete: Function called when request completes, so this request and
A
Alan Stern 已提交
50 51
 *	its buffer may be re-used.  The function will always be called with
 *	interrupts disabled, and it must not sleep.
L
Linus Torvalds 已提交
52 53 54 55 56 57 58 59 60
 *	Reads terminate with a short packet, or when the buffer fills,
 *	whichever comes first.  When writes terminate, some data bytes
 *	will usually still be in flight (often in a hardware fifo).
 *	Errors (for reads or writes) stop the queue from advancing
 *	until the completion function returns, so that any transfers
 *	invalidated by the error may first be dequeued.
 * @context: For use by the completion callback
 * @list: For use by the gadget driver.
 * @status: Reports completion code, zero or a negative errno.
61 62 63 64
 *	Normally, faults block the transfer queue from advancing until
 *	the completion callback returns.
 *	Code "-ESHUTDOWN" indicates completion caused by device disconnect,
 *	or when the driver disabled the endpoint.
L
Linus Torvalds 已提交
65
 * @actual: Reports bytes transferred to/from the buffer.  For reads (OUT
66 67 68 69 70
 *	transfers) this may be less than the requested length.  If the
 *	short_not_ok flag is set, short reads are treated as errors
 *	even when status otherwise indicates successful completion.
 *	Note that for writes (IN transfers) some data bytes may still
 *	reside in a device-side FIFO when the request is reported as
L
Linus Torvalds 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
 *	complete.
 *
 * These are allocated/freed through the endpoint they're used with.  The
 * hardware's driver can add extra per-request data to the memory it returns,
 * which often avoids separate memory allocations (potential failures),
 * later when the request is queued.
 *
 * Request flags affect request handling, such as whether a zero length
 * packet is written (the "zero" flag), whether a short read should be
 * treated as an error (blocking request queue advance, the "short_not_ok"
 * flag), or hinting that an interrupt is not required (the "no_interrupt"
 * flag, for use with deep request queues).
 *
 * Bulk endpoints can use any size buffers, and can also be used for interrupt
 * transfers. interrupt-only endpoints can be much less functional.
86
 *
L
Lucas De Marchi 已提交
87
 * NOTE:  this is analogous to 'struct urb' on the host side, except that
88
 * it's thinner and promotes more pre-allocation.
L
Linus Torvalds 已提交
89 90 91 92 93 94 95
 */

struct usb_request {
	void			*buf;
	unsigned		length;
	dma_addr_t		dma;

96 97 98 99
	struct scatterlist	*sg;
	unsigned		num_sgs;
	unsigned		num_mapped_sgs;

100
	unsigned		stream_id:16;
L
Linus Torvalds 已提交
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
	unsigned		no_interrupt:1;
	unsigned		zero:1;
	unsigned		short_not_ok:1;

	void			(*complete)(struct usb_ep *ep,
					struct usb_request *req);
	void			*context;
	struct list_head	list;

	int			status;
	unsigned		actual;
};

/*-------------------------------------------------------------------------*/

/* endpoint-specific parts of the api to the usb controller hardware.
 * unlike the urb model, (de)multiplexing layers are not required.
 * (so this api could slash overhead if used on the host side...)
 *
 * note that device side usb controllers commonly differ in how many
 * endpoints they support, as well as their capabilities.
 */
struct usb_ep_ops {
	int (*enable) (struct usb_ep *ep,
		const struct usb_endpoint_descriptor *desc);
	int (*disable) (struct usb_ep *ep);

	struct usb_request *(*alloc_request) (struct usb_ep *ep,
A
Al Viro 已提交
129
		gfp_t gfp_flags);
L
Linus Torvalds 已提交
130 131 132
	void (*free_request) (struct usb_ep *ep, struct usb_request *req);

	int (*queue) (struct usb_ep *ep, struct usb_request *req,
A
Al Viro 已提交
133
		gfp_t gfp_flags);
L
Linus Torvalds 已提交
134 135 136
	int (*dequeue) (struct usb_ep *ep, struct usb_request *req);

	int (*set_halt) (struct usb_ep *ep, int value);
137 138
	int (*set_wedge) (struct usb_ep *ep);

L
Linus Torvalds 已提交
139 140 141 142
	int (*fifo_status) (struct usb_ep *ep);
	void (*fifo_flush) (struct usb_ep *ep);
};

143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
/**
 * struct usb_ep_caps - endpoint capabilities description
 * @type_control:Endpoint supports control type (reserved for ep0).
 * @type_iso:Endpoint supports isochronous transfers.
 * @type_bulk:Endpoint supports bulk transfers.
 * @type_int:Endpoint supports interrupt transfers.
 * @dir_in:Endpoint supports IN direction.
 * @dir_out:Endpoint supports OUT direction.
 */
struct usb_ep_caps {
	unsigned type_control:1;
	unsigned type_iso:1;
	unsigned type_bulk:1;
	unsigned type_int:1;
	unsigned dir_in:1;
	unsigned dir_out:1;
};

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
#define USB_EP_CAPS_TYPE_CONTROL     0x01
#define USB_EP_CAPS_TYPE_ISO         0x02
#define USB_EP_CAPS_TYPE_BULK        0x04
#define USB_EP_CAPS_TYPE_INT         0x08
#define USB_EP_CAPS_TYPE_ALL \
	(USB_EP_CAPS_TYPE_ISO | USB_EP_CAPS_TYPE_BULK | USB_EP_CAPS_TYPE_INT)
#define USB_EP_CAPS_DIR_IN           0x01
#define USB_EP_CAPS_DIR_OUT          0x02
#define USB_EP_CAPS_DIR_ALL  (USB_EP_CAPS_DIR_IN | USB_EP_CAPS_DIR_OUT)

#define USB_EP_CAPS(_type, _dir) \
	{ \
		.type_control = !!(_type & USB_EP_CAPS_TYPE_CONTROL), \
		.type_iso = !!(_type & USB_EP_CAPS_TYPE_ISO), \
		.type_bulk = !!(_type & USB_EP_CAPS_TYPE_BULK), \
		.type_int = !!(_type & USB_EP_CAPS_TYPE_INT), \
		.dir_in = !!(_dir & USB_EP_CAPS_DIR_IN), \
		.dir_out = !!(_dir & USB_EP_CAPS_DIR_OUT), \
	}

L
Linus Torvalds 已提交
181 182 183 184 185
/**
 * struct usb_ep - device side representation of USB endpoint
 * @name:identifier for the endpoint, such as "ep-a" or "ep9in-bulk"
 * @ops: Function pointers used to access hardware-specific operations.
 * @ep_list:the gadget's ep_list holds all of its endpoints
186
 * @caps:The structure describing types and directions supported by endoint.
L
Linus Torvalds 已提交
187 188 189
 * @maxpacket:The maximum packet size used on this endpoint.  The initial
 *	value can sometimes be reduced (hardware allowing), according to
 *      the endpoint descriptor used to configure the endpoint.
190 191 192
 * @maxpacket_limit:The maximum packet size value which can be handled by this
 *	endpoint. It's set once by UDC driver when endpoint is initialized, and
 *	should not be changed. Should not be confused with maxpacket.
193 194
 * @max_streams: The maximum number of streams supported
 *	by this EP (0 - 16, actual number is 2^n)
195 196
 * @mult: multiplier, 'mult' value for SS Isoc EPs
 * @maxburst: the maximum number of bursts supported by this EP (for usb3)
197
 * @driver_data:for use by the gadget driver.
198 199
 * @address: used to identify the endpoint when finding descriptor that
 *	matches connection speed
200 201
 * @desc: endpoint descriptor.  This pointer is set before the endpoint is
 *	enabled and remains valid until the endpoint is disabled.
202 203
 * @comp_desc: In case of SuperSpeed support, this is the endpoint companion
 *	descriptor that is used to configure the endpoint
L
Linus Torvalds 已提交
204 205 206 207 208
 *
 * the bus controller driver lists all the general purpose endpoints in
 * gadget->ep_list.  the control endpoint (gadget->ep0) is not in that list,
 * and is accessed only in response to a driver setup() callback.
 */
209

L
Linus Torvalds 已提交
210 211 212 213 214 215
struct usb_ep {
	void			*driver_data;

	const char		*name;
	const struct usb_ep_ops	*ops;
	struct list_head	ep_list;
216
	struct usb_ep_caps	caps;
217
	bool			claimed;
218
	bool			enabled;
L
Linus Torvalds 已提交
219
	unsigned		maxpacket:16;
220
	unsigned		maxpacket_limit:16;
221
	unsigned		max_streams:16;
222
	unsigned		mult:2;
Y
Yu Xu 已提交
223
	unsigned		maxburst:5;
224
	u8			address;
225
	const struct usb_endpoint_descriptor	*desc;
226
	const struct usb_ss_ep_comp_descriptor	*comp_desc;
L
Linus Torvalds 已提交
227 228 229 230
};

/*-------------------------------------------------------------------------*/

231 232 233 234 235
/**
 * usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
 * @ep:the endpoint being configured
 * @maxpacket_limit:value of maximum packet size limit
 *
236
 * This function should be used only in UDC drivers to initialize endpoint
237 238 239 240 241 242 243 244 245
 * (usually in probe function).
 */
static inline void usb_ep_set_maxpacket_limit(struct usb_ep *ep,
					      unsigned maxpacket_limit)
{
	ep->maxpacket_limit = maxpacket_limit;
	ep->maxpacket = maxpacket_limit;
}

L
Linus Torvalds 已提交
246 247 248
/**
 * usb_ep_enable - configure endpoint, making it usable
 * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
249
 *	drivers discover endpoints through the ep_list of a usb_gadget.
L
Linus Torvalds 已提交
250
 *
251
 * When configurations are set, or when interface settings change, the driver
L
Linus Torvalds 已提交
252 253 254 255 256 257 258 259 260 261 262 263 264 265
 * will enable or disable the relevant endpoints.  while it is enabled, an
 * endpoint may be used for i/o until the driver receives a disconnect() from
 * the host or until the endpoint is disabled.
 *
 * the ep0 implementation (which calls this routine) must ensure that the
 * hardware capabilities of each endpoint match the descriptor provided
 * for it.  for example, an endpoint named "ep2in-bulk" would be usable
 * for interrupt transfers as well as bulk, but it likely couldn't be used
 * for iso transfers or for endpoint 14.  some endpoints are fully
 * configurable, with more generic names like "ep-a".  (remember that for
 * USB, "in" means "towards the USB master".)
 *
 * returns zero, or a negative error code.
 */
266
static inline int usb_ep_enable(struct usb_ep *ep)
L
Linus Torvalds 已提交
267
{
268 269 270 271 272 273 274 275 276 277 278 279
	int ret;

	if (ep->enabled)
		return 0;

	ret = ep->ops->enable(ep, ep->desc);
	if (ret)
		return ret;

	ep->enabled = true;

	return 0;
L
Linus Torvalds 已提交
280 281 282 283 284 285 286 287 288 289 290 291 292 293
}

/**
 * usb_ep_disable - endpoint is no longer usable
 * @ep:the endpoint being unconfigured.  may not be the endpoint named "ep0".
 *
 * no other task may be using this endpoint when this is called.
 * any pending and uncompleted requests will complete with status
 * indicating disconnect (-ESHUTDOWN) before this call returns.
 * gadget drivers must call usb_ep_enable() again before queueing
 * requests to the endpoint.
 *
 * returns zero, or a negative error code.
 */
294
static inline int usb_ep_disable(struct usb_ep *ep)
L
Linus Torvalds 已提交
295
{
296 297 298 299 300 301 302 303 304 305 306 307
	int ret;

	if (!ep->enabled)
		return 0;

	ret = ep->ops->disable(ep);
	if (ret)
		return ret;

	ep->enabled = false;

	return 0;
L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
}

/**
 * usb_ep_alloc_request - allocate a request object to use with this endpoint
 * @ep:the endpoint to be used with with the request
 * @gfp_flags:GFP_* flags to use
 *
 * Request objects must be allocated with this call, since they normally
 * need controller-specific setup and may even need endpoint-specific
 * resources such as allocation of DMA descriptors.
 * Requests may be submitted with usb_ep_queue(), and receive a single
 * completion callback.  Free requests with usb_ep_free_request(), when
 * they are no longer needed.
 *
 * Returns the request, or null if one could not be allocated.
 */
324 325
static inline struct usb_request *usb_ep_alloc_request(struct usb_ep *ep,
						       gfp_t gfp_flags)
L
Linus Torvalds 已提交
326
{
327
	return ep->ops->alloc_request(ep, gfp_flags);
L
Linus Torvalds 已提交
328 329 330 331 332 333 334 335 336 337 338
}

/**
 * usb_ep_free_request - frees a request object
 * @ep:the endpoint associated with the request
 * @req:the request being freed
 *
 * Reverses the effect of usb_ep_alloc_request().
 * Caller guarantees the request is not queued, and that it will
 * no longer be requeued (or otherwise used).
 */
339 340
static inline void usb_ep_free_request(struct usb_ep *ep,
				       struct usb_request *req)
L
Linus Torvalds 已提交
341
{
342
	ep->ops->free_request(ep, req);
L
Linus Torvalds 已提交
343 344 345 346 347 348 349
}

/**
 * usb_ep_queue - queues (submits) an I/O request to an endpoint.
 * @ep:the endpoint associated with the request
 * @req:the request being submitted
 * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
350
 *	pre-allocate all necessary memory with the request.
L
Linus Torvalds 已提交
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
 *
 * This tells the device controller to perform the specified request through
 * that endpoint (reading or writing a buffer).  When the request completes,
 * including being canceled by usb_ep_dequeue(), the request's completion
 * routine is called to return the request to the driver.  Any endpoint
 * (except control endpoints like ep0) may have more than one transfer
 * request queued; they complete in FIFO order.  Once a gadget driver
 * submits a request, that request may not be examined or modified until it
 * is given back to that driver through the completion callback.
 *
 * Each request is turned into one or more packets.  The controller driver
 * never merges adjacent requests into the same packet.  OUT transfers
 * will sometimes use data that's already buffered in the hardware.
 * Drivers can rely on the fact that the first byte of the request's buffer
 * always corresponds to the first byte of some USB packet, for both
 * IN and OUT transfers.
 *
 * Bulk endpoints can queue any amount of data; the transfer is packetized
 * automatically.  The last packet will be short if the request doesn't fill it
 * out completely.  Zero length packets (ZLPs) should be avoided in portable
 * protocols since not all usb hardware can successfully handle zero length
 * packets.  (ZLPs may be explicitly written, and may be implicitly written if
 * the request 'zero' flag is set.)  Bulk endpoints may also be used
 * for interrupt transfers; but the reverse is not true, and some endpoints
 * won't support every interrupt transfer.  (Such as 768 byte packets.)
 *
 * Interrupt-only endpoints are less functional than bulk endpoints, for
 * example by not supporting queueing or not handling buffers that are
 * larger than the endpoint's maxpacket size.  They may also treat data
 * toggle differently.
 *
 * Control endpoints ... after getting a setup() callback, the driver queues
 * one response (even if it would be zero length).  That enables the
L
Lucas De Marchi 已提交
384
 * status ack, after transferring data as specified in the response.  Setup
L
Linus Torvalds 已提交
385 386 387 388
 * functions may return negative error codes to generate protocol stalls.
 * (Note that some USB device controllers disallow protocol stall responses
 * in some cases.)  When control responses are deferred (the response is
 * written after the setup callback returns), then usb_ep_set_halt() may be
A
Alan Stern 已提交
389 390 391 392
 * used on ep0 to trigger protocol stalls.  Depending on the controller,
 * it may not be possible to trigger a status-stage protocol stall when the
 * data stage is over, that is, from within the response's completion
 * routine.
L
Linus Torvalds 已提交
393 394 395 396 397 398 399 400 401
 *
 * For periodic endpoints, like interrupt or isochronous ones, the usb host
 * arranges to poll once per interval, and the gadget driver usually will
 * have queued some data to transfer at that time.
 *
 * Returns zero, or a negative error code.  Endpoints that are not enabled
 * report errors; errors will also be
 * reported when the usb peripheral is disconnected.
 */
402 403
static inline int usb_ep_queue(struct usb_ep *ep,
			       struct usb_request *req, gfp_t gfp_flags)
L
Linus Torvalds 已提交
404
{
405
	return ep->ops->queue(ep, req, gfp_flags);
L
Linus Torvalds 已提交
406 407 408 409 410 411 412
}

/**
 * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
 * @ep:the endpoint associated with the request
 * @req:the request being canceled
 *
413
 * If the request is still active on the endpoint, it is dequeued and its
L
Linus Torvalds 已提交
414
 * completion routine is called (with status -ECONNRESET); else a negative
415 416
 * error code is returned. This is guaranteed to happen before the call to
 * usb_ep_dequeue() returns.
L
Linus Torvalds 已提交
417
 *
418 419
 * Note that some hardware can't clear out write fifos (to unlink the request
 * at the head of the queue) except as part of disconnecting from usb. Such
L
Linus Torvalds 已提交
420 421 422
 * restrictions prevent drivers from supporting configuration changes,
 * even to configuration zero (a "chapter 9" requirement).
 */
423
static inline int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
L
Linus Torvalds 已提交
424
{
425
	return ep->ops->dequeue(ep, req);
L
Linus Torvalds 已提交
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
}

/**
 * usb_ep_set_halt - sets the endpoint halt feature.
 * @ep: the non-isochronous endpoint being stalled
 *
 * Use this to stall an endpoint, perhaps as an error report.
 * Except for control endpoints,
 * the endpoint stays halted (will not stream any data) until the host
 * clears this feature; drivers may need to empty the endpoint's request
 * queue first, to make sure no inappropriate transfers happen.
 *
 * Note that while an endpoint CLEAR_FEATURE will be invisible to the
 * gadget driver, a SET_INTERFACE will not be.  To reset endpoints for the
 * current altsetting, see usb_ep_clear_halt().  When switching altsettings,
 * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
 *
 * Returns zero, or a negative error code.  On success, this call sets
 * underlying hardware state that blocks data transfers.
 * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
 * transfer requests are still queued, or if the controller hardware
 * (usually a FIFO) still holds bytes that the host hasn't collected.
 */
449
static inline int usb_ep_set_halt(struct usb_ep *ep)
L
Linus Torvalds 已提交
450
{
451
	return ep->ops->set_halt(ep, 1);
L
Linus Torvalds 已提交
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
}

/**
 * usb_ep_clear_halt - clears endpoint halt, and resets toggle
 * @ep:the bulk or interrupt endpoint being reset
 *
 * Use this when responding to the standard usb "set interface" request,
 * for endpoints that aren't reconfigured, after clearing any other state
 * in the endpoint's i/o queue.
 *
 * Returns zero, or a negative error code.  On success, this call clears
 * the underlying hardware state reflecting endpoint halt and data toggle.
 * Note that some hardware can't support this request (like pxa2xx_udc),
 * and accordingly can't correctly implement interface altsettings.
 */
467
static inline int usb_ep_clear_halt(struct usb_ep *ep)
L
Linus Torvalds 已提交
468
{
469
	return ep->ops->set_halt(ep, 0);
L
Linus Torvalds 已提交
470 471
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
/**
 * usb_ep_set_wedge - sets the halt feature and ignores clear requests
 * @ep: the endpoint being wedged
 *
 * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT)
 * requests. If the gadget driver clears the halt status, it will
 * automatically unwedge the endpoint.
 *
 * Returns zero on success, else negative errno.
 */
static inline int
usb_ep_set_wedge(struct usb_ep *ep)
{
	if (ep->ops->set_wedge)
		return ep->ops->set_wedge(ep);
	else
		return ep->ops->set_halt(ep, 1);
}

L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
/**
 * usb_ep_fifo_status - returns number of bytes in fifo, or error
 * @ep: the endpoint whose fifo status is being checked.
 *
 * FIFO endpoints may have "unclaimed data" in them in certain cases,
 * such as after aborted transfers.  Hosts may not have collected all
 * the IN data written by the gadget driver (and reported by a request
 * completion).  The gadget driver may not have collected all the data
 * written OUT to it by the host.  Drivers that need precise handling for
 * fault reporting or recovery may need to use this call.
 *
 * This returns the number of such bytes in the fifo, or a negative
 * errno if the endpoint doesn't use a FIFO or doesn't support such
 * precise handling.
 */
506
static inline int usb_ep_fifo_status(struct usb_ep *ep)
L
Linus Torvalds 已提交
507 508
{
	if (ep->ops->fifo_status)
509
		return ep->ops->fifo_status(ep);
L
Linus Torvalds 已提交
510 511 512 513 514 515 516 517 518 519 520 521 522
	else
		return -EOPNOTSUPP;
}

/**
 * usb_ep_fifo_flush - flushes contents of a fifo
 * @ep: the endpoint whose fifo is being flushed.
 *
 * This call may be used to flush the "unclaimed data" that may exist in
 * an endpoint fifo after abnormal transaction terminations.  The call
 * must never be used except when endpoint is not being used for any
 * protocol translation.
 */
523
static inline void usb_ep_fifo_flush(struct usb_ep *ep)
L
Linus Torvalds 已提交
524 525
{
	if (ep->ops->fifo_flush)
526
		ep->ops->fifo_flush(ep);
L
Linus Torvalds 已提交
527 528 529 530 531
}


/*-------------------------------------------------------------------------*/

532 533
struct usb_dcd_config_params {
	__u8  bU1devExitLat;	/* U1 Device exit Latency */
534
#define USB_DEFAULT_U1_DEV_EXIT_LAT	0x01	/* Less then 1 microsec */
535
	__le16 bU2DevExitLat;	/* U2 Device exit Latency */
536
#define USB_DEFAULT_U2_DEV_EXIT_LAT	0x1F4	/* Less then 500 microsec */
537 538 539
};


L
Linus Torvalds 已提交
540
struct usb_gadget;
F
Felipe Balbi 已提交
541
struct usb_gadget_driver;
542
struct usb_udc;
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553 554 555

/* the rest of the api to the controller hardware: device operations,
 * which don't involve endpoints (or i/o).
 */
struct usb_gadget_ops {
	int	(*get_frame)(struct usb_gadget *);
	int	(*wakeup)(struct usb_gadget *);
	int	(*set_selfpowered) (struct usb_gadget *, int is_selfpowered);
	int	(*vbus_session) (struct usb_gadget *, int is_active);
	int	(*vbus_draw) (struct usb_gadget *, unsigned mA);
	int	(*pullup) (struct usb_gadget *, int is_on);
	int	(*ioctl)(struct usb_gadget *,
				unsigned code, unsigned long param);
556
	void	(*get_config_params)(struct usb_dcd_config_params *);
557 558
	int	(*udc_start)(struct usb_gadget *,
			struct usb_gadget_driver *);
559
	int	(*udc_stop)(struct usb_gadget *);
560 561 562
	struct usb_ep *(*match_ep)(struct usb_gadget *,
			struct usb_endpoint_descriptor *,
			struct usb_ss_ep_comp_descriptor *);
L
Linus Torvalds 已提交
563 564 565 566
};

/**
 * struct usb_gadget - represents a usb slave device
567
 * @work: (internal use) Workqueue to be used for sysfs_notify()
568
 * @udc: struct usb_udc pointer for this gadget
L
Linus Torvalds 已提交
569 570
 * @ops: Function pointers used to access hardware-specific operations.
 * @ep0: Endpoint zero, used when reading or writing responses to
571
 *	driver setup() requests
L
Linus Torvalds 已提交
572 573
 * @ep_list: List of other endpoints supported by the device.
 * @speed: Speed of current connection to USB host.
574 575
 * @max_speed: Maximal speed the UDC can handle.  UDC must support this
 *      and all slower speeds.
576
 * @state: the state we are now (attached, suspended, configured, etc)
577 578 579 580 581
 * @name: Identifies the controller hardware type.  Used in diagnostics
 *	and sometimes configuration.
 * @dev: Driver model state for this abstract device.
 * @out_epnum: last used out ep number
 * @in_epnum: last used in ep number
582
 * @otg_caps: OTG capabilities of this gadget.
583
 * @sg_supported: true if we can handle scatter-gather
L
Linus Torvalds 已提交
584 585 586 587 588 589 590 591 592 593 594
 * @is_otg: True if the USB device port uses a Mini-AB jack, so that the
 *	gadget driver must provide a USB OTG descriptor.
 * @is_a_peripheral: False unless is_otg, the "A" end of a USB cable
 *	is in the Mini-AB jack, and HNP has been used to switch roles
 *	so that the "A" device currently acts as A-Peripheral, not A-Host.
 * @a_hnp_support: OTG device feature flag, indicating that the A-Host
 *	supports HNP at this port.
 * @a_alt_hnp_support: OTG device feature flag, indicating that the A-Host
 *	only supports HNP on a different root port.
 * @b_hnp_enable: OTG device feature flag, indicating that the A-Host
 *	enabled HNP support.
595 596
 * @quirk_ep_out_aligned_size: epout requires buffer size to be aligned to
 *	MaxPacketSize.
597
 * @is_selfpowered: if the gadget is self-powered.
598 599 600
 * @deactivated: True if gadget is deactivated - in deactivated state it cannot
 *	be connected.
 * @connected: True if gadget is connected.
L
Linus Torvalds 已提交
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
 *
 * Gadgets have a mostly-portable "gadget driver" implementing device
 * functions, handling all usb configurations and interfaces.  Gadget
 * drivers talk to hardware-specific code indirectly, through ops vectors.
 * That insulates the gadget driver from hardware details, and packages
 * the hardware endpoints through generic i/o queues.  The "usb_gadget"
 * and "usb_ep" interfaces provide that insulation from the hardware.
 *
 * Except for the driver data, all fields in this structure are
 * read-only to the gadget driver.  That driver data is part of the
 * "driver model" infrastructure in 2.6 (and later) kernels, and for
 * earlier systems is grouped in a similar structure that's not known
 * to the rest of the kernel.
 *
 * Values of the three OTG device feature flags are updated before the
 * setup() call corresponding to USB_REQ_SET_CONFIGURATION, and before
 * driver suspend() calls.  They are valid only when is_otg, and when the
 * device is acting as a B-Peripheral (so is_a_peripheral is false).
 */
struct usb_gadget {
621
	struct work_struct		work;
622
	struct usb_udc			*udc;
L
Linus Torvalds 已提交
623 624 625 626 627
	/* readonly to gadget driver */
	const struct usb_gadget_ops	*ops;
	struct usb_ep			*ep0;
	struct list_head		ep_list;	/* of usb_ep */
	enum usb_device_speed		speed;
628
	enum usb_device_speed		max_speed;
629
	enum usb_device_state		state;
630 631 632 633
	const char			*name;
	struct device			dev;
	unsigned			out_epnum;
	unsigned			in_epnum;
634
	struct usb_otg_caps		*otg_caps;
635

636
	unsigned			sg_supported:1;
L
Linus Torvalds 已提交
637 638 639 640 641
	unsigned			is_otg:1;
	unsigned			is_a_peripheral:1;
	unsigned			b_hnp_enable:1;
	unsigned			a_hnp_support:1;
	unsigned			a_alt_hnp_support:1;
642
	unsigned			quirk_ep_out_aligned_size:1;
643
	unsigned			quirk_altset_not_supp:1;
644
	unsigned			quirk_stall_not_supp:1;
645
	unsigned			quirk_zlp_not_supp:1;
646
	unsigned			is_selfpowered:1;
647 648
	unsigned			deactivated:1;
	unsigned			connected:1;
L
Linus Torvalds 已提交
649
};
650
#define work_to_gadget(w)	(container_of((w), struct usb_gadget, work))
L
Linus Torvalds 已提交
651

652 653 654 655
static inline void set_gadget_data(struct usb_gadget *gadget, void *data)
	{ dev_set_drvdata(&gadget->dev, data); }
static inline void *get_gadget_data(struct usb_gadget *gadget)
	{ return dev_get_drvdata(&gadget->dev); }
656 657 658 659
static inline struct usb_gadget *dev_to_usb_gadget(struct device *dev)
{
	return container_of(dev, struct usb_gadget, dev);
}
L
Linus Torvalds 已提交
660 661

/* iterates the non-control endpoints; 'tmp' is a struct usb_ep pointer */
662
#define gadget_for_each_ep(tmp, gadget) \
L
Linus Torvalds 已提交
663 664
	list_for_each_entry(tmp, &(gadget)->ep_list, ep_list)

665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
/**
 * usb_ep_align_maybe - returns @len aligned to ep's maxpacketsize if gadget
 *	requires quirk_ep_out_aligned_size, otherwise reguens len.
 * @g: controller to check for quirk
 * @ep: the endpoint whose maxpacketsize is used to align @len
 * @len: buffer size's length to align to @ep's maxpacketsize
 *
 * This helper is used in case it's required for any reason to check and maybe
 * align buffer's size to an ep's maxpacketsize.
 */
static inline size_t
usb_ep_align_maybe(struct usb_gadget *g, struct usb_ep *ep, size_t len)
{
	return !g->quirk_ep_out_aligned_size ? len :
			round_up(len, (size_t)ep->desc->wMaxPacketSize);
}

682 683 684 685 686 687 688 689 690 691
/**
 * gadget_is_altset_supported - return true iff the hardware supports
 *	altsettings
 * @g: controller to check for quirk
 */
static inline int gadget_is_altset_supported(struct usb_gadget *g)
{
	return !g->quirk_altset_not_supp;
}

692 693 694 695 696 697 698 699 700
/**
 * gadget_is_stall_supported - return true iff the hardware supports stalling
 * @g: controller to check for quirk
 */
static inline int gadget_is_stall_supported(struct usb_gadget *g)
{
	return !g->quirk_stall_not_supp;
}

701 702 703 704 705 706 707 708 709
/**
 * gadget_is_zlp_supported - return true iff the hardware supports zlp
 * @g: controller to check for quirk
 */
static inline int gadget_is_zlp_supported(struct usb_gadget *g)
{
	return !g->quirk_zlp_not_supp;
}

710 711
/**
 * gadget_is_dualspeed - return true iff the hardware handles high speed
R
Randy Dunlap 已提交
712
 * @g: controller that might support both high and full speeds
713 714 715
 */
static inline int gadget_is_dualspeed(struct usb_gadget *g)
{
716
	return g->max_speed >= USB_SPEED_HIGH;
717 718
}

719
/**
720 721
 * gadget_is_superspeed() - return true if the hardware handles superspeed
 * @g: controller that might support superspeed
722 723 724
 */
static inline int gadget_is_superspeed(struct usb_gadget *g)
{
725
	return g->max_speed >= USB_SPEED_SUPER;
726 727
}

728 729
/**
 * gadget_is_otg - return true iff the hardware is OTG-ready
R
Randy Dunlap 已提交
730
 * @g: controller that might have a Mini-AB connector
731 732 733 734 735 736 737 738 739 740 741 742 743
 *
 * This is a runtime test, since kernels with a USB-OTG stack sometimes
 * run on boards which only have a Mini-B (or Mini-A) connector.
 */
static inline int gadget_is_otg(struct usb_gadget *g)
{
#ifdef CONFIG_USB_OTG
	return g->is_otg;
#else
	return 0;
#endif
}

L
Linus Torvalds 已提交
744 745 746 747 748 749 750
/**
 * usb_gadget_frame_number - returns the current frame number
 * @gadget: controller that reports the frame number
 *
 * Returns the usb frame number, normally eleven bits from a SOF packet,
 * or negative errno if this device doesn't support this capability.
 */
751
static inline int usb_gadget_frame_number(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
752
{
753
	return gadget->ops->get_frame(gadget);
L
Linus Torvalds 已提交
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
}

/**
 * usb_gadget_wakeup - tries to wake up the host connected to this gadget
 * @gadget: controller used to wake up the host
 *
 * Returns zero on success, else negative error code if the hardware
 * doesn't support such attempts, or its support has not been enabled
 * by the usb host.  Drivers must return device descriptors that report
 * their ability to support this, or hosts won't enable it.
 *
 * This may also try to use SRP to wake the host and start enumeration,
 * even if OTG isn't otherwise in use.  OTG devices may also start
 * remote wakeup even when hosts don't explicitly enable it.
 */
769
static inline int usb_gadget_wakeup(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
770 771 772
{
	if (!gadget->ops->wakeup)
		return -EOPNOTSUPP;
773
	return gadget->ops->wakeup(gadget);
L
Linus Torvalds 已提交
774 775 776 777 778 779 780 781 782 783 784
}

/**
 * usb_gadget_set_selfpowered - sets the device selfpowered feature.
 * @gadget:the device being declared as self-powered
 *
 * this affects the device status reported by the hardware driver
 * to reflect that it now has a local power supply.
 *
 * returns zero on success, else negative errno.
 */
785
static inline int usb_gadget_set_selfpowered(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
786 787 788
{
	if (!gadget->ops->set_selfpowered)
		return -EOPNOTSUPP;
789
	return gadget->ops->set_selfpowered(gadget, 1);
L
Linus Torvalds 已提交
790 791 792 793 794 795 796 797 798 799 800 801
}

/**
 * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
 * @gadget:the device being declared as bus-powered
 *
 * this affects the device status reported by the hardware driver.
 * some hardware may not support bus-powered operation, in which
 * case this feature's value can never change.
 *
 * returns zero on success, else negative errno.
 */
802
static inline int usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
803 804 805
{
	if (!gadget->ops->set_selfpowered)
		return -EOPNOTSUPP;
806
	return gadget->ops->set_selfpowered(gadget, 0);
L
Linus Torvalds 已提交
807 808 809 810 811
}

/**
 * usb_gadget_vbus_connect - Notify controller that VBUS is powered
 * @gadget:The device which now has VBUS power.
812
 * Context: can sleep
L
Linus Torvalds 已提交
813 814 815 816 817 818 819 820 821
 *
 * This call is used by a driver for an external transceiver (or GPIO)
 * that detects a VBUS power session starting.  Common responses include
 * resuming the controller, activating the D+ (or D-) pullup to let the
 * host detect that a USB device is attached, and starting to draw power
 * (8mA or possibly more, especially after SET_CONFIGURATION).
 *
 * Returns zero on success, else negative errno.
 */
822
static inline int usb_gadget_vbus_connect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
823 824 825
{
	if (!gadget->ops->vbus_session)
		return -EOPNOTSUPP;
826
	return gadget->ops->vbus_session(gadget, 1);
L
Linus Torvalds 已提交
827 828 829 830 831 832 833 834 835 836 837 838 839 840
}

/**
 * usb_gadget_vbus_draw - constrain controller's VBUS power usage
 * @gadget:The device whose VBUS usage is being described
 * @mA:How much current to draw, in milliAmperes.  This should be twice
 *	the value listed in the configuration descriptor bMaxPower field.
 *
 * This call is used by gadget drivers during SET_CONFIGURATION calls,
 * reporting how much power the device may consume.  For example, this
 * could affect how quickly batteries are recharged.
 *
 * Returns zero on success, else negative errno.
 */
841
static inline int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
L
Linus Torvalds 已提交
842 843 844
{
	if (!gadget->ops->vbus_draw)
		return -EOPNOTSUPP;
845
	return gadget->ops->vbus_draw(gadget, mA);
L
Linus Torvalds 已提交
846 847 848 849 850
}

/**
 * usb_gadget_vbus_disconnect - notify controller about VBUS session end
 * @gadget:the device whose VBUS supply is being described
851
 * Context: can sleep
L
Linus Torvalds 已提交
852 853 854 855 856 857 858
 *
 * This call is used by a driver for an external transceiver (or GPIO)
 * that detects a VBUS power session ending.  Common responses include
 * reversing everything done in usb_gadget_vbus_connect().
 *
 * Returns zero on success, else negative errno.
 */
859
static inline int usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
860 861 862
{
	if (!gadget->ops->vbus_session)
		return -EOPNOTSUPP;
863
	return gadget->ops->vbus_session(gadget, 0);
L
Linus Torvalds 已提交
864 865 866 867 868 869 870 871 872 873 874 875 876
}

/**
 * usb_gadget_connect - software-controlled connect to USB host
 * @gadget:the peripheral being connected
 *
 * Enables the D+ (or potentially D-) pullup.  The host will start
 * enumerating this gadget when the pullup is active and a VBUS session
 * is active (the link is powered).  This pullup is always enabled unless
 * usb_gadget_disconnect() has been used to disable it.
 *
 * Returns zero on success, else negative errno.
 */
877
static inline int usb_gadget_connect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
878
{
879 880
	int ret;

L
Linus Torvalds 已提交
881 882
	if (!gadget->ops->pullup)
		return -EOPNOTSUPP;
883 884 885 886 887 888 889 890 891 892 893 894 895 896

	if (gadget->deactivated) {
		/*
		 * If gadget is deactivated we only save new state.
		 * Gadget will be connected automatically after activation.
		 */
		gadget->connected = true;
		return 0;
	}

	ret = gadget->ops->pullup(gadget, 1);
	if (!ret)
		gadget->connected = 1;
	return ret;
L
Linus Torvalds 已提交
897 898 899 900 901 902 903 904 905 906
}

/**
 * usb_gadget_disconnect - software-controlled disconnect from USB host
 * @gadget:the peripheral being disconnected
 *
 * Disables the D+ (or potentially D-) pullup, which the host may see
 * as a disconnect (when a VBUS session is active).  Not all systems
 * support software pullup controls.
 *
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934
 * Returns zero on success, else negative errno.
 */
static inline int usb_gadget_disconnect(struct usb_gadget *gadget)
{
	int ret;

	if (!gadget->ops->pullup)
		return -EOPNOTSUPP;

	if (gadget->deactivated) {
		/*
		 * If gadget is deactivated we only save new state.
		 * Gadget will stay disconnected after activation.
		 */
		gadget->connected = false;
		return 0;
	}

	ret = gadget->ops->pullup(gadget, 0);
	if (!ret)
		gadget->connected = 0;
	return ret;
}

/**
 * usb_gadget_deactivate - deactivate function which is not ready to work
 * @gadget: the peripheral being deactivated
 *
L
Linus Torvalds 已提交
935 936
 * This routine may be used during the gadget driver bind() call to prevent
 * the peripheral from ever being visible to the USB host, unless later
937
 * usb_gadget_activate() is called.  For example, user mode components may
L
Linus Torvalds 已提交
938 939 940 941
 * need to be activated before the system can talk to hosts.
 *
 * Returns zero on success, else negative errno.
 */
942
static inline int usb_gadget_deactivate(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
943
{
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
	int ret;

	if (gadget->deactivated)
		return 0;

	if (gadget->connected) {
		ret = usb_gadget_disconnect(gadget);
		if (ret)
			return ret;
		/*
		 * If gadget was being connected before deactivation, we want
		 * to reconnect it in usb_gadget_activate().
		 */
		gadget->connected = true;
	}
	gadget->deactivated = true;

	return 0;
L
Linus Torvalds 已提交
962 963
}

964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
/**
 * usb_gadget_activate - activate function which is not ready to work
 * @gadget: the peripheral being activated
 *
 * This routine activates gadget which was previously deactivated with
 * usb_gadget_deactivate() call. It calls usb_gadget_connect() if needed.
 *
 * Returns zero on success, else negative errno.
 */
static inline int usb_gadget_activate(struct usb_gadget *gadget)
{
	if (!gadget->deactivated)
		return 0;

	gadget->deactivated = false;

	/*
	 * If gadget has been connected before deactivation, or became connected
	 * while it was being deactivated, we call usb_gadget_connect().
	 */
	if (gadget->connected)
		return usb_gadget_connect(gadget);

	return 0;
}
L
Linus Torvalds 已提交
989 990 991 992 993 994

/*-------------------------------------------------------------------------*/

/**
 * struct usb_gadget_driver - driver for usb 'slave' devices
 * @function: String describing the gadget's function
995
 * @max_speed: Highest speed the driver handles.
L
Linus Torvalds 已提交
996
 * @setup: Invoked for ep0 control requests that aren't handled by
997 998 999 1000
 *	the hardware level driver. Most calls must be handled by
 *	the gadget driver, including descriptor and configuration
 *	management.  The 16 bit members of the setup data are in
 *	USB byte order. Called in_interrupt; this may not sleep.  Driver
L
Linus Torvalds 已提交
1001 1002
 *	queues a response to ep0, or returns negative to stall.
 * @disconnect: Invoked after all transfers have been stopped,
1003 1004
 *	when the host is disconnected.  May be called in_interrupt; this
 *	may not sleep.  Some devices can't detect disconnect, so this might
L
Linus Torvalds 已提交
1005
 *	not be called except as part of controller shutdown.
1006
 * @bind: the driver's bind callback
L
Linus Torvalds 已提交
1007
 * @unbind: Invoked when the driver is unbound from a gadget,
1008 1009
 *	usually from rmmod (after a disconnect is reported).
 *	Called in a context that permits sleeping.
L
Linus Torvalds 已提交
1010 1011
 * @suspend: Invoked on USB suspend.  May be called in_interrupt.
 * @resume: Invoked on USB resume.  May be called in_interrupt.
1012 1013
 * @reset: Invoked on USB bus reset. It is mandatory for all gadget drivers
 *	and should be called in_interrupt.
L
Linus Torvalds 已提交
1014
 * @driver: Driver model state for this driver.
1015 1016
 * @udc_name: A name of UDC this driver should be bound to. If udc_name is NULL,
 *	this driver will be bound to any available UDC.
1017
 * @pending: UDC core private data used for deferred probe of this driver.
L
Linus Torvalds 已提交
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
 *
 * Devices are disabled till a gadget driver successfully bind()s, which
 * means the driver will handle setup() requests needed to enumerate (and
 * meet "chapter 9" requirements) then do some useful work.
 *
 * If gadget->is_otg is true, the gadget driver must provide an OTG
 * descriptor during enumeration, or else fail the bind() call.  In such
 * cases, no USB traffic may flow until both bind() returns without
 * having called usb_gadget_disconnect(), and the USB host stack has
 * initialized.
 *
 * Drivers use hardware-specific knowledge to configure the usb hardware.
 * endpoint addressing is only one of several hardware characteristics that
 * are in descriptors the ep0 implementation returns from setup() calls.
 *
 * Except for ep0 implementation, most driver code shouldn't need change to
 * run on top of different usb controllers.  It'll use endpoints set up by
 * that ep0 implementation.
 *
 * The usb controller driver handles a few standard usb requests.  Those
 * include set_address, and feature flags for devices, interfaces, and
 * endpoints (the get_status, set_feature, and clear_feature requests).
 *
 * Accordingly, the driver's setup() callback must always implement all
 * get_descriptor requests, returning at least a device descriptor and
 * a configuration descriptor.  Drivers must make sure the endpoint
 * descriptors match any hardware constraints. Some hardware also constrains
 * other descriptors. (The pxa250 allows only configurations 1, 2, or 3).
 *
 * The driver's setup() callback must also implement set_configuration,
 * and should also implement set_interface, get_configuration, and
 * get_interface.  Setting a configuration (or interface) is where
 * endpoints should be activated or (config 0) shut down.
 *
 * (Note that only the default control endpoint is supported.  Neither
 * hosts nor devices generally support control traffic except to ep0.)
 *
 * Most devices will ignore USB suspend/resume operations, and so will
 * not provide those callbacks.  However, some may need to change modes
 * when the host is not longer directing those activities.  For example,
 * local controls (buttons, dials, etc) may need to be re-enabled since
 * the (remote) host can't do that any longer; or an error state might
 * be cleared, to make the device behave identically whether or not
 * power is maintained.
 */
struct usb_gadget_driver {
	char			*function;
1065
	enum usb_device_speed	max_speed;
1066 1067
	int			(*bind)(struct usb_gadget *gadget,
					struct usb_gadget_driver *driver);
L
Linus Torvalds 已提交
1068 1069 1070 1071 1072 1073
	void			(*unbind)(struct usb_gadget *);
	int			(*setup)(struct usb_gadget *,
					const struct usb_ctrlrequest *);
	void			(*disconnect)(struct usb_gadget *);
	void			(*suspend)(struct usb_gadget *);
	void			(*resume)(struct usb_gadget *);
1074
	void			(*reset)(struct usb_gadget *);
L
Linus Torvalds 已提交
1075

1076
	/* FIXME support safe rmmod */
L
Linus Torvalds 已提交
1077
	struct device_driver	driver;
1078 1079

	char			*udc_name;
1080
	struct list_head	pending;
L
Linus Torvalds 已提交
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
};



/*-------------------------------------------------------------------------*/

/* driver modules register and unregister, as usual.
 * these calls must be made in a context that can sleep.
 *
 * these will usually be implemented directly by the hardware-dependent
 * usb bus interface driver, which will only support a single driver.
 */

/**
1095 1096
 * usb_gadget_probe_driver - probe a gadget driver
 * @driver: the driver being registered
1097
 * Context: can sleep
L
Linus Torvalds 已提交
1098 1099 1100
 *
 * Call this in your gadget driver's module initialization function,
 * to tell the underlying usb controller driver about your driver.
1101 1102 1103
 * The @bind() function will be called to bind it to a gadget before this
 * registration call returns.  It's expected that the @bind() function will
 * be in init sections.
L
Linus Torvalds 已提交
1104
 */
1105
int usb_gadget_probe_driver(struct usb_gadget_driver *driver);
L
Linus Torvalds 已提交
1106 1107 1108 1109

/**
 * usb_gadget_unregister_driver - unregister a gadget driver
 * @driver:the driver being unregistered
1110
 * Context: can sleep
L
Linus Torvalds 已提交
1111 1112 1113 1114 1115 1116
 *
 * Call this in your gadget driver's module cleanup function,
 * to tell the underlying usb controller that your driver is
 * going away.  If the controller is connected to a USB host,
 * it will first disconnect().  The driver is also requested
 * to unbind() and clean up any device state, before this procedure
1117 1118
 * finally returns.  It's expected that the unbind() functions
 * will in in exit sections, so may not be linked in some kernels.
L
Linus Torvalds 已提交
1119
 */
1120
int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
L
Linus Torvalds 已提交
1121

1122 1123
extern int usb_add_gadget_udc_release(struct device *parent,
		struct usb_gadget *gadget, void (*release)(struct device *dev));
F
Felipe Balbi 已提交
1124 1125 1126
extern int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
extern void usb_del_gadget_udc(struct usb_gadget *gadget);

L
Linus Torvalds 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
/*-------------------------------------------------------------------------*/

/* utility to simplify dealing with string descriptors */

/**
 * struct usb_string - wraps a C string and its USB id
 * @id:the (nonzero) ID for this string
 * @s:the string, in UTF-8 encoding
 *
 * If you're using usb_gadget_get_string(), use this to wrap a string
 * together with its ID.
 */
struct usb_string {
	u8			id;
	const char		*s;
};

/**
 * struct usb_gadget_strings - a set of USB strings in a given language
 * @language:identifies the strings' language (0x0409 for en-us)
 * @strings:array of strings with their ids
 *
 * If you're using usb_gadget_get_string(), use this to wrap all the
 * strings for a given language.
 */
struct usb_gadget_strings {
	u16			language;	/* 0x0409 for en-us */
	struct usb_string	*strings;
};

1157 1158 1159 1160 1161
struct usb_gadget_string_container {
	struct list_head        list;
	u8                      *stash[0];
};

L
Linus Torvalds 已提交
1162
/* put descriptor for string with that id into buf (buflen >= 256) */
1163
int usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf);
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176

/*-------------------------------------------------------------------------*/

/* utility to simplify managing config descriptors */

/* write vector of descriptors into buffer */
int usb_descriptor_fillbuf(void *, unsigned,
		const struct usb_descriptor_header **);

/* build config descriptor from single descriptor vector */
int usb_gadget_config_buf(const struct usb_config_descriptor *config,
	void *buf, unsigned buflen, const struct usb_descriptor_header **desc);

1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
/* copy a NULL-terminated vector of descriptors */
struct usb_descriptor_header **usb_copy_descriptors(
		struct usb_descriptor_header **);

/**
 * usb_free_descriptors - free descriptors returned by usb_copy_descriptors()
 * @v: vector of descriptors
 */
static inline void usb_free_descriptors(struct usb_descriptor_header **v)
{
	kfree(v);
}

1190 1191 1192 1193 1194 1195 1196
struct usb_function;
int usb_assign_descriptors(struct usb_function *f,
		struct usb_descriptor_header **fs,
		struct usb_descriptor_header **hs,
		struct usb_descriptor_header **ss);
void usb_free_all_descriptors(struct usb_function *f);

1197 1198 1199 1200
struct usb_descriptor_header *usb_otg_descriptor_alloc(
				struct usb_gadget *gadget);
int usb_otg_descriptor_init(struct usb_gadget *gadget,
		struct usb_descriptor_header *otg_desc);
L
Linus Torvalds 已提交
1201 1202
/*-------------------------------------------------------------------------*/

1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
/* utility to simplify map/unmap of usb_requests to/from DMA */

extern int usb_gadget_map_request(struct usb_gadget *gadget,
		struct usb_request *req, int is_in);

extern void usb_gadget_unmap_request(struct usb_gadget *gadget,
		struct usb_request *req, int is_in);

/*-------------------------------------------------------------------------*/

1213 1214 1215 1216 1217 1218 1219
/* utility to set gadget state properly */

extern void usb_gadget_set_state(struct usb_gadget *gadget,
		enum usb_device_state state);

/*-------------------------------------------------------------------------*/

1220 1221 1222 1223 1224 1225
/* utility to tell udc core that the bus reset occurs */
extern void usb_gadget_udc_reset(struct usb_gadget *gadget,
		struct usb_gadget_driver *driver);

/*-------------------------------------------------------------------------*/

1226 1227 1228 1229 1230
/* utility to give requests back to the gadget layer */

extern void usb_gadget_giveback_request(struct usb_ep *ep,
		struct usb_request *req);

P
Peter Chen 已提交
1231 1232
/*-------------------------------------------------------------------------*/

1233 1234 1235 1236 1237 1238 1239
/* utility to find endpoint by name */

extern struct usb_ep *gadget_find_ep_by_name(struct usb_gadget *g,
		const char *name);

/*-------------------------------------------------------------------------*/

1240 1241 1242 1243 1244 1245 1246 1247
/* utility to check if endpoint caps match descriptor needs */

extern int usb_gadget_ep_match_desc(struct usb_gadget *gadget,
		struct usb_ep *ep, struct usb_endpoint_descriptor *desc,
		struct usb_ss_ep_comp_descriptor *ep_comp);

/*-------------------------------------------------------------------------*/

P
Peter Chen 已提交
1248 1249
/* utility to update vbus status for udc core, it may be scheduled */
extern void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status);
1250 1251 1252

/*-------------------------------------------------------------------------*/

L
Linus Torvalds 已提交
1253 1254
/* utility wrapping a simple endpoint selection policy */

1255
extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
1256
			struct usb_endpoint_descriptor *);
L
Linus Torvalds 已提交
1257

1258 1259 1260 1261 1262

extern struct usb_ep *usb_ep_autoconfig_ss(struct usb_gadget *,
			struct usb_endpoint_descriptor *,
			struct usb_ss_ep_comp_descriptor *);

1263 1264
extern void usb_ep_autoconfig_release(struct usb_ep *);

1265
extern void usb_ep_autoconfig_reset(struct usb_gadget *);
L
Linus Torvalds 已提交
1266

1267
#endif /* __LINUX_USB_GADGET_H */