gadget.h 39.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 143 144 145 146 147 148 149 150
	int (*fifo_status) (struct usb_ep *ep);
	void (*fifo_flush) (struct usb_ep *ep);
};

/**
 * 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
 * @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.
151 152 153
 * @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.
154 155
 * @max_streams: The maximum number of streams supported
 *	by this EP (0 - 16, actual number is 2^n)
156 157
 * @mult: multiplier, 'mult' value for SS Isoc EPs
 * @maxburst: the maximum number of bursts supported by this EP (for usb3)
158
 * @driver_data:for use by the gadget driver.
159 160
 * @address: used to identify the endpoint when finding descriptor that
 *	matches connection speed
161 162
 * @desc: endpoint descriptor.  This pointer is set before the endpoint is
 *	enabled and remains valid until the endpoint is disabled.
163 164
 * @comp_desc: In case of SuperSpeed support, this is the endpoint companion
 *	descriptor that is used to configure the endpoint
L
Linus Torvalds 已提交
165 166 167 168 169 170 171 172 173 174 175 176
 *
 * 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.
 */
struct usb_ep {
	void			*driver_data;

	const char		*name;
	const struct usb_ep_ops	*ops;
	struct list_head	ep_list;
	unsigned		maxpacket:16;
177
	unsigned		maxpacket_limit:16;
178
	unsigned		max_streams:16;
179
	unsigned		mult:2;
Y
Yu Xu 已提交
180
	unsigned		maxburst:5;
181
	u8			address;
182
	const struct usb_endpoint_descriptor	*desc;
183
	const struct usb_ss_ep_comp_descriptor	*comp_desc;
L
Linus Torvalds 已提交
184 185 186 187
};

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

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
/**
 * 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
 *
 * This function shoud be used only in UDC drivers to initialize endpoint
 * (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 已提交
203 204 205
/**
 * usb_ep_enable - configure endpoint, making it usable
 * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
206
 *	drivers discover endpoints through the ep_list of a usb_gadget.
L
Linus Torvalds 已提交
207
 *
208
 * When configurations are set, or when interface settings change, the driver
L
Linus Torvalds 已提交
209 210 211 212 213 214 215 216 217 218 219 220 221 222
 * 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.
 */
223
static inline int usb_ep_enable(struct usb_ep *ep)
L
Linus Torvalds 已提交
224
{
225
	return ep->ops->enable(ep, ep->desc);
L
Linus Torvalds 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238 239
}

/**
 * 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.
 */
240
static inline int usb_ep_disable(struct usb_ep *ep)
L
Linus Torvalds 已提交
241
{
242
	return ep->ops->disable(ep);
L
Linus Torvalds 已提交
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
}

/**
 * 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.
 */
259 260
static inline struct usb_request *usb_ep_alloc_request(struct usb_ep *ep,
						       gfp_t gfp_flags)
L
Linus Torvalds 已提交
261
{
262
	return ep->ops->alloc_request(ep, gfp_flags);
L
Linus Torvalds 已提交
263 264 265 266 267 268 269 270 271 272 273
}

/**
 * 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).
 */
274 275
static inline void usb_ep_free_request(struct usb_ep *ep,
				       struct usb_request *req)
L
Linus Torvalds 已提交
276
{
277
	ep->ops->free_request(ep, req);
L
Linus Torvalds 已提交
278 279 280 281 282 283 284
}

/**
 * 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
285
 *	pre-allocate all necessary memory with the request.
L
Linus Torvalds 已提交
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
 *
 * 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 已提交
319
 * status ack, after transferring data as specified in the response.  Setup
L
Linus Torvalds 已提交
320 321 322 323
 * 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 已提交
324 325 326 327
 * 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 已提交
328 329 330 331 332 333 334 335 336
 *
 * 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.
 */
337 338
static inline int usb_ep_queue(struct usb_ep *ep,
			       struct usb_request *req, gfp_t gfp_flags)
L
Linus Torvalds 已提交
339
{
340
	return ep->ops->queue(ep, req, gfp_flags);
L
Linus Torvalds 已提交
341 342 343 344 345 346 347
}

/**
 * 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
 *
348
 * If the request is still active on the endpoint, it is dequeued and its
L
Linus Torvalds 已提交
349
 * completion routine is called (with status -ECONNRESET); else a negative
350 351
 * error code is returned. This is guaranteed to happen before the call to
 * usb_ep_dequeue() returns.
L
Linus Torvalds 已提交
352
 *
353 354
 * 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 已提交
355 356 357
 * restrictions prevent drivers from supporting configuration changes,
 * even to configuration zero (a "chapter 9" requirement).
 */
