PageRenderTime 87ms CodeModel.GetById 17ms app.highlight 58ms RepoModel.GetById 2ms app.codeStats 0ms

/include/linux/usb.h

https://github.com/airy09/android_kernel_sony_apq8064
C Header | 1726 lines | 740 code | 180 blank | 806 comment | 20 complexity | 7548504fd8560e5b29d4ca757b423f27 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1#ifndef __LINUX_USB_H
   2#define __LINUX_USB_H
   3
   4#include <linux/mod_devicetable.h>
   5#include <linux/usb/ch9.h>
   6
   7#define USB_MAJOR			180
   8#define USB_DEVICE_MAJOR		189
   9
  10
  11#ifdef __KERNEL__
  12
  13#include <linux/errno.h>        /* for -ENODEV */
  14#include <linux/delay.h>	/* for mdelay() */
  15#include <linux/interrupt.h>	/* for in_interrupt() */
  16#include <linux/list.h>		/* for struct list_head */
  17#include <linux/kref.h>		/* for struct kref */
  18#include <linux/device.h>	/* for struct device */
  19#include <linux/fs.h>		/* for struct file_operations */
  20#include <linux/completion.h>	/* for struct completion */
  21#include <linux/sched.h>	/* for current && schedule_timeout */
  22#include <linux/mutex.h>	/* for struct mutex */
  23#include <linux/pm_runtime.h>	/* for runtime PM */
  24
  25struct usb_device;
  26struct usb_driver;
  27struct wusb_dev;
  28
  29/*-------------------------------------------------------------------------*/
  30
  31/*
  32 * Host-side wrappers for standard USB descriptors ... these are parsed
  33 * from the data provided by devices.  Parsing turns them from a flat
  34 * sequence of descriptors into a hierarchy:
  35 *
  36 *  - devices have one (usually) or more configs;
  37 *  - configs have one (often) or more interfaces;
  38 *  - interfaces have one (usually) or more settings;
  39 *  - each interface setting has zero or (usually) more endpoints.
  40 *  - a SuperSpeed endpoint has a companion descriptor
  41 *
  42 * And there might be other descriptors mixed in with those.
  43 *
  44 * Devices may also have class-specific or vendor-specific descriptors.
  45 */
  46
  47struct ep_device;
  48
  49/**
  50 * struct usb_host_endpoint - host-side endpoint descriptor and queue
  51 * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder
  52 * @ss_ep_comp: SuperSpeed companion descriptor for this endpoint
  53 * @urb_list: urbs queued to this endpoint; maintained by usbcore
  54 * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
  55 *	with one or more transfer descriptors (TDs) per urb
  56 * @ep_dev: ep_device for sysfs info
  57 * @extra: descriptors following this endpoint in the configuration
  58 * @extralen: how many bytes of "extra" are valid
  59 * @enabled: URBs may be submitted to this endpoint
  60 *
  61 * USB requests are always queued to a given endpoint, identified by a
  62 * descriptor within an active interface in a given USB configuration.
  63 */
  64struct usb_host_endpoint {
  65	struct usb_endpoint_descriptor		desc;
  66	struct usb_ss_ep_comp_descriptor	ss_ep_comp;
  67	struct list_head		urb_list;
  68	void				*hcpriv;
  69	struct ep_device		*ep_dev;	/* For sysfs info */
  70
  71	unsigned char *extra;   /* Extra descriptors */
  72	int extralen;
  73	int enabled;
  74};
  75
  76/* host-side wrapper for one interface setting's parsed descriptors */
  77struct usb_host_interface {
  78	struct usb_interface_descriptor	desc;
  79
  80	/* array of desc.bNumEndpoint endpoints associated with this
  81	 * interface setting.  these will be in no particular order.
  82	 */
  83	struct usb_host_endpoint *endpoint;
  84
  85	char *string;		/* iInterface string, if present */
  86	unsigned char *extra;   /* Extra descriptors */
  87	int extralen;
  88};
  89
  90enum usb_interface_condition {
  91	USB_INTERFACE_UNBOUND = 0,
  92	USB_INTERFACE_BINDING,
  93	USB_INTERFACE_BOUND,
  94	USB_INTERFACE_UNBINDING,
  95};
  96
  97/**
  98 * struct usb_interface - what usb device drivers talk to
  99 * @altsetting: array of interface structures, one for each alternate
 100 *	setting that may be selected.  Each one includes a set of
 101 *	endpoint configurations.  They will be in no particular order.
 102 * @cur_altsetting: the current altsetting.
 103 * @num_altsetting: number of altsettings defined.
 104 * @intf_assoc: interface association descriptor
 105 * @minor: the minor number assigned to this interface, if this
 106 *	interface is bound to a driver that uses the USB major number.
 107 *	If this interface does not use the USB major, this field should
 108 *	be unused.  The driver should set this value in the probe()
 109 *	function of the driver, after it has been assigned a minor
 110 *	number from the USB core by calling usb_register_dev().
 111 * @condition: binding state of the interface: not bound, binding
 112 *	(in probe()), bound to a driver, or unbinding (in disconnect())
 113 * @sysfs_files_created: sysfs attributes exist
 114 * @ep_devs_created: endpoint child pseudo-devices exist
 115 * @unregistering: flag set when the interface is being unregistered
 116 * @needs_remote_wakeup: flag set when the driver requires remote-wakeup
 117 *	capability during autosuspend.
 118 * @needs_altsetting0: flag set when a set-interface request for altsetting 0
 119 *	has been deferred.
 120 * @needs_binding: flag set when the driver should be re-probed or unbound
 121 *	following a reset or suspend operation it doesn't support.
 122 * @dev: driver model's view of this device
 123 * @usb_dev: if an interface is bound to the USB major, this will point
 124 *	to the sysfs representation for that device.
 125 * @pm_usage_cnt: PM usage counter for this interface
 126 * @reset_ws: Used for scheduling resets from atomic context.
 127 * @reset_running: set to 1 if the interface is currently running a
 128 *      queued reset so that usb_cancel_queued_reset() doesn't try to
 129 *      remove from the workqueue when running inside the worker
 130 *      thread. See __usb_queue_reset_device().
 131 * @resetting_device: USB core reset the device, so use alt setting 0 as
 132 *	current; needs bandwidth alloc after reset.
 133 *
 134 * USB device drivers attach to interfaces on a physical device.  Each
 135 * interface encapsulates a single high level function, such as feeding
 136 * an audio stream to a speaker or reporting a change in a volume control.
 137 * Many USB devices only have one interface.  The protocol used to talk to
 138 * an interface's endpoints can be defined in a usb "class" specification,
 139 * or by a product's vendor.  The (default) control endpoint is part of
 140 * every interface, but is never listed among the interface's descriptors.
 141 *
 142 * The driver that is bound to the interface can use standard driver model
 143 * calls such as dev_get_drvdata() on the dev member of this structure.
 144 *
 145 * Each interface may have alternate settings.  The initial configuration
 146 * of a device sets altsetting 0, but the device driver can change
 147 * that setting using usb_set_interface().  Alternate settings are often
 148 * used to control the use of periodic endpoints, such as by having
 149 * different endpoints use different amounts of reserved USB bandwidth.
 150 * All standards-conformant USB devices that use isochronous endpoints
 151 * will use them in non-default settings.
 152 *
 153 * The USB specification says that alternate setting numbers must run from
 154 * 0 to one less than the total number of alternate settings.  But some
 155 * devices manage to mess this up, and the structures aren't necessarily
 156 * stored in numerical order anyhow.  Use usb_altnum_to_altsetting() to
 157 * look up an alternate setting in the altsetting array based on its number.
 158 */
 159struct usb_interface {
 160	/* array of alternate settings for this interface,
 161	 * stored in no particular order */
 162	struct usb_host_interface *altsetting;
 163
 164	struct usb_host_interface *cur_altsetting;	/* the currently
 165					 * active alternate setting */
 166	unsigned num_altsetting;	/* number of alternate settings */
 167
 168	/* If there is an interface association descriptor then it will list
 169	 * the associated interfaces */
 170	struct usb_interface_assoc_descriptor *intf_assoc;
 171
 172	int minor;			/* minor number this interface is
 173					 * bound to */
 174	enum usb_interface_condition condition;		/* state of binding */
 175	unsigned sysfs_files_created:1;	/* the sysfs attributes exist */
 176	unsigned ep_devs_created:1;	/* endpoint "devices" exist */
 177	unsigned unregistering:1;	/* unregistration is in progress */
 178	unsigned needs_remote_wakeup:1;	/* driver requires remote wakeup */
 179	unsigned needs_altsetting0:1;	/* switch to altsetting 0 is pending */
 180	unsigned needs_binding:1;	/* needs delayed unbind/rebind */
 181	unsigned reset_running:1;
 182	unsigned resetting_device:1;	/* true: bandwidth alloc after reset */
 183
 184	struct device dev;		/* interface specific device info */
 185	struct device *usb_dev;
 186	atomic_t pm_usage_cnt;		/* usage counter for autosuspend */
 187	struct work_struct reset_ws;	/* for resets in atomic context */
 188};
 189#define	to_usb_interface(d) container_of(d, struct usb_interface, dev)
 190
 191static inline void *usb_get_intfdata(struct usb_interface *intf)
 192{
 193	return dev_get_drvdata(&intf->dev);
 194}
 195
 196static inline void usb_set_intfdata(struct usb_interface *intf, void *data)
 197{
 198	dev_set_drvdata(&intf->dev, data);
 199}
 200
 201struct usb_interface *usb_get_intf(struct usb_interface *intf);
 202void usb_put_intf(struct usb_interface *intf);
 203
 204/* this maximum is arbitrary */
 205#define USB_MAXINTERFACES	32
 206#define USB_MAXIADS		(USB_MAXINTERFACES/2)
 207
 208/**
 209 * struct usb_interface_cache - long-term representation of a device interface
 210 * @num_altsetting: number of altsettings defined.
 211 * @ref: reference counter.
 212 * @altsetting: variable-length array of interface structures, one for
 213 *	each alternate setting that may be selected.  Each one includes a
 214 *	set of endpoint configurations.  They will be in no particular order.
 215 *
 216 * These structures persist for the lifetime of a usb_device, unlike
 217 * struct usb_interface (which persists only as long as its configuration
 218 * is installed).  The altsetting arrays can be accessed through these
 219 * structures at any time, permitting comparison of configurations and
 220 * providing support for the /proc/bus/usb/devices pseudo-file.
 221 */
 222struct usb_interface_cache {
 223	unsigned num_altsetting;	/* number of alternate settings */
 224	struct kref ref;		/* reference counter */
 225
 226	/* variable-length array of alternate settings for this interface,
 227	 * stored in no particular order */
 228	struct usb_host_interface altsetting[0];
 229};
 230#define	ref_to_usb_interface_cache(r) \
 231		container_of(r, struct usb_interface_cache, ref)
 232#define	altsetting_to_usb_interface_cache(a) \
 233		container_of(a, struct usb_interface_cache, altsetting[0])
 234
 235/**
 236 * struct usb_host_config - representation of a device's configuration
 237 * @desc: the device's configuration descriptor.
 238 * @string: pointer to the cached version of the iConfiguration string, if
 239 *	present for this configuration.
 240 * @intf_assoc: list of any interface association descriptors in this config
 241 * @interface: array of pointers to usb_interface structures, one for each
 242 *	interface in the configuration.  The number of interfaces is stored
 243 *	in desc.bNumInterfaces.  These pointers are valid only while the
 244 *	the configuration is active.
 245 * @intf_cache: array of pointers to usb_interface_cache structures, one
 246 *	for each interface in the configuration.  These structures exist
 247 *	for the entire life of the device.
 248 * @extra: pointer to buffer containing all extra descriptors associated
 249 *	with this configuration (those preceding the first interface
 250 *	descriptor).
 251 * @extralen: length of the extra descriptors buffer.
 252 *
 253 * USB devices may have multiple configurations, but only one can be active
 254 * at any time.  Each encapsulates a different operational environment;
 255 * for example, a dual-speed device would have separate configurations for
 256 * full-speed and high-speed operation.  The number of configurations
 257 * available is stored in the device descriptor as bNumConfigurations.
 258 *
 259 * A configuration can contain multiple interfaces.  Each corresponds to
 260 * a different function of the USB device, and all are available whenever
 261 * the configuration is active.  The USB standard says that interfaces
 262 * are supposed to be numbered from 0 to desc.bNumInterfaces-1, but a lot
 263 * of devices get this wrong.  In addition, the interface array is not
 264 * guaranteed to be sorted in numerical order.  Use usb_ifnum_to_if() to
 265 * look up an interface entry based on its number.
 266 *
 267 * Device drivers should not attempt to activate configurations.  The choice
 268 * of which configuration to install is a policy decision based on such
 269 * considerations as available power, functionality provided, and the user's
 270 * desires (expressed through userspace tools).  However, drivers can call
 271 * usb_reset_configuration() to reinitialize the current configuration and
 272 * all its interfaces.
 273 */
 274struct usb_host_config {
 275	struct usb_config_descriptor	desc;
 276
 277	char *string;		/* iConfiguration string, if present */
 278
 279	/* List of any Interface Association Descriptors in this
 280	 * configuration. */
 281	struct usb_interface_assoc_descriptor *intf_assoc[USB_MAXIADS];
 282
 283	/* the interfaces associated with this configuration,
 284	 * stored in no particular order */
 285	struct usb_interface *interface[USB_MAXINTERFACES];
 286
 287	/* Interface information available even when this is not the
 288	 * active configuration */
 289	struct usb_interface_cache *intf_cache[USB_MAXINTERFACES];
 290
 291	unsigned char *extra;   /* Extra descriptors */
 292	int extralen;
 293};
 294
 295/* USB2.0 and USB3.0 device BOS descriptor set */
 296struct usb_host_bos {
 297	struct usb_bos_descriptor	*desc;
 298
 299	/* wireless cap descriptor is handled by wusb */
 300	struct usb_ext_cap_descriptor	*ext_cap;
 301	struct usb_ss_cap_descriptor	*ss_cap;
 302	struct usb_ss_container_id_descriptor	*ss_id;
 303};
 304
 305int __usb_get_extra_descriptor(char *buffer, unsigned size,
 306	unsigned char type, void **ptr);
 307#define usb_get_extra_descriptor(ifpoint, type, ptr) \
 308				__usb_get_extra_descriptor((ifpoint)->extra, \
 309				(ifpoint)->extralen, \
 310				type, (void **)ptr)
 311
 312/* ----------------------------------------------------------------------- */
 313
 314/* USB device number allocation bitmap */
 315struct usb_devmap {
 316	unsigned long devicemap[128 / (8*sizeof(unsigned long))];
 317};
 318
 319/*
 320 * Allocated per bus (tree of devices) we have:
 321 */
 322struct usb_bus {
 323	struct device *controller;	/* host/master side hardware */
 324	int busnum;			/* Bus number (in order of reg) */
 325	const char *bus_name;		/* stable id (PCI slot_name etc) */
 326	u8 uses_dma;			/* Does the host controller use DMA? */
 327	u8 uses_pio_for_control;	/*
 328					 * Does the host controller use PIO
 329					 * for control transfers?
 330					 */
 331	u8 otg_port;			/* 0, or number of OTG/HNP port */
 332	unsigned is_b_host:1;		/* true during some HNP roleswitches */
 333	unsigned b_hnp_enable:1;	/* OTG: did A-Host enable HNP? */
 334	unsigned hnp_support:1;		/* OTG: HNP is supported on OTG port */
 335	unsigned quick_hnp:1;		/* OTG: Indiacates if hnp is required
 336					   irrespective of host_request flag
 337					 */
 338	unsigned otg_vbus_off:1;	/* OTG: OTG test device feature bit that
 339					 * tells A-device to turn off VBUS after
 340					 * B-device is disconnected.
 341					 */
 342	struct delayed_work hnp_polling;/* OTG: HNP polling work */
 343	unsigned sg_tablesize;		/* 0 or largest number of sg list entries */
 344
 345	int devnum_next;		/* Next open device number in
 346					 * round-robin allocation */
 347
 348	struct usb_devmap devmap;	/* device address allocation map */
 349	struct usb_device *root_hub;	/* Root hub */
 350	struct usb_bus *hs_companion;	/* Companion EHCI bus, if any */
 351	struct list_head bus_list;	/* list of busses */
 352
 353	int bandwidth_allocated;	/* on this bus: how much of the time
 354					 * reserved for periodic (intr/iso)
 355					 * requests is used, on average?
 356					 * Units: microseconds/frame.
 357					 * Limits: Full/low speed reserve 90%,
 358					 * while high speed reserves 80%.
 359					 */
 360	int bandwidth_int_reqs;		/* number of Interrupt requests */
 361	int bandwidth_isoc_reqs;	/* number of Isoc. requests */
 362
 363#ifdef CONFIG_USB_DEVICEFS
 364	struct dentry *usbfs_dentry;	/* usbfs dentry entry for the bus */
 365#endif
 366
 367#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
 368	struct mon_bus *mon_bus;	/* non-null when associated */
 369	int monitored;			/* non-zero when monitored */
 370#endif
 371	unsigned skip_resume:1;		/* All USB devices are brought into full
 372					 * power state after system resume. It
 373					 * is desirable for some buses to keep
 374					 * their devices in suspend state even
 375					 * after system resume. The devices
 376					 * are resumed later when a remote
 377					 * wakeup is detected or an interface
 378					 * driver starts I/O.
 379					 */
 380};
 381
 382/* ----------------------------------------------------------------------- */
 383
 384/* This is arbitrary.
 385 * From USB 2.0 spec Table 11-13, offset 7, a hub can
 386 * have up to 255 ports. The most yet reported is 10.
 387 *
 388 * Current Wireless USB host hardware (Intel i1480 for example) allows
 389 * up to 22 devices to connect. Upcoming hardware might raise that
 390 * limit. Because the arrays need to add a bit for hub status data, we
 391 * do 31, so plus one evens out to four bytes.
 392 */
 393
 394#if defined(CONFIG_USB_PEHCI_HCD) || defined(CONFIG_USB_PEHCI_HCD_MODULE)
 395#define USB_OTG_SUSPEND		0x1
 396#define USB_OTG_ENUMERATE	0x2
 397#define USB_OTG_DISCONNECT	0x4
 398#define USB_OTG_RESUME		0x8
 399#define USB_OTG_REMOTEWAKEUP	0x10
 400#define USB_OTG_WAKEUP_ALL	0x20
 401#endif
 402
 403#define USB_MAXCHILDREN		(31)
 404
 405struct usb_tt;
 406
 407enum usb_device_removable {
 408	USB_DEVICE_REMOVABLE_UNKNOWN = 0,
 409	USB_DEVICE_REMOVABLE,
 410	USB_DEVICE_FIXED,
 411};
 412
 413/**
 414 * struct usb_device - kernel's representation of a USB device
 415 * @devnum: device number; address on a USB bus
 416 * @devpath: device ID string for use in messages (e.g., /port/...)
 417 * @route: tree topology hex string for use with xHCI
 418 * @state: device state: configured, not attached, etc.
 419 * @speed: device speed: high/full/low (or error)
 420 * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub
 421 * @ttport: device port on that tt hub
 422 * @toggle: one bit for each endpoint, with ([0] = IN, [1] = OUT) endpoints
 423 * @parent: our hub, unless we're the root
 424 * @bus: bus we're part of
 425 * @ep0: endpoint 0 data (default control pipe)
 426 * @dev: generic device interface
 427 * @descriptor: USB device descriptor
 428 * @bos: USB device BOS descriptor set
 429 * @config: all of the device's configs
 430 * @actconfig: the active configuration
 431 * @ep_in: array of IN endpoints
 432 * @ep_out: array of OUT endpoints
 433 * @rawdescriptors: raw descriptors for each config
 434 * @bus_mA: Current available from the bus
 435 * @portnum: parent port number (origin 1)
 436 * @level: number of USB hub ancestors
 437 * @can_submit: URBs may be submitted
 438 * @persist_enabled:  USB_PERSIST enabled for this device
 439 * @have_langid: whether string_langid is valid
 440 * @authorized: policy has said we can use it;
 441 *	(user space) policy determines if we authorize this device to be
 442 *	used or not. By default, wired USB devices are authorized.
 443 *	WUSB devices are not, until we authorize them from user space.
 444 *	FIXME -- complete doc
 445 * @authenticated: Crypto authentication passed
 446 * @wusb: device is Wireless USB
 447 * @lpm_capable: device supports LPM
 448 * @usb2_hw_lpm_capable: device can perform USB2 hardware LPM
 449 * @usb2_hw_lpm_enabled: USB2 hardware LPM enabled
 450 * @string_langid: language ID for strings
 451 * @product: iProduct string, if present (static)
 452 * @manufacturer: iManufacturer string, if present (static)
 453 * @serial: iSerialNumber string, if present (static)
 454 * @filelist: usbfs files that are open to this device
 455 * @usb_classdev: USB class device that was created for usbfs device
 456 *	access from userspace
 457 * @usbfs_dentry: usbfs dentry entry for the device
 458 * @maxchild: number of ports if hub
 459 * @children: child devices - USB devices that are attached to this hub
 460 * @quirks: quirks of the whole device
 461 * @urbnum: number of URBs submitted for the whole device
 462 * @active_duration: total time device is not suspended
 463 * @connect_time: time device was first connected
 464 * @do_remote_wakeup:  remote wakeup should be enabled
 465 * @reset_resume: needs reset instead of resume
 466 * @wusb_dev: if this is a Wireless USB device, link to the WUSB
 467 *	specific data for the device.
 468 * @slot_id: Slot ID assigned by xHCI
 469 * @removable: Device can be physically removed from this port
 470 *
 471 * Notes:
 472 * Usbcore drivers should not set usbdev->state directly.  Instead use
 473 * usb_set_device_state().
 474 */
 475struct usb_device {
 476	int		devnum;
 477	char		devpath[16];
 478	u32		route;
 479	enum usb_device_state	state;
 480	enum usb_device_speed	speed;
 481
 482	struct usb_tt	*tt;
 483	int		ttport;
 484
 485	unsigned int toggle[2];
 486
 487	struct usb_device *parent;
 488	struct usb_bus *bus;
 489	struct usb_host_endpoint ep0;
 490
 491	struct device dev;
 492
 493	struct usb_device_descriptor descriptor;
 494	struct usb_host_bos *bos;
 495	struct usb_host_config *config;
 496
 497	struct usb_host_config *actconfig;
 498	struct usb_host_endpoint *ep_in[16];
 499	struct usb_host_endpoint *ep_out[16];
 500
 501	char **rawdescriptors;
 502
 503	unsigned short bus_mA;
 504	u8 portnum;
 505	u8 level;
 506
 507	unsigned can_submit:1;
 508	unsigned persist_enabled:1;
 509	unsigned have_langid:1;
 510	unsigned authorized:1;
 511	unsigned authenticated:1;
 512	unsigned wusb:1;
 513	unsigned lpm_capable:1;
 514	unsigned usb2_hw_lpm_capable:1;
 515	unsigned usb2_hw_lpm_enabled:1;
 516	int string_langid;
 517
 518	/* static strings from the device */
 519	char *product;
 520	char *manufacturer;
 521	char *serial;
 522
 523	struct list_head filelist;
 524#ifdef CONFIG_USB_DEVICE_CLASS
 525	struct device *usb_classdev;
 526#endif
 527#ifdef CONFIG_USB_DEVICEFS
 528	struct dentry *usbfs_dentry;
 529#endif
 530
 531#if defined(CONFIG_USB_PEHCI_HCD) || defined(CONFIG_USB_PEHCI_HCD_MODULE)
 532	/*otg add ons */
 533	u8 otgdevice;				/*device is otg type */
 534
 535	/*otg states from otg driver, suspend, enumerate, disconnect */
 536	u8 otgstate;
 537	void *otgpriv;
 538	void (*otg_notif) (void *otg_priv,
 539				unsigned long notif, unsigned long data);
 540	void *hcd_priv;
 541	void (*hcd_suspend) (void *hcd_priv);
 542#endif
 543	int maxchild;
 544	struct usb_device **children;
 545
 546	u32 quirks;
 547	atomic_t urbnum;
 548
 549	unsigned long active_duration;
 550
 551#ifdef CONFIG_PM
 552	unsigned long connect_time;
 553
 554	unsigned do_remote_wakeup:1;
 555	unsigned reset_resume:1;
 556#endif
 557	struct wusb_dev *wusb_dev;
 558	int slot_id;
 559	enum usb_device_removable removable;
 560};
 561#define	to_usb_device(d) container_of(d, struct usb_device, dev)
 562
 563static inline struct usb_device *interface_to_usbdev(struct usb_interface *intf)
 564{
 565	return to_usb_device(intf->dev.parent);
 566}
 567
 568extern struct usb_device *usb_get_dev(struct usb_device *dev);
 569extern void usb_put_dev(struct usb_device *dev);
 570
 571/* USB device locking */
 572#define usb_lock_device(udev)		device_lock(&(udev)->dev)
 573#define usb_unlock_device(udev)		device_unlock(&(udev)->dev)
 574#define usb_trylock_device(udev)	device_trylock(&(udev)->dev)
 575extern int usb_lock_device_for_reset(struct usb_device *udev,
 576				     const struct usb_interface *iface);
 577
 578/* USB port reset for device reinitialization */
 579extern int usb_reset_device(struct usb_device *dev);
 580extern void usb_queue_reset_device(struct usb_interface *dev);
 581
 582
 583/* USB autosuspend and autoresume */
 584#ifdef CONFIG_USB_SUSPEND
 585extern void usb_enable_autosuspend(struct usb_device *udev);
 586extern void usb_disable_autosuspend(struct usb_device *udev);
 587
 588extern int usb_autopm_get_interface(struct usb_interface *intf);
 589extern void usb_autopm_put_interface(struct usb_interface *intf);
 590extern int usb_autopm_get_interface_async(struct usb_interface *intf);
 591extern void usb_autopm_put_interface_async(struct usb_interface *intf);
 592extern void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
 593extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
 594
 595static inline void usb_mark_last_busy(struct usb_device *udev)
 596{
 597	pm_runtime_mark_last_busy(&udev->dev);
 598}
 599
 600#else
 601
 602static inline int usb_enable_autosuspend(struct usb_device *udev)
 603{ return 0; }
 604static inline int usb_disable_autosuspend(struct usb_device *udev)
 605{ return 0; }
 606
 607static inline int usb_autopm_get_interface(struct usb_interface *intf)
 608{ return 0; }
 609static inline int usb_autopm_get_interface_async(struct usb_interface *intf)
 610{ return 0; }
 611
 612static inline void usb_autopm_put_interface(struct usb_interface *intf)
 613{ }
 614static inline void usb_autopm_put_interface_async(struct usb_interface *intf)
 615{ }
 616static inline void usb_autopm_get_interface_no_resume(
 617		struct usb_interface *intf)
 618{ }
 619static inline void usb_autopm_put_interface_no_suspend(
 620		struct usb_interface *intf)
 621{ }
 622static inline void usb_mark_last_busy(struct usb_device *udev)
 623{ }
 624#endif
 625
 626/*-------------------------------------------------------------------------*/
 627
 628/* for drivers using iso endpoints */
 629extern int usb_get_current_frame_number(struct usb_device *usb_dev);
 630
 631/* Sets up a group of bulk endpoints to support multiple stream IDs. */
 632extern int usb_alloc_streams(struct usb_interface *interface,
 633		struct usb_host_endpoint **eps, unsigned int num_eps,
 634		unsigned int num_streams, gfp_t mem_flags);
 635
 636/* Reverts a group of bulk endpoints back to not using stream IDs. */
 637extern void usb_free_streams(struct usb_interface *interface,
 638		struct usb_host_endpoint **eps, unsigned int num_eps,
 639		gfp_t mem_flags);
 640
 641/* used these for multi-interface device registration */
 642extern int usb_driver_claim_interface(struct usb_driver *driver,
 643			struct usb_interface *iface, void *priv);
 644
 645/**
 646 * usb_interface_claimed - returns true iff an interface is claimed
 647 * @iface: the interface being checked
 648 *
 649 * Returns true (nonzero) iff the interface is claimed, else false (zero).
 650 * Callers must own the driver model's usb bus readlock.  So driver
 651 * probe() entries don't need extra locking, but other call contexts
 652 * may need to explicitly claim that lock.
 653 *
 654 */
 655static inline int usb_interface_claimed(struct usb_interface *iface)
 656{
 657	return (iface->dev.driver != NULL);
 658}
 659
 660extern void usb_driver_release_interface(struct usb_driver *driver,
 661			struct usb_interface *iface);
 662const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 663					 const struct usb_device_id *id);
 664extern int usb_match_one_id(struct usb_interface *interface,
 665			    const struct usb_device_id *id);
 666
 667extern struct usb_interface *usb_find_interface(struct usb_driver *drv,
 668		int minor);
 669extern struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
 670		unsigned ifnum);
 671extern struct usb_host_interface *usb_altnum_to_altsetting(
 672		const struct usb_interface *intf, unsigned int altnum);
 673extern struct usb_host_interface *usb_find_alt_setting(
 674		struct usb_host_config *config,
 675		unsigned int iface_num,
 676		unsigned int alt_num);
 677
 678
 679/**
 680 * usb_make_path - returns stable device path in the usb tree
 681 * @dev: the device whose path is being constructed
 682 * @buf: where to put the string
 683 * @size: how big is "buf"?
 684 *
 685 * Returns length of the string (> 0) or negative if size was too small.
 686 *
 687 * This identifier is intended to be "stable", reflecting physical paths in
 688 * hardware such as physical bus addresses for host controllers or ports on
 689 * USB hubs.  That makes it stay the same until systems are physically
 690 * reconfigured, by re-cabling a tree of USB devices or by moving USB host
 691 * controllers.  Adding and removing devices, including virtual root hubs
 692 * in host controller driver modules, does not change these path identifiers;
 693 * neither does rebooting or re-enumerating.  These are more useful identifiers
 694 * than changeable ("unstable") ones like bus numbers or device addresses.
 695 *
 696 * With a partial exception for devices connected to USB 2.0 root hubs, these
 697 * identifiers are also predictable.  So long as the device tree isn't changed,
 698 * plugging any USB device into a given hub port always gives it the same path.
 699 * Because of the use of "companion" controllers, devices connected to ports on
 700 * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
 701 * high speed, and a different one if they are full or low speed.
 702 */
 703static inline int usb_make_path(struct usb_device *dev, char *buf, size_t size)
 704{
 705	int actual;
 706	actual = snprintf(buf, size, "usb-%s-%s", dev->bus->bus_name,
 707			  dev->devpath);
 708	return (actual >= (int)size) ? -1 : actual;
 709}
 710
 711/*-------------------------------------------------------------------------*/
 712
 713#define USB_DEVICE_ID_MATCH_DEVICE \
 714		(USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
 715#define USB_DEVICE_ID_MATCH_DEV_RANGE \
 716		(USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
 717#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
 718		(USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
 719#define USB_DEVICE_ID_MATCH_DEV_INFO \
 720		(USB_DEVICE_ID_MATCH_DEV_CLASS | \
 721		USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \
 722		USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
 723#define USB_DEVICE_ID_MATCH_INT_INFO \
 724		(USB_DEVICE_ID_MATCH_INT_CLASS | \
 725		USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
 726		USB_DEVICE_ID_MATCH_INT_PROTOCOL)
 727
 728/**
 729 * USB_DEVICE - macro used to describe a specific usb device
 730 * @vend: the 16 bit USB Vendor ID
 731 * @prod: the 16 bit USB Product ID
 732 *
 733 * This macro is used to create a struct usb_device_id that matches a
 734 * specific device.
 735 */
 736#define USB_DEVICE(vend, prod) \
 737	.match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
 738	.idVendor = (vend), \
 739	.idProduct = (prod)
 740/**
 741 * USB_DEVICE_VER - describe a specific usb device with a version range
 742 * @vend: the 16 bit USB Vendor ID
 743 * @prod: the 16 bit USB Product ID
 744 * @lo: the bcdDevice_lo value
 745 * @hi: the bcdDevice_hi value
 746 *
 747 * This macro is used to create a struct usb_device_id that matches a
 748 * specific device, with a version range.
 749 */
 750#define USB_DEVICE_VER(vend, prod, lo, hi) \
 751	.match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, \
 752	.idVendor = (vend), \
 753	.idProduct = (prod), \
 754	.bcdDevice_lo = (lo), \
 755	.bcdDevice_hi = (hi)
 756
 757/**
 758 * USB_DEVICE_INTERFACE_PROTOCOL - describe a usb device with a specific interface protocol
 759 * @vend: the 16 bit USB Vendor ID
 760 * @prod: the 16 bit USB Product ID
 761 * @pr: bInterfaceProtocol value
 762 *
 763 * This macro is used to create a struct usb_device_id that matches a
 764 * specific interface protocol of devices.
 765 */
 766#define USB_DEVICE_INTERFACE_PROTOCOL(vend, prod, pr) \
 767	.match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
 768		       USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
 769	.idVendor = (vend), \
 770	.idProduct = (prod), \
 771	.bInterfaceProtocol = (pr)
 772
 773/**
 774 * USB_DEVICE_INTERFACE_NUMBER - describe a usb device with a specific interface number
 775 * @vend: the 16 bit USB Vendor ID
 776 * @prod: the 16 bit USB Product ID
 777 * @num: bInterfaceNumber value
 778 *
 779 * This macro is used to create a struct usb_device_id that matches a
 780 * specific interface number of devices.
 781 */
 782#define USB_DEVICE_INTERFACE_NUMBER(vend, prod, num) \
 783	.match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
 784		       USB_DEVICE_ID_MATCH_INT_NUMBER, \
 785	.idVendor = (vend), \
 786	.idProduct = (prod), \
 787	.bInterfaceNumber = (num)
 788
 789/**
 790 * USB_DEVICE_INFO - macro used to describe a class of usb devices
 791 * @cl: bDeviceClass value
 792 * @sc: bDeviceSubClass value
 793 * @pr: bDeviceProtocol value
 794 *
 795 * This macro is used to create a struct usb_device_id that matches a
 796 * specific class of devices.
 797 */
 798#define USB_DEVICE_INFO(cl, sc, pr) \
 799	.match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, \
 800	.bDeviceClass = (cl), \
 801	.bDeviceSubClass = (sc), \
 802	.bDeviceProtocol = (pr)
 803
 804/**
 805 * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces
 806 * @cl: bInterfaceClass value
 807 * @sc: bInterfaceSubClass value
 808 * @pr: bInterfaceProtocol value
 809 *
 810 * This macro is used to create a struct usb_device_id that matches a
 811 * specific class of interfaces.
 812 */
 813#define USB_INTERFACE_INFO(cl, sc, pr) \
 814	.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \
 815	.bInterfaceClass = (cl), \
 816	.bInterfaceSubClass = (sc), \
 817	.bInterfaceProtocol = (pr)
 818
 819/**
 820 * USB_DEVICE_AND_INTERFACE_INFO - describe a specific usb device with a class of usb interfaces
 821 * @vend: the 16 bit USB Vendor ID
 822 * @prod: the 16 bit USB Product ID
 823 * @cl: bInterfaceClass value
 824 * @sc: bInterfaceSubClass value
 825 * @pr: bInterfaceProtocol value
 826 *
 827 * This macro is used to create a struct usb_device_id that matches a
 828 * specific device with a specific class of interfaces.
 829 *
 830 * This is especially useful when explicitly matching devices that have
 831 * vendor specific bDeviceClass values, but standards-compliant interfaces.
 832 */
 833#define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, cl, sc, pr) \
 834	.match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
 835		| USB_DEVICE_ID_MATCH_DEVICE, \
 836	.idVendor = (vend), \
 837	.idProduct = (prod), \
 838	.bInterfaceClass = (cl), \
 839	.bInterfaceSubClass = (sc), \
 840	.bInterfaceProtocol = (pr)
 841
 842/* ----------------------------------------------------------------------- */
 843
 844/* Stuff for dynamic usb ids */
 845struct usb_dynids {
 846	spinlock_t lock;
 847	struct list_head list;
 848};
 849
 850struct usb_dynid {
 851	struct list_head node;
 852	struct usb_device_id id;
 853};
 854
 855extern ssize_t usb_store_new_id(struct usb_dynids *dynids,
 856				struct device_driver *driver,
 857				const char *buf, size_t count);
 858
 859/**
 860 * struct usbdrv_wrap - wrapper for driver-model structure
 861 * @driver: The driver-model core driver structure.
 862 * @for_devices: Non-zero for device drivers, 0 for interface drivers.
 863 */
 864struct usbdrv_wrap {
 865	struct device_driver driver;
 866	int for_devices;
 867};
 868
 869/**
 870 * struct usb_driver - identifies USB interface driver to usbcore
 871 * @name: The driver name should be unique among USB drivers,
 872 *	and should normally be the same as the module name.
 873 * @probe: Called to see if the driver is willing to manage a particular
 874 *	interface on a device.  If it is, probe returns zero and uses
 875 *	usb_set_intfdata() to associate driver-specific data with the
 876 *	interface.  It may also use usb_set_interface() to specify the
 877 *	appropriate altsetting.  If unwilling to manage the interface,
 878 *	return -ENODEV, if genuine IO errors occurred, an appropriate
 879 *	negative errno value.
 880 * @disconnect: Called when the interface is no longer accessible, usually
 881 *	because its device has been (or is being) disconnected or the
 882 *	driver module is being unloaded.
 883 * @unlocked_ioctl: Used for drivers that want to talk to userspace through
 884 *	the "usbfs" filesystem.  This lets devices provide ways to
 885 *	expose information to user space regardless of where they
 886 *	do (or don't) show up otherwise in the filesystem.
 887 * @suspend: Called when the device is going to be suspended by the system.
 888 * @resume: Called when the device is being resumed by the system.
 889 * @reset_resume: Called when the suspended device has been reset instead
 890 *	of being resumed.
 891 * @pre_reset: Called by usb_reset_device() when the device is about to be
 892 *	reset.  This routine must not return until the driver has no active
 893 *	URBs for the device, and no more URBs may be submitted until the
 894 *	post_reset method is called.
 895 * @post_reset: Called by usb_reset_device() after the device
 896 *	has been reset
 897 * @id_table: USB drivers use ID table to support hotplugging.
 898 *	Export this with MODULE_DEVICE_TABLE(usb,...).  This must be set
 899 *	or your driver's probe function will never get called.
 900 * @dynids: used internally to hold the list of dynamically added device
 901 *	ids for this driver.
 902 * @drvwrap: Driver-model core structure wrapper.
 903 * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
 904 *	added to this driver by preventing the sysfs file from being created.
 905 * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
 906 *	for interfaces bound to this driver.
 907 * @soft_unbind: if set to 1, the USB core will not kill URBs and disable
 908 *	endpoints before calling the driver's disconnect method.
 909 *
 910 * USB interface drivers must provide a name, probe() and disconnect()
 911 * methods, and an id_table.  Other driver fields are optional.
 912 *
 913 * The id_table is used in hotplugging.  It holds a set of descriptors,
 914 * and specialized data may be associated with each entry.  That table
 915 * is used by both user and kernel mode hotplugging support.
 916 *
 917 * The probe() and disconnect() methods are called in a context where
 918 * they can sleep, but they should avoid abusing the privilege.  Most
 919 * work to connect to a device should be done when the device is opened,
 920 * and undone at the last close.  The disconnect code needs to address
 921 * concurrency issues with respect to open() and close() methods, as
 922 * well as forcing all pending I/O requests to complete (by unlinking
 923 * them as necessary, and blocking until the unlinks complete).
 924 */
 925struct usb_driver {
 926	const char *name;
 927
 928	int (*probe) (struct usb_interface *intf,
 929		      const struct usb_device_id *id);
 930
 931	void (*disconnect) (struct usb_interface *intf);
 932
 933	int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
 934			void *buf);
 935
 936	int (*suspend) (struct usb_interface *intf, pm_message_t message);
 937	int (*resume) (struct usb_interface *intf);
 938	int (*reset_resume)(struct usb_interface *intf);
 939
 940	int (*pre_reset)(struct usb_interface *intf);
 941	int (*post_reset)(struct usb_interface *intf);
 942
 943	const struct usb_device_id *id_table;
 944
 945	struct usb_dynids dynids;
 946	struct usbdrv_wrap drvwrap;
 947	unsigned int no_dynamic_id:1;
 948	unsigned int supports_autosuspend:1;
 949	unsigned int soft_unbind:1;
 950};
 951#define	to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)
 952
 953/**
 954 * struct usb_device_driver - identifies USB device driver to usbcore
 955 * @name: The driver name should be unique among USB drivers,
 956 *	and should normally be the same as the module name.
 957 * @probe: Called to see if the driver is willing to manage a particular
 958 *	device.  If it is, probe returns zero and uses dev_set_drvdata()
 959 *	to associate driver-specific data with the device.  If unwilling
 960 *	to manage the device, return a negative errno value.
 961 * @disconnect: Called when the device is no longer accessible, usually
 962 *	because it has been (or is being) disconnected or the driver's
 963 *	module is being unloaded.
 964 * @suspend: Called when the device is going to be suspended by the system.
 965 * @resume: Called when the device is being resumed by the system.
 966 * @drvwrap: Driver-model core structure wrapper.
 967 * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
 968 *	for devices bound to this driver.
 969 *
 970 * USB drivers must provide all the fields listed above except drvwrap.
 971 */
 972struct usb_device_driver {
 973	const char *name;
 974
 975	int (*probe) (struct usb_device *udev);
 976	void (*disconnect) (struct usb_device *udev);
 977
 978	int (*suspend) (struct usb_device *udev, pm_message_t message);
 979	int (*resume) (struct usb_device *udev, pm_message_t message);
 980	struct usbdrv_wrap drvwrap;
 981	unsigned int supports_autosuspend:1;
 982};
 983#define	to_usb_device_driver(d) container_of(d, struct usb_device_driver, \
 984		drvwrap.driver)
 985
 986extern struct bus_type usb_bus_type;
 987
 988/**
 989 * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
 990 * @name: the usb class device name for this driver.  Will show up in sysfs.
 991 * @devnode: Callback to provide a naming hint for a possible
 992 *	device node to create.
 993 * @fops: pointer to the struct file_operations of this driver.
 994 * @minor_base: the start of the minor range for this driver.
 995 *
 996 * This structure is used for the usb_register_dev() and
 997 * usb_unregister_dev() functions, to consolidate a number of the
 998 * parameters used for them.
 999 */
1000struct usb_class_driver {
1001	char *name;
1002	char *(*devnode)(struct device *dev, umode_t *mode);
1003	const struct file_operations *fops;
1004	int minor_base;
1005};
1006
1007/*
1008 * use these in module_init()/module_exit()
1009 * and don't forget MODULE_DEVICE_TABLE(usb, ...)
1010 */
1011extern int usb_register_driver(struct usb_driver *, struct module *,
1012			       const char *);
1013
1014/* use a define to avoid include chaining to get THIS_MODULE & friends */
1015#define usb_register(driver) \
1016	usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
1017
1018extern void usb_deregister(struct usb_driver *);
1019
1020/**
1021 * module_usb_driver() - Helper macro for registering a USB driver
1022 * @__usb_driver: usb_driver struct
1023 *
1024 * Helper macro for USB drivers which do not do anything special in module
1025 * init/exit. This eliminates a lot of boilerplate. Each module may only
1026 * use this macro once, and calling it replaces module_init() and module_exit()
1027 */
1028#define module_usb_driver(__usb_driver) \
1029	module_driver(__usb_driver, usb_register, \
1030		       usb_deregister)
1031
1032extern int usb_register_device_driver(struct usb_device_driver *,
1033			struct module *);
1034extern void usb_deregister_device_driver(struct usb_device_driver *);
1035
1036extern int usb_register_dev(struct usb_interface *intf,
1037			    struct usb_class_driver *class_driver);
1038extern void usb_deregister_dev(struct usb_interface *intf,
1039			       struct usb_class_driver *class_driver);
1040
1041extern int usb_disabled(void);
1042
1043/* ----------------------------------------------------------------------- */
1044
1045/*
1046 * URB support, for asynchronous request completions
1047 */
1048
1049/*
1050 * urb->transfer_flags:
1051 *
1052 * Note: URB_DIR_IN/OUT is automatically set in usb_submit_urb().
1053 */
1054#define URB_SHORT_NOT_OK	0x0001	/* report short reads as errors */
1055#define URB_ISO_ASAP		0x0002	/* iso-only, urb->start_frame
1056					 * ignored */
1057#define URB_NO_TRANSFER_DMA_MAP	0x0004	/* urb->transfer_dma valid on submit */
1058#define URB_NO_FSBR		0x0020	/* UHCI-specific */
1059#define URB_ZERO_PACKET		0x0040	/* Finish bulk OUT with short packet */
1060#define URB_NO_INTERRUPT	0x0080	/* HINT: no non-error interrupt
1061					 * needed */
1062#define URB_FREE_BUFFER		0x0100	/* Free transfer buffer with the URB */
1063
1064/* The following flags are used internally by usbcore and HCDs */
1065#define URB_DIR_IN		0x0200	/* Transfer from device to host */
1066#define URB_DIR_OUT		0
1067#define URB_DIR_MASK		URB_DIR_IN
1068
1069#define URB_DMA_MAP_SINGLE	0x00010000	/* Non-scatter-gather mapping */
1070#define URB_DMA_MAP_PAGE	0x00020000	/* HCD-unsupported S-G */
1071#define URB_DMA_MAP_SG		0x00040000	/* HCD-supported S-G */
1072#define URB_MAP_LOCAL		0x00080000	/* HCD-local-memory mapping */
1073#define URB_SETUP_MAP_SINGLE	0x00100000	/* Setup packet DMA mapped */
1074#define URB_SETUP_MAP_LOCAL	0x00200000	/* HCD-local setup packet */
1075#define URB_DMA_SG_COMBINED	0x00400000	/* S-G entries were combined */
1076#define URB_ALIGNED_TEMP_BUFFER	0x00800000	/* Temp buffer was alloc'd */
1077
1078struct usb_iso_packet_descriptor {
1079	unsigned int offset;
1080	unsigned int length;		/* expected length */
1081	unsigned int actual_length;
1082	int status;
1083};
1084
1085struct urb;
1086
1087struct usb_anchor {
1088	struct list_head urb_list;
1089	wait_queue_head_t wait;
1090	spinlock_t lock;
1091	unsigned int poisoned:1;
1092};
1093
1094static inline void init_usb_anchor(struct usb_anchor *anchor)
1095{
1096	INIT_LIST_HEAD(&anchor->urb_list);
1097	init_waitqueue_head(&anchor->wait);
1098	spin_lock_init(&anchor->lock);
1099}
1100
1101typedef void (*usb_complete_t)(struct urb *);
1102
1103/**
1104 * struct urb - USB Request Block
1105 * @urb_list: For use by current owner of the URB.
1106 * @anchor_list: membership in the list of an anchor
1107 * @anchor: to anchor URBs to a common mooring
1108 * @ep: Points to the endpoint's data structure.  Will eventually
1109 *	replace @pipe.
1110 * @pipe: Holds endpoint number, direction, type, and more.
1111 *	Create these values with the eight macros available;
1112 *	usb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"
1113 *	(control), "bulk", "int" (interrupt), or "iso" (isochronous).
1114 *	For example usb_sndbulkpipe() or usb_rcvintpipe().  Endpoint
1115 *	numbers range from zero to fifteen.  Note that "in" endpoint two
1116 *	is a different endpoint (and pipe) from "out" endpoint two.
1117 *	The current configuration controls the existence, type, and
1118 *	maximum packet size of any given endpoint.
1119 * @stream_id: the endpoint's stream ID for bulk streams
1120 * @dev: Identifies the USB device to perform the request.
1121 * @status: This is read in non-iso completion functions to get the
1122 *	status of the particular request.  ISO requests only use it
1123 *	to tell whether the URB was unlinked; detailed status for
1124 *	each frame is in the fields of the iso_frame-desc.
1125 * @transfer_flags: A variety of flags may be used to affect how URB
1126 *	submission, unlinking, or operation are handled.  Different
1127 *	kinds of URB can use different flags.
1128 * @transfer_buffer:  This identifies the buffer to (or from) which the I/O
1129 *	request will be performed unless URB_NO_TRANSFER_DMA_MAP is set
1130 *	(however, do not leave garbage in transfer_buffer even then).
1131 *	This buffer must be suitable for DMA; allocate it with
1132 *	kmalloc() or equivalent.  For transfers to "in" endpoints, contents
1133 *	of this buffer will be modified.  This buffer is used for the data
1134 *	stage of control transfers.
1135 * @transfer_dma: When transfer_flags includes URB_NO_TRANSFER_DMA_MAP,
1136 *	the device driver is saying that it provided this DMA address,
1137 *	which the host controller driver should use in preference to the
1138 *	transfer_buffer.
1139 * @sg: scatter gather buffer list
1140 * @num_mapped_sgs: (internal) number of mapped sg entries
1141 * @num_sgs: number of entries in the sg list
1142 * @transfer_buffer_length: How big is transfer_buffer.  The transfer may
1143 *	be broken up into chunks according to the current maximum packet
1144 *	size for the endpoint, which is a function of the configuration
1145 *	and is encoded in the pipe.  When the length is zero, neither
1146 *	transfer_buffer nor transfer_dma is used.
1147 * @actual_length: This is read in non-iso completion functions, and
1148 *	it tells how many bytes (out of transfer_buffer_length) were
1149 *	transferred.  It will normally be the same as requested, unless
1150 *	either an error was reported or a short read was performed.
1151 *	The URB_SHORT_NOT_OK transfer flag may be used to make such
1152 *	short reads be reported as errors.
1153 * @setup_packet: Only used for control transfers, this points to eight bytes
1154 *	of setup data.  Control transfers always start by sending this data
1155 *	to the device.  Then transfer_buffer is read or written, if needed.
1156 * @setup_dma: DMA pointer for the setup packet.  The caller must not use
1157 *	this field; setup_packet must point to a valid buffer.
1158 * @start_frame: Returns the initial frame for isochronous transfers.
1159 * @number_of_packets: Lists the number of ISO transfer buffers.
1160 * @interval: Specifies the polling interval for interrupt or isochronous
1161 *	transfers.  The units are frames (milliseconds) for full and low
1162 *	speed devices, and microframes (1/8 millisecond) for highspeed
1163 *	and SuperSpeed devices.
1164 * @error_count: Returns the number of ISO transfers that reported errors.
1165 * @context: For use in completion functions.  This normally points to
1166 *	request-specific driver context.
1167 * @complete: Completion handler. This URB is passed as the parameter to the
1168 *	completion function.  The completion function may then do what
1169 *	it likes with the URB, including resubmitting or freeing it.
1170 * @iso_frame_desc: Used to provide arrays of ISO transfer buffers and to
1171 *	collect the transfer status for each buffer.
1172 *
1173 * This structure identifies USB transfer requests.  URBs must be allocated by
1174 * calling usb_alloc_urb() and freed with a call to usb_free_urb().
1175 * Initialization may be done using various usb_fill_*_urb() functions.  URBs
1176 * are submitted using usb_submit_urb(), and pending requests may be canceled
1177 * using usb_unlink_urb() or usb_kill_urb().
1178 *
1179 * Data Transfer Buffers:
1180 *
1181 * Normally drivers provide I/O buffers allocated with kmalloc() or otherwise
1182 * taken from the general page pool.  That is provided by transfer_buffer
1183 * (control requests also use setup_packet), and host controller drivers
1184 * perform a dma mapping (and unmapping) for each buffer transferred.  Those
1185 * mapping operations can be expensive on some platforms (perhaps using a dma
1186 * bounce buffer or talking to an IOMMU),
1187 * although they're cheap on commodity x86 and ppc hardware.
1188 *
1189 * Alternatively, drivers may pass the URB_NO_TRANSFER_DMA_MAP transfer flag,
1190 * which tells the host controller driver that no such mapping is needed for
1191 * the transfer_buffer since
1192 * the device driver is DMA-aware.  For example, a device driver might
1193 * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map().
1194 * When this transfer flag is provided, host controller drivers will
1195 * attempt to use the dma address found in the transfer_dma
1196 * field rather than determining a dma address themselves.
1197 *
1198 * Note that transfer_buffer must still be set if the controller
1199 * does not support DMA (as indicated by bus.uses_dma) and when talking
1200 * to root hub. If you have to trasfer between highmem zone and the device
1201 * on such controller, create a bounce buffer or bail out with an error.
1202 * If transfer_buffer cannot be set (is in highmem) and the controller is DMA
1203 * capable, assign NULL to it, so that usbmon knows not to use the value.
1204 * The setup_packet must always be set, so it cannot be located in highmem.
1205 *
1206 * Initialization:
1207 *
1208 * All URBs submitted must initialize the dev, pipe, transfer_flags (may be
1209 * zero), and complete fields.  All URBs must also initialize
1210 * transfer_buffer and transfer_buffer_length.  They may provide the
1211 * URB_SHORT_NOT_OK transfer flag, indicating that short reads are
1212 * to be treated as errors; that flag is invalid for write requests.
1213 *
1214 * Bulk URBs may
1215 * use the URB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
1216 * should always terminate with a short packet, even if it means adding an
1217 * extra zero length packet.
1218 *
1219 * Control URBs must provide a valid pointer in the setup_packet field.
1220 * Unlike the transfer_buffer, the setup_packet may not be mapped for DMA
1221 * beforehand.
1222 *
1223 * Interrupt URBs must provide an interval, saying how often (in milliseconds
1224 * or, for highspeed devices, 125 microsecond units)
1225 * to poll for transfers.  After the URB has been submitted, the interval
1226 * field reflects how the transfer was actually scheduled.
1227 * The polling interval may be more frequent than requested.
1228 * For example, some controllers have a maximum interval of 32 milliseconds,
1229 * while others support intervals of up to 1024 milliseconds.
1230 * Isochronous URBs also have transfer intervals.  (Note that for isochronous
1231 * endpoints, as well as high speed interrupt endpoints, the encoding of
1232 * the transfer interval in the endpoint descriptor is logarithmic.
1233 * Device drivers must convert that value to linear units themselves.)
1234 *
1235 * Isochronous URBs normally use the URB_ISO_ASAP transfer flag, telling
1236 * the host controller to schedule the transfer as soon as bandwidth
1237 * utilization allows, and then set start_frame to reflect the actual frame
1238 * selected during submission.  Otherwise drivers must specify the start_frame
1239 * and handle the case where the transfer can't begin then.  However, drivers
1240 * won't know how bandwidth is currently allocated, and while they can
1241 * find the current frame using usb_get_current_frame_number () they can't
1242 * know the range for that frame number.  (Ranges for frame counter values
1243 * are HC-specific, and can go from 256 to 65536 frames from "now".)
1244 *
1245 * Isochronous URBs have a different data transfer model, in part because
1246 * the quality of service is only "best effort".  Callers provide specially
1247 * allocated URBs, with number_of_packets worth of iso_frame_desc structures
1248 * at the end.  Each such packet is an individual ISO transfer.  Isochronous
1249

Large files files are truncated, but you can click here to view the full file