358
static inline int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
L
Linus Torvalds 已提交
359
{
360
	return ep->ops->dequeue(ep, req);
L
Linus Torvalds 已提交
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
}

/**
 * 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.
 */
384
static inline int usb_ep_set_halt(struct usb_ep *ep)
L
Linus Torvalds 已提交
385
{
386
	return ep->ops->set_halt(ep, 1);
L
Linus Torvalds 已提交
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
}

/**
 * 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.
 */
402
static inline int usb_ep_clear_halt(struct usb_ep *ep)
L
Linus Torvalds 已提交
403
{
404
	return ep->ops->set_halt(ep, 0);
L
Linus Torvalds 已提交
405 406
}

407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
/**
 * 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 已提交
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
/**
 * 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.
 */
441
static inline int usb_ep_fifo_status(struct usb_ep *ep)
L
Linus Torvalds 已提交
442 443
{
	if (ep->ops->fifo_status)
444
		return ep->ops->fifo_status(ep);
L
Linus Torvalds 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457
	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.
 */
458
static inline void usb_ep_fifo_flush(struct usb_ep *ep)
L
Linus Torvalds 已提交
459 460
{
	if (ep->ops->fifo_flush)
461
		ep->ops->fifo_flush(ep);
L
Linus Torvalds 已提交
462 463 464 465 466
}


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

467 468
struct usb_dcd_config_params {
	__u8  bU1devExitLat;	/* U1 Device exit Latency */
469
#define USB_DEFAULT_U1_DEV_EXIT_LAT	0x01	/* Less then 1 microsec */
470
	__le16 bU2DevExitLat;	/* U2 Device exit Latency */
471
#define USB_DEFAULT_U2_DEV_EXIT_LAT	0x1F4	/* Less then 500 microsec */
472 473 474
};


L
Linus Torvalds 已提交
475
struct usb_gadget;
F
Felipe Balbi 已提交
476
struct usb_gadget_driver;
L
Linus Torvalds 已提交
477 478 479 480 481 482 483 484 485 486 487 488 489

/* 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);
490
	void	(*get_config_params)(struct usb_dcd_config_params *);
491 492 493 494
	int	(*udc_start)(struct usb_gadget *,
			struct usb_gadget_driver *);
	int	(*udc_stop)(struct usb_gadget *,
			struct usb_gadget_driver *);
L
Linus Torvalds 已提交
495 496 497 498
};

/**
 * struct usb_gadget - represents a usb slave device
499
 * @work: (internal use) Workqueue to be used for sysfs_notify()
L
Linus Torvalds 已提交
500 501
 * @ops: Function pointers used to access hardware-specific operations.
 * @ep0: Endpoint zero, used when reading or writing responses to
502
 *	driver setup() requests
L
Linus Torvalds 已提交
503 504
 * @ep_list: List of other endpoints supported by the device.
 * @speed: Speed of current connection to USB host.
505 506
 * @max_speed: Maximal speed the UDC can handle.  UDC must support this
 *      and all slower speeds.
507
 * @state: the state we are now (attached, suspended, configured, etc)
508 509 510 511 512
 * @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
513
 * @sg_supported: true if we can handle scatter-gather
L
Linus Torvalds 已提交
514 515 516 517 518 519 520 521 522 523 524
 * @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.
525 526
 * @quirk_ep_out_aligned_size: epout requires buffer size to be aligned to
 *	MaxPacketSize.
L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
 *
 * 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 {
547
	struct work_struct		work;
L
Linus Torvalds 已提交
548 549 550 551 552
	/* 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;
553
	enum usb_device_speed		max_speed;
554
	enum usb_device_state		state;
555 556 557 558 559
	const char			*name;
	struct device			dev;
	unsigned			out_epnum;
	unsigned			in_epnum;

560
	unsigned			sg_supported:1;
L
Linus Torvalds 已提交
561 562 563 564 565
	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;
566
	unsigned			quirk_ep_out_aligned_size:1;
L
Linus Torvalds 已提交
567
};
568
#define work_to_gadget(w)	(container_of((w), struct usb_gadget, work))
L
Linus Torvalds 已提交
569

570 571 572 573
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); }
574 575 576 577
static inline struct usb_gadget *dev_to_usb_gadget(struct device *dev)
{
	return container_of(dev, struct usb_gadget, dev);
}
L
Linus Torvalds 已提交
578 579

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


584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
/**
 * 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);
}

601 602
/**
 * gadget_is_dualspeed - return true iff the hardware handles high speed
R
Randy Dunlap 已提交
603
 * @g: controller that might support both high and full speeds
604 605 606
 */
static inline int gadget_is_dualspeed(struct usb_gadget *g)
{
607
	return g->max_speed >= USB_SPEED_HIGH;
608 609
}

610
/**
611 612
 * gadget_is_superspeed() - return true if the hardware handles superspeed
 * @g: controller that might support superspeed
613 614 615
 */
static inline int gadget_is_superspeed(struct usb_gadget *g)
{
616
	return g->max_speed >= USB_SPEED_SUPER;
617 618
}

619 620
/**
 * gadget_is_otg - return true iff the hardware is OTG-ready
R
Randy Dunlap 已提交
621
 * @g: controller that might have a Mini-AB connector
622 623 624 625 626 627 628 629 630 631 632 633 634
 *
 * 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 已提交
635 636 637 638 639 640 641
/**
 * 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.
 */
642
static inline int usb_gadget_frame_number(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
643
{
644
	return gadget->ops->get_frame(gadget);
L
Linus Torvalds 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
}

/**
 * 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.
 */
660
static inline int usb_gadget_wakeup(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
661 662 663
{
	if (!gadget->ops->wakeup)
		return -EOPNOTSUPP;
664
	return gadget->ops->wakeup(gadget);
L
Linus Torvalds 已提交
665 666 667 668 669 670 671 672 673 674 675
}

/**
 * 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.
 */
676
static inline int usb_gadget_set_selfpowered(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
677 678 679
{
	if (!gadget->ops->set_selfpowered)
		return -EOPNOTSUPP;
680
	return gadget->ops->set_selfpowered(gadget, 1);
L
Linus Torvalds 已提交
681 682 683 684 685 686 687 688 689 690 691 692
}

/**
 * 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.
 */
693
static inline int usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
694 695 696
{
	if (!gadget->ops->set_selfpowered)
		return -EOPNOTSUPP;
697
	return gadget->ops->set_selfpowered(gadget, 0);
L
Linus Torvalds 已提交
698 699 700 701 702
}

/**
 * usb_gadget_vbus_connect - Notify controller that VBUS is powered
 * @gadget:The device which now has VBUS power.
703
 * Context: can sleep
L
Linus Torvalds 已提交
704 705 706 707 708 709 710 711 712
 *
 * 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.
 */
713
static inline int usb_gadget_vbus_connect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
714 715 716
{
	if (!gadget->ops->vbus_session)
		return -EOPNOTSUPP;
717
	return gadget->ops->vbus_session(gadget, 1);
L
Linus Torvalds 已提交
718 719 720 721 722 723 724 725 726 727 728 729 730 731
}

/**
 * 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.
 */
732
static inline int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
L
Linus Torvalds 已提交
733 734 735
{
	if (!gadget->ops->vbus_draw)
		return -EOPNOTSUPP;
736
	return gadget->ops->vbus_draw(gadget, mA);
L
Linus Torvalds 已提交
737 738 739 740 741
}

/**
 * usb_gadget_vbus_disconnect - notify controller about VBUS session end
 * @gadget:the device whose VBUS supply is being described
742
 * Context: can sleep
L
Linus Torvalds 已提交
743 744 745 746 747 748 749
 *
 * 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.
 */
750
static inline int usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
751 752 753
{
	if (!gadget->ops->vbus_session)
		return -EOPNOTSUPP;
754
	return gadget->ops->vbus_session(gadget, 0);
L
Linus Torvalds 已提交
755 756 757 758 759 760 761 762 763 764 765 766 767
}

/**
 * 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.
 */
768
static inline int usb_gadget_connect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
769 770 771
{
	if (!gadget->ops->pullup)
		return -EOPNOTSUPP;
772
	return gadget->ops->pullup(gadget, 1);
L
Linus Torvalds 已提交
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
}

/**
 * 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.
 *
 * 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
 * usb_gadget_connect() is called.  For example, user mode components may
 * need to be activated before the system can talk to hosts.
 *
 * Returns zero on success, else negative errno.
 */
790
static inline int usb_gadget_disconnect(struct usb_gadget *gadget)
L
Linus Torvalds 已提交
791 792 793
{
	if (!gadget->ops->pullup)
		return -EOPNOTSUPP;
794
	return gadget->ops->pullup(gadget, 0);
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802
}


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

/**
 * struct usb_gadget_driver - driver for usb 'slave' devices
 * @function: String describing the gadget's function
803
 * @max_speed: Highest speed the driver handles.
L
Linus Torvalds 已提交
804
 * @setup: Invoked for ep0 control requests that aren't handled by
805 806 807 808
 *	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 已提交
809 810
 *	queues a response to ep0, or returns negative to stall.
 * @disconnect: Invoked after all transfers have been stopped,
811 812
 *	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 已提交
813
 *	not be called except as part of controller shutdown.
814
 * @bind: the driver's bind callback
L
Linus Torvalds 已提交
815
 * @unbind: Invoked when the driver is unbound from a gadget,
816 817
 *	usually from rmmod (after a disconnect is reported).
 *	Called in a context that permits sleeping.
L
Linus Torvalds 已提交
818 819
 * @suspend: Invoked on USB suspend.  May be called in_interrupt.
 * @resume: Invoked on USB resume.  May be called in_interrupt.
820 821
 * @reset: Invoked on USB bus reset. It is mandatory for all gadget drivers
 *	and should be called in_interrupt.
L
Linus Torvalds 已提交
822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
 * @driver: Driver model state for this driver.
 *
 * 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;
870
	enum usb_device_speed	max_speed;
871 872
	int			(*bind)(struct usb_gadget *gadget,
					struct usb_gadget_driver *driver);
L
Linus Torvalds 已提交
873 874 875 876 877 878
	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 *);
879
	void			(*reset)(struct usb_gadget *);
L
Linus Torvalds 已提交
880

881
	/* FIXME support safe rmmod */
L
Linus Torvalds 已提交
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
	struct device_driver	driver;
};



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

/* 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.
 */

/**
897 898
 * usb_gadget_probe_driver - probe a gadget driver
 * @driver: the driver being registered
899
 * Context: can sleep
L
Linus Torvalds 已提交
900 901 902
 *
 * Call this in your gadget driver's module initialization function,
 * to tell the underlying usb controller driver about your driver.
903 904 905
 * 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 已提交
906
 */
907
int usb_gadget_probe_driver(struct usb_gadget_driver *driver);
L
Linus Torvalds 已提交
908 909 910 911

/**
 * usb_gadget_unregister_driver - unregister a gadget driver
 * @driver:the driver being unregistered
912
 * Context: can sleep
L
Linus Torvalds 已提交
913 914 915 916 917 918
 *
 * 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
919 920
 * 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 已提交
921
 */
922
int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
L
Linus Torvalds 已提交
923

924 925
extern int usb_add_gadget_udc_release(struct device *parent,
		struct usb_gadget *gadget, void (*release)(struct device *dev));
F
Felipe Balbi 已提交
926 927
extern int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
extern void usb_del_gadget_udc(struct usb_gadget *gadget);
928 929
extern int udc_attach_driver(const char *name,
		struct usb_gadget_driver *driver);
F
Felipe Balbi 已提交
930

L
Linus Torvalds 已提交
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
/*-------------------------------------------------------------------------*/

/* 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;
};

961 962 963 964 965
struct usb_gadget_string_container {
	struct list_head        list;
	u8                      *stash[0];
};

L
Linus Torvalds 已提交
966
/* put descriptor for string with that id into buf (buflen >= 256) */
967
int usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf);
L
Linus Torvalds 已提交
968 969 970 971 972 973 974 975 976 977 978 979 980

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

/* 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);

981 982 983 984 985 986 987 988 989 990 991 992 993
/* 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);
}

994 995 996 997 998 999 1000
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);

L
Linus Torvalds 已提交
1001 1002
/*-------------------------------------------------------------------------*/

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
/* 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);

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

1013 1014 1015 1016 1017 1018 1019
/* utility to set gadget state properly */

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

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

1020 1021 1022 1023 1024 1025
/* 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);

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

L
Linus Torvalds 已提交
1026 1027
/* utility wrapping a simple endpoint selection policy */

1028
extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
1029
			struct usb_endpoint_descriptor *);
L
Linus Torvalds 已提交
1030

1031 1032 1033 1034 1035

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

1036
extern void usb_ep_autoconfig_reset(struct usb_gadget *);
L
Linus Torvalds 已提交
1037

1038
#endif /* __LINUX_USB_GADGET_H */