| 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>
|
| 14 | #include <linux/delay.h>
|
| 15 | #include <linux/interrupt.h>
|
| 16 | #include <linux/list.h>
|
| 17 | #include <linux/kref.h>
|
| 18 | #include <linux/device.h>
|
| 19 | #include <linux/fs.h>
|
| 20 | #include <linux/completion.h>
|
| 21 | #include <linux/sched.h>
|
| 22 | #include <linux/mutex.h>
|
| 23 | #include <linux/pm_runtime.h>
|
| 24 |
|
| 25 | struct usb_device;
|
| 26 | struct usb_driver;
|
| 27 | struct 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 |
|
| 47 | struct 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 | * @ssp_isoc_ep_comp: SuperSpeedPlus isoc companion descriptor for this endpoint
|
| 54 | * @urb_list: urbs queued to this endpoint; maintained by usbcore
|
| 55 | * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
|
| 56 | * with one or more transfer descriptors (TDs) per urb
|
| 57 | * @ep_dev: ep_device for sysfs info
|
| 58 | * @extra: descriptors following this endpoint in the configuration
|
| 59 | * @extralen: how many bytes of "extra" are valid
|
| 60 | * @enabled: URBs may be submitted to this endpoint
|
| 61 | * @streams: number of USB-3 streams allocated on the endpoint
|
| 62 | *
|
| 63 | * USB requests are always queued to a given endpoint, identified by a
|
| 64 | * descriptor within an active interface in a given USB configuration.
|
| 65 |
|
| 66 | struct usb_host_endpoint {
|
| 67 | struct usb_endpoint_descriptor desc;
|
| 68 | struct usb_ss_ep_comp_descriptor ss_ep_comp;
|
| 69 | struct usb_ssp_isoc_ep_comp_descriptor ssp_isoc_ep_comp;
|
| 70 | struct list_head urb_list;
|
| 71 | void *hcpriv;
|
| 72 | struct ep_device *ep_dev;
|
| 73 |
|
| 74 | unsigned char *extra;
|
| 75 | int extralen;
|
| 76 | int enabled;
|
| 77 | int streams;
|
| 78 | };
|
| 79 |
|
| 80 |
|
| 81 | struct usb_host_interface {
|
| 82 | struct usb_interface_descriptor desc;
|
| 83 |
|
| 84 | int extralen;
|
| 85 | unsigned char *extra;
|
| 86 |
|
| 87 | |
| 88 | * interface setting. these will be in no particular order.
|
| 89 |
|
| 90 | struct usb_host_endpoint *endpoint;
|
| 91 |
|
| 92 | char *string;
|
| 93 | };
|
| 94 |
|
| 95 | enum usb_interface_condition {
|
| 96 | USB_INTERFACE_UNBOUND = 0,
|
| 97 | USB_INTERFACE_BINDING,
|
| 98 | USB_INTERFACE_BOUND,
|
| 99 | USB_INTERFACE_UNBINDING,
|
| 100 | };
|
| 101 |
|
| 102 | int __must_check
|
| 103 | usb_find_common_endpoints(struct usb_host_interface *alt,
|
| 104 | struct usb_endpoint_descriptor **bulk_in,
|
| 105 | struct usb_endpoint_descriptor **bulk_out,
|
| 106 | struct usb_endpoint_descriptor **int_in,
|
| 107 | struct usb_endpoint_descriptor **int_out);
|
| 108 |
|
| 109 | int __must_check
|
| 110 | usb_find_common_endpoints_reverse(struct usb_host_interface *alt,
|
| 111 | struct usb_endpoint_descriptor **bulk_in,
|
| 112 | struct usb_endpoint_descriptor **bulk_out,
|
| 113 | struct usb_endpoint_descriptor **int_in,
|
| 114 | struct usb_endpoint_descriptor **int_out);
|
| 115 |
|
| 116 | static inline int __must_check
|
| 117 | usb_find_bulk_in_endpoint(struct usb_host_interface *alt,
|
| 118 | struct usb_endpoint_descriptor **bulk_in)
|
| 119 | {
|
| 120 | return usb_find_common_endpoints(alt, bulk_in, NULL, NULL, NULL);
|
| 121 | }
|
| 122 |
|
| 123 | static inline int __must_check
|
| 124 | usb_find_bulk_out_endpoint(struct usb_host_interface *alt,
|
| 125 | struct usb_endpoint_descriptor **bulk_out)
|
| 126 | {
|
| 127 | return usb_find_common_endpoints(alt, NULL, bulk_out, NULL, NULL);
|
| 128 | }
|
| 129 |
|
| 130 | static inline int __must_check
|
| 131 | usb_find_int_in_endpoint(struct usb_host_interface *alt,
|
| 132 | struct usb_endpoint_descriptor **int_in)
|
| 133 | {
|
| 134 | return usb_find_common_endpoints(alt, NULL, NULL, int_in, NULL);
|
| 135 | }
|
| 136 |
|
| 137 | static inline int __must_check
|
| 138 | usb_find_int_out_endpoint(struct usb_host_interface *alt,
|
| 139 | struct usb_endpoint_descriptor **int_out)
|
| 140 | {
|
| 141 | return usb_find_common_endpoints(alt, NULL, NULL, NULL, int_out);
|
| 142 | }
|
| 143 |
|
| 144 | static inline int __must_check
|
| 145 | usb_find_last_bulk_in_endpoint(struct usb_host_interface *alt,
|
| 146 | struct usb_endpoint_descriptor **bulk_in)
|
| 147 | {
|
| 148 | return usb_find_common_endpoints_reverse(alt, bulk_in, NULL, NULL, NULL);
|
| 149 | }
|
| 150 |
|
| 151 | static inline int __must_check
|
| 152 | usb_find_last_bulk_out_endpoint(struct usb_host_interface *alt,
|
| 153 | struct usb_endpoint_descriptor **bulk_out)
|
| 154 | {
|
| 155 | return usb_find_common_endpoints_reverse(alt, NULL, bulk_out, NULL, NULL);
|
| 156 | }
|
| 157 |
|
| 158 | static inline int __must_check
|
| 159 | usb_find_last_int_in_endpoint(struct usb_host_interface *alt,
|
| 160 | struct usb_endpoint_descriptor **int_in)
|
| 161 | {
|
| 162 | return usb_find_common_endpoints_reverse(alt, NULL, NULL, int_in, NULL);
|
| 163 | }
|
| 164 |
|
| 165 | static inline int __must_check
|
| 166 | usb_find_last_int_out_endpoint(struct usb_host_interface *alt,
|
| 167 | struct usb_endpoint_descriptor **int_out)
|
| 168 | {
|
| 169 | return usb_find_common_endpoints_reverse(alt, NULL, NULL, NULL, int_out);
|
| 170 | }
|
| 171 |
|
| 172 | |
| 173 | * struct usb_interface - what usb device drivers talk to
|
| 174 | * @altsetting: array of interface structures, one for each alternate
|
| 175 | * setting that may be selected. Each one includes a set of
|
| 176 | * endpoint configurations. They will be in no particular order.
|
| 177 | * @cur_altsetting: the current altsetting.
|
| 178 | * @num_altsetting: number of altsettings defined.
|
| 179 | * @intf_assoc: interface association descriptor
|
| 180 | * @minor: the minor number assigned to this interface, if this
|
| 181 | * interface is bound to a driver that uses the USB major number.
|
| 182 | * If this interface does not use the USB major, this field should
|
| 183 | * be unused. The driver should set this value in the probe()
|
| 184 | * function of the driver, after it has been assigned a minor
|
| 185 | * number from the USB core by calling usb_register_dev().
|
| 186 | * @condition: binding state of the interface: not bound, binding
|
| 187 | * (in probe()), bound to a driver, or unbinding (in disconnect())
|
| 188 | * @sysfs_files_created: sysfs attributes exist
|
| 189 | * @ep_devs_created: endpoint child pseudo-devices exist
|
| 190 | * @unregistering: flag set when the interface is being unregistered
|
| 191 | * @needs_remote_wakeup: flag set when the driver requires remote-wakeup
|
| 192 | * capability during autosuspend.
|
| 193 | * @needs_altsetting0: flag set when a set-interface request for altsetting 0
|
| 194 | * has been deferred.
|
| 195 | * @needs_binding: flag set when the driver should be re-probed or unbound
|
| 196 | * following a reset or suspend operation it doesn't support.
|
| 197 | * @authorized: This allows to (de)authorize individual interfaces instead
|
| 198 | * a whole device in contrast to the device authorization.
|
| 199 | * @dev: driver model's view of this device
|
| 200 | * @usb_dev: if an interface is bound to the USB major, this will point
|
| 201 | * to the sysfs representation for that device.
|
| 202 | * @pm_usage_cnt: PM usage counter for this interface
|
| 203 | * @reset_ws: Used for scheduling resets from atomic context.
|
| 204 | * @resetting_device: USB core reset the device, so use alt setting 0 as
|
| 205 | * current; needs bandwidth alloc after reset.
|
| 206 | *
|
| 207 | * USB device drivers attach to interfaces on a physical device. Each
|
| 208 | * interface encapsulates a single high level function, such as feeding
|
| 209 | * an audio stream to a speaker or reporting a change in a volume control.
|
| 210 | * Many USB devices only have one interface. The protocol used to talk to
|
| 211 | * an interface's endpoints can be defined in a usb "class" specification,
|
| 212 | * or by a product's vendor. The (default) control endpoint is part of
|
| 213 | * every interface, but is never listed among the interface's descriptors.
|
| 214 | *
|
| 215 | * The driver that is bound to the interface can use standard driver model
|
| 216 | * calls such as dev_get_drvdata() on the dev member of this structure.
|
| 217 | *
|
| 218 | * Each interface may have alternate settings. The initial configuration
|
| 219 | * of a device sets altsetting 0, but the device driver can change
|
| 220 | * that setting using usb_set_interface(). Alternate settings are often
|
| 221 | * used to control the use of periodic endpoints, such as by having
|
| 222 | * different endpoints use different amounts of reserved USB bandwidth.
|
| 223 | * All standards-conformant USB devices that use isochronous endpoints
|
| 224 | * will use them in non-default settings.
|
| 225 | *
|
| 226 | * The USB specification says that alternate setting numbers must run from
|
| 227 | * 0 to one less than the total number of alternate settings. But some
|
| 228 | * devices manage to mess this up, and the structures aren't necessarily
|
| 229 | * stored in numerical order anyhow. Use usb_altnum_to_altsetting() to
|
| 230 | * look up an alternate setting in the altsetting array based on its number.
|
| 231 |
|
| 232 | struct usb_interface {
|
| 233 | |
| 234 | * stored in no particular order
|
| 235 | struct usb_host_interface *altsetting;
|
| 236 |
|
| 237 | struct usb_host_interface *cur_altsetting; |
| 238 | * active alternate setting
|
| 239 | unsigned num_altsetting;
|
| 240 |
|
| 241 | |
| 242 | * the associated interfaces
|
| 243 | struct usb_interface_assoc_descriptor *intf_assoc;
|
| 244 |
|
| 245 | int minor; |
| 246 | * bound to
|
| 247 | enum usb_interface_condition condition;
|
| 248 | unsigned sysfs_files_created:1;
|
| 249 | unsigned ep_devs_created:1;
|
| 250 | unsigned unregistering:1;
|
| 251 | unsigned needs_remote_wakeup:1;
|
| 252 | unsigned needs_altsetting0:1;
|
| 253 | unsigned needs_binding:1;
|
| 254 | unsigned resetting_device:1;
|
| 255 | unsigned authorized:1;
|
| 256 |
|
| 257 | struct device dev;
|
| 258 | struct device *usb_dev;
|
| 259 | atomic_t pm_usage_cnt;
|
| 260 | struct work_struct reset_ws;
|
| 261 | };
|
| 262 | #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
|
| 263 |
|
| 264 | static inline void *usb_get_intfdata(struct usb_interface *intf)
|
| 265 | {
|
| 266 | return dev_get_drvdata(&intf->dev);
|
| 267 | }
|
| 268 |
|
| 269 | static inline void usb_set_intfdata(struct usb_interface *intf, void *data)
|
| 270 | {
|
| 271 | dev_set_drvdata(&intf->dev, data);
|
| 272 | }
|
| 273 |
|
| 274 | struct usb_interface *usb_get_intf(struct usb_interface *intf);
|
| 275 | void usb_put_intf(struct usb_interface *intf);
|
| 276 |
|
| 277 |
|
| 278 | #define USB_MAXENDPOINTS 30
|
| 279 |
|
| 280 | #define USB_MAXINTERFACES 32
|
| 281 | #define USB_MAXIADS (USB_MAXINTERFACES/2)
|
| 282 |
|
| 283 | |
| 284 | * USB Resume Timer: Every Host controller driver should drive the resume
|
| 285 | * signalling on the bus for the amount of time defined by this macro.
|
| 286 | *
|
| 287 | * That way we will have a 'stable' behavior among all HCDs supported by Linux.
|
| 288 | *
|
| 289 | * Note that the USB Specification states we should drive resume for *at least*
|
| 290 | * 20 ms, but it doesn't give an upper bound. This creates two possible
|
| 291 | * situations which we want to avoid:
|
| 292 | *
|
| 293 | * (a) sometimes an msleep(20) might expire slightly before 20 ms, which causes
|
| 294 | * us to fail USB Electrical Tests, thus failing Certification
|
| 295 | *
|
| 296 | * (b) Some (many) devices actually need more than 20 ms of resume signalling,
|
| 297 | * and while we can argue that's against the USB Specification, we don't have
|
| 298 | * control over which devices a certification laboratory will be using for
|
| 299 | * certification. If CertLab uses a device which was tested against Windows and
|
| 300 | * that happens to have relaxed resume signalling rules, we might fall into
|
| 301 | * situations where we fail interoperability and electrical tests.
|
| 302 | *
|
| 303 | * In order to avoid both conditions, we're using a 40 ms resume timeout, which
|
| 304 | * should cope with both LPJ calibration errors and devices not following every
|
| 305 | * detail of the USB Specification.
|
| 306 |
|
| 307 | #define USB_RESUME_TIMEOUT 40
|
| 308 |
|
| 309 | |
| 310 | * struct usb_interface_cache - long-term representation of a device interface
|
| 311 | * @num_altsetting: number of altsettings defined.
|
| 312 | * @ref: reference counter.
|
| 313 | * @altsetting: variable-length array of interface structures, one for
|
| 314 | * each alternate setting that may be selected. Each one includes a
|
| 315 | * set of endpoint configurations. They will be in no particular order.
|
| 316 | *
|
| 317 | * These structures persist for the lifetime of a usb_device, unlike
|
| 318 | * struct usb_interface (which persists only as long as its configuration
|
| 319 | * is installed). The altsetting arrays can be accessed through these
|
| 320 | * structures at any time, permitting comparison of configurations and
|
| 321 | * providing support for the /sys/kernel/debug/usb/devices pseudo-file.
|
| 322 |
|
| 323 | struct usb_interface_cache {
|
| 324 | unsigned num_altsetting;
|
| 325 | struct kref ref;
|
| 326 |
|
| 327 | |
| 328 | * stored in no particular order
|
| 329 | struct usb_host_interface altsetting[0];
|
| 330 | };
|
| 331 | #define ref_to_usb_interface_cache(r) \
|
| 332 | container_of(r, struct usb_interface_cache, ref)
|
| 333 | #define altsetting_to_usb_interface_cache(a) \
|
| 334 | container_of(a, struct usb_interface_cache, altsetting[0])
|
| 335 |
|
| 336 | |
| 337 | * struct usb_host_config - representation of a device's configuration
|
| 338 | * @desc: the device's configuration descriptor.
|
| 339 | * @string: pointer to the cached version of the iConfiguration string, if
|
| 340 | * present for this configuration.
|
| 341 | * @intf_assoc: list of any interface association descriptors in this config
|
| 342 | * @interface: array of pointers to usb_interface structures, one for each
|
| 343 | * interface in the configuration. The number of interfaces is stored
|
| 344 | * in desc.bNumInterfaces. These pointers are valid only while the
|
| 345 | * the configuration is active.
|
| 346 | * @intf_cache: array of pointers to usb_interface_cache structures, one
|
| 347 | * for each interface in the configuration. These structures exist
|
| 348 | * for the entire life of the device.
|
| 349 | * @extra: pointer to buffer containing all extra descriptors associated
|
| 350 | * with this configuration (those preceding the first interface
|
| 351 | * descriptor).
|
| 352 | * @extralen: length of the extra descriptors buffer.
|
| 353 | *
|
| 354 | * USB devices may have multiple configurations, but only one can be active
|
| 355 | * at any time. Each encapsulates a different operational environment;
|
| 356 | * for example, a dual-speed device would have separate configurations for
|
| 357 | * full-speed and high-speed operation. The number of configurations
|
| 358 | * available is stored in the device descriptor as bNumConfigurations.
|
| 359 | *
|
| 360 | * A configuration can contain multiple interfaces. Each corresponds to
|
| 361 | * a different function of the USB device, and all are available whenever
|
| 362 | * the configuration is active. The USB standard says that interfaces
|
| 363 | * are supposed to be numbered from 0 to desc.bNumInterfaces-1, but a lot
|
| 364 | * of devices get this wrong. In addition, the interface array is not
|
| 365 | * guaranteed to be sorted in numerical order. Use usb_ifnum_to_if() to
|
| 366 | * look up an interface entry based on its number.
|
| 367 | *
|
| 368 | * Device drivers should not attempt to activate configurations. The choice
|
| 369 | * of which configuration to install is a policy decision based on such
|
| 370 | * considerations as available power, functionality provided, and the user's
|
| 371 | * desires (expressed through userspace tools). However, drivers can call
|
| 372 | * usb_reset_configuration() to reinitialize the current configuration and
|
| 373 | * all its interfaces.
|
| 374 |
|
| 375 | struct usb_host_config {
|
| 376 | struct usb_config_descriptor desc;
|
| 377 |
|
| 378 | char *string;
|
| 379 |
|
| 380 | |
| 381 | * configuration.
|
| 382 | struct usb_interface_assoc_descriptor *intf_assoc[USB_MAXIADS];
|
| 383 |
|
| 384 | |
| 385 | * stored in no particular order
|
| 386 | struct usb_interface *interface[USB_MAXINTERFACES];
|
| 387 |
|
| 388 | |
| 389 | * active configuration
|
| 390 | struct usb_interface_cache *intf_cache[USB_MAXINTERFACES];
|
| 391 |
|
| 392 | unsigned char *extra;
|
| 393 | int extralen;
|
| 394 | };
|
| 395 |
|
| 396 |
|
| 397 | struct usb_host_bos {
|
| 398 | struct usb_bos_descriptor *desc;
|
| 399 |
|
| 400 |
|
| 401 | struct usb_ext_cap_descriptor *ext_cap;
|
| 402 | struct usb_ss_cap_descriptor *ss_cap;
|
| 403 | struct usb_ssp_cap_descriptor *ssp_cap;
|
| 404 | struct usb_ss_container_id_descriptor *ss_id;
|
| 405 | struct usb_ptm_cap_descriptor *ptm_cap;
|
| 406 | };
|
| 407 |
|
| 408 | int __usb_get_extra_descriptor(char *buffer, unsigned size,
|
| 409 | unsigned char type, void **ptr);
|
| 410 | #define usb_get_extra_descriptor(ifpoint, type, ptr) \
|
| 411 | __usb_get_extra_descriptor((ifpoint)->extra, \
|
| 412 | (ifpoint)->extralen, \
|
| 413 | type, (void **)ptr)
|
| 414 |
|
| 415 |
|
| 416 |
|
| 417 |
|
| 418 | struct usb_devmap {
|
| 419 | unsigned long devicemap[128 / (8*sizeof(unsigned long))];
|
| 420 | };
|
| 421 |
|
| 422 | |
| 423 | * Allocated per bus (tree of devices) we have:
|
| 424 |
|
| 425 | struct usb_bus {
|
| 426 | struct device *controller;
|
| 427 | struct device *sysdev;
|
| 428 | int busnum;
|
| 429 | const char *bus_name;
|
| 430 | u8 uses_dma;
|
| 431 | u8 uses_pio_for_control; |
| 432 | * Does the host controller use PIO
|
| 433 | * for control transfers?
|
| 434 |
|
| 435 | u8 otg_port;
|
| 436 | unsigned is_b_host:1;
|
| 437 | unsigned b_hnp_enable:1;
|
| 438 | unsigned no_stop_on_short:1; |
| 439 | * Quirk: some controllers don't stop
|
| 440 | * the ep queue on a short transfer
|
| 441 | * with the URB_SHORT_NOT_OK flag set.
|
| 442 |
|
| 443 | unsigned no_sg_constraint:1;
|
| 444 | unsigned sg_tablesize;
|
| 445 |
|
| 446 | int devnum_next; |
| 447 | * round-robin allocation
|
| 448 | struct mutex devnum_next_mutex;
|
| 449 |
|
| 450 | struct usb_devmap devmap;
|
| 451 | struct usb_device *root_hub;
|
| 452 | struct usb_bus *hs_companion;
|
| 453 |
|
| 454 | int bandwidth_allocated; |
| 455 | * reserved for periodic (intr/iso)
|
| 456 | * requests is used, on average?
|
| 457 | * Units: microseconds/frame.
|
| 458 | * Limits: Full/low speed reserve 90%,
|
| 459 | * while high speed reserves 80%.
|
| 460 |
|
| 461 | int bandwidth_int_reqs;
|
| 462 | int bandwidth_isoc_reqs;
|
| 463 |
|
| 464 | unsigned resuming_ports;
|
| 465 |
|
| 466 | #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
|
| 467 | struct mon_bus *mon_bus;
|
| 468 | int monitored;
|
| 469 | #endif
|
| 470 | };
|
| 471 |
|
| 472 | struct usb_dev_state;
|
| 473 |
|
| 474 |
|
| 475 |
|
| 476 | struct usb_tt;
|
| 477 |
|
| 478 | enum usb_device_removable {
|
| 479 | USB_DEVICE_REMOVABLE_UNKNOWN = 0,
|
| 480 | USB_DEVICE_REMOVABLE,
|
| 481 | USB_DEVICE_FIXED,
|
| 482 | };
|
| 483 |
|
| 484 | enum usb_port_connect_type {
|
| 485 | USB_PORT_CONNECT_TYPE_UNKNOWN = 0,
|
| 486 | USB_PORT_CONNECT_TYPE_HOT_PLUG,
|
| 487 | USB_PORT_CONNECT_TYPE_HARD_WIRED,
|
| 488 | USB_PORT_NOT_USED,
|
| 489 | };
|
| 490 |
|
| 491 | |
| 492 | * USB 2.0 Link Power Management (LPM) parameters.
|
| 493 |
|
| 494 | struct usb2_lpm_parameters {
|
| 495 | |
| 496 | * resume on an exit from L1.
|
| 497 |
|
| 498 | unsigned int besl;
|
| 499 |
|
| 500 | |
| 501 | * When the timer counts to zero, the parent hub will initiate a LPM
|
| 502 | * transition to L1.
|
| 503 |
|
| 504 | int timeout;
|
| 505 | };
|
| 506 |
|
| 507 | |
| 508 | * USB 3.0 Link Power Management (LPM) parameters.
|
| 509 | *
|
| 510 | * PEL and SEL are USB 3.0 Link PM latencies for device-initiated LPM exit.
|
| 511 | * MEL is the USB 3.0 Link PM latency for host-initiated LPM exit.
|
| 512 | * All three are stored in nanoseconds.
|
| 513 |
|
| 514 | struct usb3_lpm_parameters {
|
| 515 | |
| 516 | * Maximum exit latency (MEL) for the host to send a packet to the
|
| 517 | * device (either a Ping for isoc endpoints, or a data packet for
|
| 518 | * interrupt endpoints), the hubs to decode the packet, and for all hubs
|
| 519 | * in the path to transition the links to U0.
|
| 520 |
|
| 521 | unsigned int mel;
|
| 522 | |
| 523 | * Maximum exit latency for a device-initiated LPM transition to bring
|
| 524 | * all links into U0. Abbreviated as "PEL" in section 9.4.12 of the USB
|
| 525 | * 3.0 spec, with no explanation of what "P" stands for. "Path"?
|
| 526 |
|
| 527 | unsigned int pel;
|
| 528 |
|
| 529 | |
| 530 | * The System Exit Latency (SEL) includes PEL, and three other
|
| 531 | * latencies. After a device initiates a U0 transition, it will take
|
| 532 | * some time from when the device sends the ERDY to when it will finally
|
| 533 | * receive the data packet. Basically, SEL should be the worse-case
|
| 534 | * latency from when a device starts initiating a U0 transition to when
|
| 535 | * it will get data.
|
| 536 |
|
| 537 | unsigned int sel;
|
| 538 | |
| 539 | * The idle timeout value that is currently programmed into the parent
|
| 540 | * hub for this device. When the timer counts to zero, the parent hub
|
| 541 | * will initiate an LPM transition to either U1 or U2.
|
| 542 |
|
| 543 | int timeout;
|
| 544 | };
|
| 545 |
|
| 546 | |
| 547 | * struct usb_device - kernel's representation of a USB device
|
| 548 | * @devnum: device number; address on a USB bus
|
| 549 | * @devpath: device ID string for use in messages (e.g., /port/...)
|
| 550 | * @route: tree topology hex string for use with xHCI
|
| 551 | * @state: device state: configured, not attached, etc.
|
| 552 | * @speed: device speed: high/full/low (or error)
|
| 553 | * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub
|
| 554 | * @ttport: device port on that tt hub
|
| 555 | * @toggle: one bit for each endpoint, with ([0] = IN, [1] = OUT) endpoints
|
| 556 | * @parent: our hub, unless we're the root
|
| 557 | * @bus: bus we're part of
|
| 558 | * @ep0: endpoint 0 data (default control pipe)
|
| 559 | * @dev: generic device interface
|
| 560 | * @descriptor: USB device descriptor
|
| 561 | * @bos: USB device BOS descriptor set
|
| 562 | * @config: all of the device's configs
|
| 563 | * @actconfig: the active configuration
|
| 564 | * @ep_in: array of IN endpoints
|
| 565 | * @ep_out: array of OUT endpoints
|
| 566 | * @rawdescriptors: raw descriptors for each config
|
| 567 | * @bus_mA: Current available from the bus
|
| 568 | * @portnum: parent port number (origin 1)
|
| 569 | * @level: number of USB hub ancestors
|
| 570 | * @can_submit: URBs may be submitted
|
| 571 | * @persist_enabled: USB_PERSIST enabled for this device
|
| 572 | * @have_langid: whether string_langid is valid
|
| 573 | * @authorized: policy has said we can use it;
|
| 574 | * (user space) policy determines if we authorize this device to be
|
| 575 | * used or not. By default, wired USB devices are authorized.
|
| 576 | * WUSB devices are not, until we authorize them from user space.
|
| 577 | * FIXME -- complete doc
|
| 578 | * @authenticated: Crypto authentication passed
|
| 579 | * @wusb: device is Wireless USB
|
| 580 | * @lpm_capable: device supports LPM
|
| 581 | * @usb2_hw_lpm_capable: device can perform USB2 hardware LPM
|
| 582 | * @usb2_hw_lpm_besl_capable: device can perform USB2 hardware BESL LPM
|
| 583 | * @usb2_hw_lpm_enabled: USB2 hardware LPM is enabled
|
| 584 | * @usb2_hw_lpm_allowed: Userspace allows USB 2.0 LPM to be enabled
|
| 585 | * @usb3_lpm_u1_enabled: USB3 hardware U1 LPM enabled
|
| 586 | * @usb3_lpm_u2_enabled: USB3 hardware U2 LPM enabled
|
| 587 | * @string_langid: language ID for strings
|
| 588 | * @product: iProduct string, if present (static)
|
| 589 | * @manufacturer: iManufacturer string, if present (static)
|
| 590 | * @serial: iSerialNumber string, if present (static)
|
| 591 | * @filelist: usbfs files that are open to this device
|
| 592 | * @maxchild: number of ports if hub
|
| 593 | * @quirks: quirks of the whole device
|
| 594 | * @urbnum: number of URBs submitted for the whole device
|
| 595 | * @active_duration: total time device is not suspended
|
| 596 | * @connect_time: time device was first connected
|
| 597 | * @do_remote_wakeup: remote wakeup should be enabled
|
| 598 | * @reset_resume: needs reset instead of resume
|
| 599 | * @port_is_suspended: the upstream port is suspended (L2 or U3)
|
| 600 | * @wusb_dev: if this is a Wireless USB device, link to the WUSB
|
| 601 | * specific data for the device.
|
| 602 | * @slot_id: Slot ID assigned by xHCI
|
| 603 | * @removable: Device can be physically removed from this port
|
| 604 | * @l1_params: best effor service latency for USB2 L1 LPM state, and L1 timeout.
|
| 605 | * @u1_params: exit latencies for USB3 U1 LPM state, and hub-initiated timeout.
|
| 606 | * @u2_params: exit latencies for USB3 U2 LPM state, and hub-initiated timeout.
|
| 607 | * @lpm_disable_count: Ref count used by usb_disable_lpm() and usb_enable_lpm()
|
| 608 | * to keep track of the number of functions that require USB 3.0 Link Power
|
| 609 | * Management to be disabled for this usb_device. This count should only
|
| 610 | * be manipulated by those functions, with the bandwidth_mutex is held.
|
| 611 | *
|
| 612 | * Notes:
|
| 613 | * Usbcore drivers should not set usbdev->state directly. Instead use
|
| 614 | * usb_set_device_state().
|
| 615 |
|
| 616 | struct usb_device {
|
| 617 | int devnum;
|
| 618 | char devpath[16];
|
| 619 | u32 route;
|
| 620 | enum usb_device_state state;
|
| 621 | enum usb_device_speed speed;
|
| 622 |
|
| 623 | struct usb_tt *tt;
|
| 624 | int ttport;
|
| 625 |
|
| 626 | unsigned int toggle[2];
|
| 627 |
|
| 628 | struct usb_device *parent;
|
| 629 | struct usb_bus *bus;
|
| 630 | struct usb_host_endpoint ep0;
|
| 631 |
|
| 632 | struct device dev;
|
| 633 |
|
| 634 | struct usb_device_descriptor descriptor;
|
| 635 | struct usb_host_bos *bos;
|
| 636 | struct usb_host_config *config;
|
| 637 |
|
| 638 | struct usb_host_config *actconfig;
|
| 639 | struct usb_host_endpoint *ep_in[16];
|
| 640 | struct usb_host_endpoint *ep_out[16];
|
| 641 |
|
| 642 | char **rawdescriptors;
|
| 643 |
|
| 644 | unsigned short bus_mA;
|
| 645 | u8 portnum;
|
| 646 | u8 level;
|
| 647 |
|
| 648 | unsigned can_submit:1;
|
| 649 | unsigned persist_enabled:1;
|
| 650 | unsigned have_langid:1;
|
| 651 | unsigned authorized:1;
|
| 652 | unsigned authenticated:1;
|
| 653 | unsigned wusb:1;
|
| 654 | unsigned lpm_capable:1;
|
| 655 | unsigned usb2_hw_lpm_capable:1;
|
| 656 | unsigned usb2_hw_lpm_besl_capable:1;
|
| 657 | unsigned usb2_hw_lpm_enabled:1;
|
| 658 | unsigned usb2_hw_lpm_allowed:1;
|
| 659 | unsigned usb3_lpm_u1_enabled:1;
|
| 660 | unsigned usb3_lpm_u2_enabled:1;
|
| 661 | int string_langid;
|
| 662 |
|
| 663 |
|
| 664 | char *product;
|
| 665 | char *manufacturer;
|
| 666 | char *serial;
|
| 667 |
|
| 668 | struct list_head filelist;
|
| 669 |
|
| 670 | int maxchild;
|
| 671 |
|
| 672 | u32 quirks;
|
| 673 | atomic_t urbnum;
|
| 674 |
|
| 675 | unsigned long active_duration;
|
| 676 |
|
| 677 | #ifdef CONFIG_PM
|
| 678 | unsigned long connect_time;
|
| 679 |
|
| 680 | unsigned do_remote_wakeup:1;
|
| 681 | unsigned reset_resume:1;
|
| 682 | unsigned port_is_suspended:1;
|
| 683 | #endif
|
| 684 | struct wusb_dev *wusb_dev;
|
| 685 | int slot_id;
|
| 686 | enum usb_device_removable removable;
|
| 687 | struct usb2_lpm_parameters l1_params;
|
| 688 | struct usb3_lpm_parameters u1_params;
|
| 689 | struct usb3_lpm_parameters u2_params;
|
| 690 | unsigned lpm_disable_count;
|
| 691 | };
|
| 692 | #define to_usb_device(d) container_of(d, struct usb_device, dev)
|
| 693 |
|
| 694 | static inline struct usb_device *interface_to_usbdev(struct usb_interface *intf)
|
| 695 | {
|
| 696 | return to_usb_device(intf->dev.parent);
|
| 697 | }
|
| 698 |
|
| 699 | extern struct usb_device *usb_get_dev(struct usb_device *dev);
|
| 700 | extern void usb_put_dev(struct usb_device *dev);
|
| 701 | extern struct usb_device *usb_hub_find_child(struct usb_device *hdev,
|
| 702 | int port1);
|
| 703 |
|
| 704 | |
| 705 | * usb_hub_for_each_child - iterate over all child devices on the hub
|
| 706 | * @hdev: USB device belonging to the usb hub
|
| 707 | * @port1: portnum associated with child device
|
| 708 | * @child: child device pointer
|
| 709 |
|
| 710 | #define usb_hub_for_each_child(hdev, port1, child) \
|
| 711 | for (port1 = 1, child = usb_hub_find_child(hdev, port1); \
|
| 712 | port1 <= hdev->maxchild; \
|
| 713 | child = usb_hub_find_child(hdev, ++port1)) \
|
| 714 | if (!child) continue; else
|
| 715 |
|
| 716 |
|
| 717 | #define usb_lock_device(udev) device_lock(&(udev)->dev)
|
| 718 | #define usb_unlock_device(udev) device_unlock(&(udev)->dev)
|
| 719 | #define usb_lock_device_interruptible(udev) device_lock_interruptible(&(udev)->dev)
|
| 720 | #define usb_trylock_device(udev) device_trylock(&(udev)->dev)
|
| 721 | extern int usb_lock_device_for_reset(struct usb_device *udev,
|
| 722 | const struct usb_interface *iface);
|
| 723 |
|
| 724 |
|
| 725 | extern int usb_reset_device(struct usb_device *dev);
|
| 726 | extern void usb_queue_reset_device(struct usb_interface *dev);
|
| 727 |
|
| 728 | #ifdef CONFIG_ACPI
|
| 729 | extern int usb_acpi_set_power_state(struct usb_device *hdev, int index,
|
| 730 | bool enable);
|
| 731 | extern bool usb_acpi_power_manageable(struct usb_device *hdev, int index);
|
| 732 | #else
|
| 733 | static inline int usb_acpi_set_power_state(struct usb_device *hdev, int index,
|
| 734 | bool enable) { return 0; }
|
| 735 | static inline bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
|
| 736 | { return true; }
|
| 737 | #endif
|
| 738 |
|
| 739 |
|
| 740 | #ifdef CONFIG_PM
|
| 741 | extern void usb_enable_autosuspend(struct usb_device *udev);
|
| 742 | extern void usb_disable_autosuspend(struct usb_device *udev);
|
| 743 |
|
| 744 | extern int usb_autopm_get_interface(struct usb_interface *intf);
|
| 745 | extern void usb_autopm_put_interface(struct usb_interface *intf);
|
| 746 | extern int usb_autopm_get_interface_async(struct usb_interface *intf);
|
| 747 | extern void usb_autopm_put_interface_async(struct usb_interface *intf);
|
| 748 | extern void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
|
| 749 | extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
|
| 750 |
|
| 751 | static inline void usb_mark_last_busy(struct usb_device *udev)
|
| 752 | {
|
| 753 | pm_runtime_mark_last_busy(&udev->dev);
|
| 754 | }
|
| 755 |
|
| 756 | #else
|
| 757 |
|
| 758 | static inline int usb_enable_autosuspend(struct usb_device *udev)
|
| 759 | { return 0; }
|
| 760 | static inline int usb_disable_autosuspend(struct usb_device *udev)
|
| 761 | { return 0; }
|
| 762 |
|
| 763 | static inline int usb_autopm_get_interface(struct usb_interface *intf)
|
| 764 | { return 0; }
|
| 765 | static inline int usb_autopm_get_interface_async(struct usb_interface *intf)
|
| 766 | { return 0; }
|
| 767 |
|
| 768 | static inline void usb_autopm_put_interface(struct usb_interface *intf)
|
| 769 | { }
|
| 770 | static inline void usb_autopm_put_interface_async(struct usb_interface *intf)
|
| 771 | { }
|
| 772 | static inline void usb_autopm_get_interface_no_resume(
|
| 773 | struct usb_interface *intf)
|
| 774 | { }
|
| 775 | static inline void usb_autopm_put_interface_no_suspend(
|
| 776 | struct usb_interface *intf)
|
| 777 | { }
|
| 778 | static inline void usb_mark_last_busy(struct usb_device *udev)
|
| 779 | { }
|
| 780 | #endif
|
| 781 |
|
| 782 | extern int usb_disable_lpm(struct usb_device *udev);
|
| 783 | extern void usb_enable_lpm(struct usb_device *udev);
|
| 784 |
|
| 785 | extern int usb_unlocked_disable_lpm(struct usb_device *udev);
|
| 786 | extern void usb_unlocked_enable_lpm(struct usb_device *udev);
|
| 787 |
|
| 788 | extern int usb_disable_ltm(struct usb_device *udev);
|
| 789 | extern void usb_enable_ltm(struct usb_device *udev);
|
| 790 |
|
| 791 | static inline bool usb_device_supports_ltm(struct usb_device *udev)
|
| 792 | {
|
| 793 | if (udev->speed < USB_SPEED_SUPER || !udev->bos || !udev->bos->ss_cap)
|
| 794 | return false;
|
| 795 | return udev->bos->ss_cap->bmAttributes & USB_LTM_SUPPORT;
|
| 796 | }
|
| 797 |
|
| 798 | static inline bool usb_device_no_sg_constraint(struct usb_device *udev)
|
| 799 | {
|
| 800 | return udev && udev->bus && udev->bus->no_sg_constraint;
|
| 801 | }
|
| 802 |
|
| 803 |
|
| 804 |
|
| 805 |
|
| 806 |
|
| 807 | extern int usb_get_current_frame_number(struct usb_device *usb_dev);
|
| 808 |
|
| 809 |
|
| 810 | extern int usb_alloc_streams(struct usb_interface *interface,
|
| 811 | struct usb_host_endpoint **eps, unsigned int num_eps,
|
| 812 | unsigned int num_streams, gfp_t mem_flags);
|
| 813 |
|
| 814 |
|
| 815 | extern int usb_free_streams(struct usb_interface *interface,
|
| 816 | struct usb_host_endpoint **eps, unsigned int num_eps,
|
| 817 | gfp_t mem_flags);
|
| 818 |
|
| 819 |
|
| 820 | extern int usb_driver_claim_interface(struct usb_driver *driver,
|
| 821 | struct usb_interface *iface, void *priv);
|
| 822 |
|
| 823 | |
| 824 | * usb_interface_claimed - returns true iff an interface is claimed
|
| 825 | * @iface: the interface being checked
|
| 826 | *
|
| 827 | * Return: %true (nonzero) iff the interface is claimed, else %false
|
| 828 | * (zero).
|
| 829 | *
|
| 830 | * Note:
|
| 831 | * Callers must own the driver model's usb bus readlock. So driver
|
| 832 | * probe() entries don't need extra locking, but other call contexts
|
| 833 | * may need to explicitly claim that lock.
|
| 834 | *
|
| 835 |
|
| 836 | static inline int usb_interface_claimed(struct usb_interface *iface)
|
| 837 | {
|
| 838 | return (iface->dev.driver != NULL);
|
| 839 | }
|
| 840 |
|
| 841 | extern void usb_driver_release_interface(struct usb_driver *driver,
|
| 842 | struct usb_interface *iface);
|
| 843 | const struct usb_device_id *usb_match_id(struct usb_interface *interface,
|
| 844 | const struct usb_device_id *id);
|
| 845 | extern int usb_match_one_id(struct usb_interface *interface,
|
| 846 | const struct usb_device_id *id);
|
| 847 |
|
| 848 | extern int usb_for_each_dev(void *data, int (*fn)(struct usb_device *, void *));
|
| 849 | extern struct usb_interface *usb_find_interface(struct usb_driver *drv,
|
| 850 | int minor);
|
| 851 | extern struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
|
| 852 | unsigned ifnum);
|
| 853 | extern struct usb_host_interface *usb_altnum_to_altsetting(
|
| 854 | const struct usb_interface *intf, unsigned int altnum);
|
| 855 | extern struct usb_host_interface *usb_find_alt_setting(
|
| 856 | struct usb_host_config *config,
|
| 857 | unsigned int iface_num,
|
| 858 | unsigned int alt_num);
|
| 859 |
|
| 860 |
|
| 861 | int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
|
| 862 | struct usb_dev_state *owner);
|
| 863 | int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
|
| 864 | struct usb_dev_state *owner);
|
| 865 |
|
| 866 | |
| 867 | * usb_make_path - returns stable device path in the usb tree
|
| 868 | * @dev: the device whose path is being constructed
|
| 869 | * @buf: where to put the string
|
| 870 | * @size: how big is "buf"?
|
| 871 | *
|
| 872 | * Return: Length of the string (> 0) or negative if size was too small.
|
| 873 | *
|
| 874 | * Note:
|
| 875 | * This identifier is intended to be "stable", reflecting physical paths in
|
| 876 | * hardware such as physical bus addresses for host controllers or ports on
|
| 877 | * USB hubs. That makes it stay the same until systems are physically
|
| 878 | * reconfigured, by re-cabling a tree of USB devices or by moving USB host
|
| 879 | * controllers. Adding and removing devices, including virtual root hubs
|
| 880 | * in host controller driver modules, does not change these path identifiers;
|
| 881 | * neither does rebooting or re-enumerating. These are more useful identifiers
|
| 882 | * than changeable ("unstable") ones like bus numbers or device addresses.
|
| 883 | *
|
| 884 | * With a partial exception for devices connected to USB 2.0 root hubs, these
|
| 885 | * identifiers are also predictable. So long as the device tree isn't changed,
|
| 886 | * plugging any USB device into a given hub port always gives it the same path.
|
| 887 | * Because of the use of "companion" controllers, devices connected to ports on
|
| 888 | * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
|
| 889 | * high speed, and a different one if they are full or low speed.
|
| 890 |
|
| 891 | static inline int usb_make_path(struct usb_device *dev, char *buf, size_t size)
|
| 892 | {
|
| 893 | int actual;
|
| 894 | actual = snprintf(buf, size, "usb-%s-%s", dev->bus->bus_name,
|
| 895 | dev->devpath);
|
| 896 | return (actual >= (int)size) ? -1 : actual;
|
| 897 | }
|
| 898 |
|
| 899 |
|
| 900 |
|
| 901 | #define USB_DEVICE_ID_MATCH_DEVICE \
|
| 902 | (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
|
| 903 | #define USB_DEVICE_ID_MATCH_DEV_RANGE \
|
| 904 | (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
|
| 905 | #define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
|
| 906 | (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
|
| 907 | #define USB_DEVICE_ID_MATCH_DEV_INFO \
|
| 908 | (USB_DEVICE_ID_MATCH_DEV_CLASS | \
|
| 909 | USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \
|
| 910 | USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
|
| 911 | #define USB_DEVICE_ID_MATCH_INT_INFO \
|
| 912 | (USB_DEVICE_ID_MATCH_INT_CLASS | \
|
| 913 | USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
|
| 914 | USB_DEVICE_ID_MATCH_INT_PROTOCOL)
|
| 915 |
|
| 916 | |
| 917 | * USB_DEVICE - macro used to describe a specific usb device
|
| 918 | * @vend: the 16 bit USB Vendor ID
|
| 919 | * @prod: the 16 bit USB Product ID
|
| 920 | *
|
| 921 | * This macro is used to create a struct usb_device_id that matches a
|
| 922 | * specific device.
|
| 923 |
|
| 924 | #define USB_DEVICE(vend, prod) \
|
| 925 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
|
| 926 | .idVendor = (vend), \
|
| 927 | .idProduct = (prod)
|
| 928 | |
| 929 | * USB_DEVICE_VER - describe a specific usb device with a version range
|
| 930 | * @vend: the 16 bit USB Vendor ID
|
| 931 | * @prod: the 16 bit USB Product ID
|
| 932 | * @lo: the bcdDevice_lo value
|
| 933 | * @hi: the bcdDevice_hi value
|
| 934 | *
|
| 935 | * This macro is used to create a struct usb_device_id that matches a
|
| 936 | * specific device, with a version range.
|
| 937 |
|
| 938 | #define USB_DEVICE_VER(vend, prod, lo, hi) \
|
| 939 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, \
|
| 940 | .idVendor = (vend), \
|
| 941 | .idProduct = (prod), \
|
| 942 | .bcdDevice_lo = (lo), \
|
| 943 | .bcdDevice_hi = (hi)
|
| 944 |
|
| 945 | |
| 946 | * USB_DEVICE_INTERFACE_CLASS - describe a usb device with a specific interface class
|
| 947 | * @vend: the 16 bit USB Vendor ID
|
| 948 | * @prod: the 16 bit USB Product ID
|
| 949 | * @cl: bInterfaceClass value
|
| 950 | *
|
| 951 | * This macro is used to create a struct usb_device_id that matches a
|
| 952 | * specific interface class of devices.
|
| 953 |
|
| 954 | #define USB_DEVICE_INTERFACE_CLASS(vend, prod, cl) \
|
| 955 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
|
| 956 | USB_DEVICE_ID_MATCH_INT_CLASS, \
|
| 957 | .idVendor = (vend), \
|
| 958 | .idProduct = (prod), \
|
| 959 | .bInterfaceClass = (cl)
|
| 960 |
|
| 961 | |
| 962 | * USB_DEVICE_INTERFACE_PROTOCOL - describe a usb device with a specific interface protocol
|
| 963 | * @vend: the 16 bit USB Vendor ID
|
| 964 | * @prod: the 16 bit USB Product ID
|
| 965 | * @pr: bInterfaceProtocol value
|
| 966 | *
|
| 967 | * This macro is used to create a struct usb_device_id that matches a
|
| 968 | * specific interface protocol of devices.
|
| 969 |
|
| 970 | #define USB_DEVICE_INTERFACE_PROTOCOL(vend, prod, pr) \
|
| 971 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
|
| 972 | USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
|
| 973 | .idVendor = (vend), \
|
| 974 | .idProduct = (prod), \
|
| 975 | .bInterfaceProtocol = (pr)
|
| 976 |
|
| 977 | |
| 978 | * USB_DEVICE_INTERFACE_NUMBER - describe a usb device with a specific interface number
|
| 979 | * @vend: the 16 bit USB Vendor ID
|
| 980 | * @prod: the 16 bit USB Product ID
|
| 981 | * @num: bInterfaceNumber value
|
| 982 | *
|
| 983 | * This macro is used to create a struct usb_device_id that matches a
|
| 984 | * specific interface number of devices.
|
| 985 |
|
| 986 | #define USB_DEVICE_INTERFACE_NUMBER(vend, prod, num) \
|
| 987 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
|
| 988 | USB_DEVICE_ID_MATCH_INT_NUMBER, \
|
| 989 | .idVendor = (vend), \
|
| 990 | .idProduct = (prod), \
|
| 991 | .bInterfaceNumber = (num)
|
| 992 |
|
| 993 | |
| 994 | * USB_DEVICE_INFO - macro used to describe a class of usb devices
|
| 995 | * @cl: bDeviceClass value
|
| 996 | * @sc: bDeviceSubClass value
|
| 997 | * @pr: bDeviceProtocol value
|
| 998 | *
|
| 999 | * This macro is used to create a struct usb_device_id that matches a
|
| 1000 | * specific class of devices.
|
| 1001 |
|
| 1002 | #define USB_DEVICE_INFO(cl, sc, pr) \
|
| 1003 | .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, \
|
| 1004 | .bDeviceClass = (cl), \
|
| 1005 | .bDeviceSubClass = (sc), \
|
| 1006 | .bDeviceProtocol = (pr)
|
| 1007 |
|
| 1008 | |
| 1009 | * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces
|
| 1010 | * @cl: bInterfaceClass value
|
| 1011 | * @sc: bInterfaceSubClass value
|
| 1012 | * @pr: bInterfaceProtocol value
|
| 1013 | *
|
| 1014 | * This macro is used to create a struct usb_device_id that matches a
|
| 1015 | * specific class of interfaces.
|
| 1016 |
|
| 1017 | #define USB_INTERFACE_INFO(cl, sc, pr) \
|
| 1018 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \
|
| 1019 | .bInterfaceClass = (cl), \
|
| 1020 | .bInterfaceSubClass = (sc), \
|
| 1021 | .bInterfaceProtocol = (pr)
|
| 1022 |
|
| 1023 | |
| 1024 | * USB_DEVICE_AND_INTERFACE_INFO - describe a specific usb device with a class of usb interfaces
|
| 1025 | * @vend: the 16 bit USB Vendor ID
|
| 1026 | * @prod: the 16 bit USB Product ID
|
| 1027 | * @cl: bInterfaceClass value
|
| 1028 | * @sc: bInterfaceSubClass value
|
| 1029 | * @pr: bInterfaceProtocol value
|
| 1030 | *
|
| 1031 | * This macro is used to create a struct usb_device_id that matches a
|
| 1032 | * specific device with a specific class of interfaces.
|
| 1033 | *
|
| 1034 | * This is especially useful when explicitly matching devices that have
|
| 1035 | * vendor specific bDeviceClass values, but standards-compliant interfaces.
|
| 1036 |
|
| 1037 | #define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, cl, sc, pr) \
|
| 1038 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
|
| 1039 | | USB_DEVICE_ID_MATCH_DEVICE, \
|
| 1040 | .idVendor = (vend), \
|
| 1041 | .idProduct = (prod), \
|
| 1042 | .bInterfaceClass = (cl), \
|
| 1043 | .bInterfaceSubClass = (sc), \
|
| 1044 | .bInterfaceProtocol = (pr)
|
| 1045 |
|
| 1046 | |
| 1047 | * USB_VENDOR_AND_INTERFACE_INFO - describe a specific usb vendor with a class of usb interfaces
|
| 1048 | * @vend: the 16 bit USB Vendor ID
|
| 1049 | * @cl: bInterfaceClass value
|
| 1050 | * @sc: bInterfaceSubClass value
|
| 1051 | * @pr: bInterfaceProtocol value
|
| 1052 | *
|
| 1053 | * This macro is used to create a struct usb_device_id that matches a
|
| 1054 | * specific vendor with a specific class of interfaces.
|
| 1055 | *
|
| 1056 | * This is especially useful when explicitly matching devices that have
|
| 1057 | * vendor specific bDeviceClass values, but standards-compliant interfaces.
|
| 1058 |
|
| 1059 | #define USB_VENDOR_AND_INTERFACE_INFO(vend, cl, sc, pr) \
|
| 1060 | .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
|
| 1061 | | USB_DEVICE_ID_MATCH_VENDOR, \
|
| 1062 | .idVendor = (vend), \
|
| 1063 | .bInterfaceClass = (cl), \
|
| 1064 | .bInterfaceSubClass = (sc), \
|
| 1065 | .bInterfaceProtocol = (pr)
|
| 1066 |
|
| 1067 |
|
| 1068 |
|
| 1069 |
|
| 1070 | struct usb_dynids {
|
| 1071 | spinlock_t lock;
|
| 1072 | struct list_head list;
|
| 1073 | };
|
| 1074 |
|
| 1075 | struct usb_dynid {
|
| 1076 | struct list_head node;
|
| 1077 | struct usb_device_id id;
|
| 1078 | };
|
| 1079 |
|
| 1080 | extern ssize_t usb_store_new_id(struct usb_dynids *dynids,
|
| 1081 | const struct usb_device_id *id_table,
|
| 1082 | struct device_driver *driver,
|
| 1083 | const char *buf, size_t count);
|
| 1084 |
|
| 1085 | extern ssize_t usb_show_dynids(struct usb_dynids *dynids, char *buf);
|
| 1086 |
|
| 1087 | |
| 1088 | * struct usbdrv_wrap - wrapper for driver-model structure
|
| 1089 | * @driver: The driver-model core driver structure.
|
| 1090 | * @for_devices: Non-zero for device drivers, 0 for interface drivers.
|
| 1091 |
|
| 1092 | struct usbdrv_wrap {
|
| 1093 | struct device_driver driver;
|
| 1094 | int for_devices;
|
| 1095 | };
|
| 1096 |
|
| 1097 | |
| 1098 | * struct usb_driver - identifies USB interface driver to usbcore
|
| 1099 | * @name: The driver name should be unique among USB drivers,
|
| 1100 | * and should normally be the same as the module name.
|
| 1101 | * @probe: Called to see if the driver is willing to manage a particular
|
| 1102 | * interface on a device. If it is, probe returns zero and uses
|
| 1103 | * usb_set_intfdata() to associate driver-specific data with the
|
| 1104 | * interface. It may also use usb_set_interface() to specify the
|
| 1105 | * appropriate altsetting. If unwilling to manage the interface,
|
| 1106 | * return -ENODEV, if genuine IO errors occurred, an appropriate
|
| 1107 | * negative errno value.
|
| 1108 | * @disconnect: Called when the interface is no longer accessible, usually
|
| 1109 | * because its device has been (or is being) disconnected or the
|
| 1110 | * driver module is being unloaded.
|
| 1111 | * @unlocked_ioctl: Used for drivers that want to talk to userspace through
|
| 1112 | * the "usbfs" filesystem. This lets devices provide ways to
|
| 1113 | * expose information to user space regardless of where they
|
| 1114 | * do (or don't) show up otherwise in the filesystem.
|
| 1115 | * @suspend: Called when the device is going to be suspended by the
|
| 1116 | * system either from system sleep or runtime suspend context. The
|
| 1117 | * return value will be ignored in system sleep context, so do NOT
|
| 1118 | * try to continue using the device if suspend fails in this case.
|
| 1119 | * Instead, let the resume or reset-resume routine recover from
|
| 1120 | * the failure.
|
| 1121 | * @resume: Called when the device is being resumed by the system.
|
| 1122 | * @reset_resume: Called when the suspended device has been reset instead
|
| 1123 | * of being resumed.
|
| 1124 | * @pre_reset: Called by usb_reset_device() when the device is about to be
|
| 1125 | * reset. This routine must not return until the driver has no active
|
| 1126 | * URBs for the device, and no more URBs may be submitted until the
|
| 1127 | * post_reset method is called.
|
| 1128 | * @post_reset: Called by usb_reset_device() after the device
|
| 1129 | * has been reset
|
| 1130 | * @id_table: USB drivers use ID table to support hotplugging.
|
| 1131 | * Export this with MODULE_DEVICE_TABLE(usb,...). This must be set
|
| 1132 | * or your driver's probe function will never get called.
|
| 1133 | * @dynids: used internally to hold the list of dynamically added device
|
| 1134 | * ids for this driver.
|
| 1135 | * @drvwrap: Driver-model core structure wrapper.
|
| 1136 | * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
|
| 1137 | * added to this driver by preventing the sysfs file from being created.
|
| 1138 | * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
|
| 1139 | * for interfaces bound to this driver.
|
| 1140 | * @soft_unbind: if set to 1, the USB core will not kill URBs and disable
|
| 1141 | * endpoints before calling the driver's disconnect method.
|
| 1142 | * @disable_hub_initiated_lpm: if set to 1, the USB core will not allow hubs
|
| 1143 | * to initiate lower power link state transitions when an idle timeout
|
| 1144 | * occurs. Device-initiated USB 3.0 link PM will still be allowed.
|
| 1145 | *
|
| 1146 | * USB interface drivers must provide a name, probe() and disconnect()
|
| 1147 | * methods, and an id_table. Other driver fields are optional.
|
| 1148 | *
|
| 1149 | * The id_table is used in hotplugging. It holds a set of descriptors,
|
| 1150 | * and specialized data may be associated with each entry. That table
|
| 1151 | * is used by both user and kernel mode hotplugging support.
|
| 1152 | *
|
| 1153 | * The probe() and disconnect() methods are called in a context where
|
| 1154 | * they can sleep, but they should avoid abusing the privilege. Most
|
| 1155 | * work to connect to a device should be done when the device is opened,
|
| 1156 | * and undone at the last close. The disconnect code needs to address
|
| 1157 | * concurrency issues with respect to open() and close() methods, as
|
| 1158 | * well as forcing all pending I/O requests to complete (by unlinking
|
| 1159 | * them as necessary, and blocking until the unlinks complete).
|
| 1160 |
|
| 1161 | struct usb_driver {
|
| 1162 | const char *name;
|
| 1163 |
|
| 1164 | int (*probe) (struct usb_interface *intf,
|
| 1165 | const struct usb_device_id *id);
|
| 1166 |
|
| 1167 | void (*disconnect) (struct usb_interface *intf);
|
| 1168 |
|
| 1169 | int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
|
| 1170 | void *buf);
|
| 1171 |
|
| 1172 | int (*suspend) (struct usb_interface *intf, pm_message_t message);
|
| 1173 | int (*resume) (struct usb_interface *intf);
|
| 1174 | int (*reset_resume)(struct usb_interface *intf);
|
| 1175 |
|
| 1176 | int (*pre_reset)(struct usb_interface *intf);
|
| 1177 | int (*post_reset)(struct usb_interface *intf);
|
| 1178 |
|
| 1179 | const struct usb_device_id *id_table;
|
| 1180 |
|
| 1181 | struct usb_dynids dynids;
|
| 1182 | struct usbdrv_wrap drvwrap;
|
| 1183 | unsigned int no_dynamic_id:1;
|
| 1184 | unsigned int supports_autosuspend:1;
|
| 1185 | unsigned int disable_hub_initiated_lpm:1;
|
| 1186 | unsigned int soft_unbind:1;
|
| 1187 | };
|
| 1188 | #define to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)
|
| 1189 |
|
| 1190 | |
| 1191 | * struct usb_device_driver - identifies USB device driver to usbcore
|
| 1192 | * @name: The driver name should be unique among USB drivers,
|
| 1193 | * and should normally be the same as the module name.
|
| 1194 | * @probe: Called to see if the driver is willing to manage a particular
|
| 1195 | * device. If it is, probe returns zero and uses dev_set_drvdata()
|
| 1196 | * to associate driver-specific data with the device. If unwilling
|
| 1197 | * to manage the device, return a negative errno value.
|
| 1198 | * @disconnect: Called when the device is no longer accessible, usually
|
| 1199 | * because it has been (or is being) disconnected or the driver's
|
| 1200 | * module is being unloaded.
|
| 1201 | * @suspend: Called when the device is going to be suspended by the system.
|
| 1202 | * @resume: Called when the device is being resumed by the system.
|
| 1203 | * @drvwrap: Driver-model core structure wrapper.
|
| 1204 | * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
|
| 1205 | * for devices bound to this driver.
|
| 1206 | *
|
| 1207 | * USB drivers must provide all the fields listed above except drvwrap.
|
| 1208 |
|
| 1209 | struct usb_device_driver {
|
| 1210 | const char *name;
|
| 1211 |
|
| 1212 | int (*probe) (struct usb_device *udev);
|
| 1213 | void (*disconnect) (struct usb_device *udev);
|
| 1214 |
|
| 1215 | int (*suspend) (struct usb_device *udev, pm_message_t message);
|
| 1216 | int (*resume) (struct usb_device *udev, pm_message_t message);
|
| 1217 | struct usbdrv_wrap drvwrap;
|
| 1218 | unsigned int supports_autosuspend:1;
|
| 1219 | };
|
| 1220 | #define to_usb_device_driver(d) container_of(d, struct usb_device_driver, \
|
| 1221 | drvwrap.driver)
|
| 1222 |
|
| 1223 | extern struct bus_type usb_bus_type;
|
| 1224 |
|
| 1225 | |
| 1226 | * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
|
| 1227 | * @name: the usb class device name for this driver. Will show up in sysfs.
|
| 1228 | * @devnode: Callback to provide a naming hint for a possible
|
| 1229 | * device node to create.
|
| 1230 | * @fops: pointer to the struct file_operations of this driver.
|
| 1231 | * @minor_base: the start of the minor range for this driver.
|
| 1232 | *
|
| 1233 | * This structure is used for the usb_register_dev() and
|
| 1234 | * usb_deregister_dev() functions, to consolidate a number of the
|
| 1235 | * parameters used for them.
|
| 1236 |
|
| 1237 | struct usb_class_driver {
|
| 1238 | char *name;
|
| 1239 | char *(*devnode)(struct device *dev, umode_t *mode);
|
| 1240 | const struct file_operations *fops;
|
| 1241 | int minor_base;
|
| 1242 | };
|
| 1243 |
|
| 1244 | |
| 1245 | * use these in module_init()/module_exit()
|
| 1246 | * and don't forget MODULE_DEVICE_TABLE(usb, ...)
|
| 1247 |
|
| 1248 | extern int usb_register_driver(struct usb_driver *, struct module *,
|
| 1249 | const char *);
|
| 1250 |
|
| 1251 |
|
| 1252 | #define usb_register(driver) \
|
| 1253 | usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
|
| 1254 |
|
| 1255 | extern void usb_deregister(struct usb_driver *);
|
| 1256 |
|
| 1257 | |
| 1258 | * module_usb_driver() - Helper macro for registering a USB driver
|
| 1259 | * @__usb_driver: usb_driver struct
|
| 1260 | *
|
| 1261 | * Helper macro for USB drivers which do not do anything special in module
|
| 1262 | * init/exit. This eliminates a lot of boilerplate. Each module may only
|
| 1263 | * use this macro once, and calling it replaces module_init() and module_exit()
|
| 1264 |
|
| 1265 | #define module_usb_driver(__usb_driver) \
|
| 1266 | module_driver(__usb_driver, usb_register, \
|
| 1267 | usb_deregister)
|
| 1268 |
|
| 1269 | extern int usb_register_device_driver(struct usb_device_driver *,
|
| 1270 | struct module *);
|
| 1271 | extern void usb_deregister_device_driver(struct usb_device_driver *);
|
| 1272 |
|
| 1273 | extern int usb_register_dev(struct usb_interface *intf,
|
| 1274 | struct usb_class_driver *class_driver);
|
| 1275 | extern void usb_deregister_dev(struct usb_interface *intf,
|
| 1276 | struct usb_class_driver *class_driver);
|
| 1277 |
|
| 1278 | extern int usb_disabled(void);
|
| 1279 |
|
| 1280 |
|
| 1281 |
|
| 1282 | |
| 1283 | * URB support, for asynchronous request completions
|
| 1284 |
|
| 1285 |
|
| 1286 | |
| 1287 | * urb->transfer_flags:
|
| 1288 | *
|
| 1289 | * Note: URB_DIR_IN/OUT is automatically set in usb_submit_urb().
|
| 1290 |
|
| 1291 | #define URB_SHORT_NOT_OK 0x0001
|
| 1292 | #define URB_ISO_ASAP 0x0002 |
| 1293 | * slot in the schedule
|
| 1294 | #define URB_NO_TRANSFER_DMA_MAP 0x0004
|
| 1295 | #define URB_NO_FSBR 0x0020
|
| 1296 | #define URB_ZERO_PACKET 0x0040
|
| 1297 | #define URB_NO_INTERRUPT 0x0080 |
| 1298 | * needed
|
| 1299 | #define URB_FREE_BUFFER 0x0100
|
| 1300 |
|
| 1301 |
|
| 1302 | #define URB_DIR_IN 0x0200
|
| 1303 | #define URB_DIR_OUT 0
|
| 1304 | #define URB_DIR_MASK URB_DIR_IN
|
| 1305 |
|
| 1306 | #define URB_DMA_MAP_SINGLE 0x00010000
|
| 1307 | #define URB_DMA_MAP_PAGE 0x00020000
|
| 1308 | #define URB_DMA_MAP_SG 0x00040000
|
| 1309 | #define URB_MAP_LOCAL 0x00080000
|
| 1310 | #define URB_SETUP_MAP_SINGLE 0x00100000
|
| 1311 | #define URB_SETUP_MAP_LOCAL 0x00200000
|
| 1312 | #define URB_DMA_SG_COMBINED 0x00400000
|
| 1313 | #define URB_ALIGNED_TEMP_BUFFER 0x00800000
|
| 1314 |
|
| 1315 | struct usb_iso_packet_descriptor {
|
| 1316 | unsigned int offset;
|
| 1317 | unsigned int length;
|
| 1318 | unsigned int actual_length;
|
| 1319 | int status;
|
| 1320 | };
|
| 1321 |
|
| 1322 | struct urb;
|
| 1323 |
|
| 1324 | struct usb_anchor {
|
| 1325 | struct list_head urb_list;
|
| 1326 | wait_queue_head_t wait;
|
| 1327 | spinlock_t lock;
|
| 1328 | atomic_t suspend_wakeups;
|
| 1329 | unsigned int poisoned:1;
|
| 1330 | };
|
| 1331 |
|
| 1332 | static inline void init_usb_anchor(struct usb_anchor *anchor)
|
| 1333 | {
|
| 1334 | memset(anchor, 0, sizeof(*anchor));
|
| 1335 | INIT_LIST_HEAD(&anchor->urb_list);
|
| 1336 | init_waitqueue_head(&anchor->wait);
|
| 1337 | spin_lock_init(&anchor->lock);
|
| 1338 | }
|
| 1339 |
|
| 1340 | typedef void (*usb_complete_t)(struct urb *);
|
| 1341 |
|
| 1342 | |
| 1343 | * struct urb - USB Request Block
|
| 1344 | * @urb_list: For use by current owner of the URB.
|
| 1345 | * @anchor_list: membership in the list of an anchor
|
| 1346 | * @anchor: to anchor URBs to a common mooring
|
| 1347 | * @ep: Points to the endpoint's data structure. Will eventually
|
| 1348 | * replace @pipe.
|
| 1349 | * @pipe: Holds endpoint number, direction, type, and more.
|
| 1350 | * Create these values with the eight macros available;
|
| 1351 | * usb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"
|
| 1352 | * (control), "bulk", "int" (interrupt), or "iso" (isochronous).
|
| 1353 | * For example usb_sndbulkpipe() or usb_rcvintpipe(). Endpoint
|
| 1354 | * numbers range from zero to fifteen. Note that "in" endpoint two
|
| 1355 | * is a different endpoint (and pipe) from "out" endpoint two.
|
| 1356 | * The current configuration controls the existence, type, and
|
| 1357 | * maximum packet size of any given endpoint.
|
| 1358 | * @stream_id: the endpoint's stream ID for bulk streams
|
| 1359 | * @dev: Identifies the USB device to perform the request.
|
| 1360 | * @status: This is read in non-iso completion functions to get the
|
| 1361 | * status of the particular request. ISO requests only use it
|
| 1362 | * to tell whether the URB was unlinked; detailed status for
|
| 1363 | * each frame is in the fields of the iso_frame-desc.
|
| 1364 | * @transfer_flags: A variety of flags may be used to affect how URB
|
| 1365 | * submission, unlinking, or operation are handled. Different
|
| 1366 | * kinds of URB can use different flags.
|
| 1367 | * @transfer_buffer: This identifies the buffer to (or from) which the I/O
|
| 1368 | * request will be performed unless URB_NO_TRANSFER_DMA_MAP is set
|
| 1369 | * (however, do not leave garbage in transfer_buffer even then).
|
| 1370 | * This buffer must be suitable for DMA; allocate it with
|
| 1371 | * kmalloc() or equivalent. For transfers to "in" endpoints, contents
|
| 1372 | * of this buffer will be modified. This buffer is used for the data
|
| 1373 | * stage of control transfers.
|
| 1374 | * @transfer_dma: When transfer_flags includes URB_NO_TRANSFER_DMA_MAP,
|
| 1375 | * the device driver is saying that it provided this DMA address,
|
| 1376 | * which the host controller driver should use in preference to the
|
| 1377 | * transfer_buffer.
|
| 1378 | * @sg: scatter gather buffer list, the buffer size of each element in
|
| 1379 | * the list (except the last) must be divisible by the endpoint's
|
| 1380 | * max packet size if no_sg_constraint isn't set in 'struct usb_bus'
|
| 1381 | * @num_mapped_sgs: (internal) number of mapped sg entries
|
| 1382 | * @num_sgs: number of entries in the sg list
|
| 1383 | * @transfer_buffer_length: How big is transfer_buffer. The transfer may
|
| 1384 | * be broken up into chunks according to the current maximum packet
|
| 1385 | * size for the endpoint, which is a function of the configuration
|
| 1386 | * and is encoded in the pipe. When the length is zero, neither
|
| 1387 | * transfer_buffer nor transfer_dma is used.
|
| 1388 | * @actual_length: This is read in non-iso completion functions, and
|
| 1389 | * it tells how many bytes (out of transfer_buffer_length) were
|
| 1390 | * transferred. It will normally be the same as requested, unless
|
| 1391 | * either an error was reported or a short read was performed.
|
| 1392 | * The URB_SHORT_NOT_OK transfer flag may be used to make such
|
| 1393 | * short reads be reported as errors.
|
| 1394 | * @setup_packet: Only used for control transfers, this points to eight bytes
|
| 1395 | * of setup data. Control transfers always start by sending this data
|
| 1396 | * to the device. Then transfer_buffer is read or written, if needed.
|
| 1397 | * @setup_dma: DMA pointer for the setup packet. The caller must not use
|
| 1398 | * this field; setup_packet must point to a valid buffer.
|
| 1399 | * @start_frame: Returns the initial frame for isochronous transfers.
|
| 1400 | * @number_of_packets: Lists the number of ISO transfer buffers.
|
| 1401 | * @interval: Specifies the polling interval for interrupt or isochronous
|
| 1402 | * transfers. The units are frames (milliseconds) for full and low
|
| 1403 | * speed devices, and microframes (1/8 millisecond) for highspeed
|
| 1404 | * and SuperSpeed devices.
|
| 1405 | * @error_count: Returns the number of ISO transfers that reported errors.
|
| 1406 | * @context: For use in completion functions. This normally points to
|
| 1407 | * request-specific driver context.
|
| 1408 | * @complete: Completion handler. This URB is passed as the parameter to the
|
| 1409 | * completion function. The completion function may then do what
|
| 1410 | * it likes with the URB, including resubmitting or freeing it.
|
| 1411 | * @iso_frame_desc: Used to provide arrays of ISO transfer buffers and to
|
| 1412 | * collect the transfer status for each buffer.
|
| 1413 | *
|
| 1414 | * This structure identifies USB transfer requests. URBs must be allocated by
|
| 1415 | * calling usb_alloc_urb() and freed with a call to usb_free_urb().
|
| 1416 | * Initialization may be done using various usb_fill_*_urb() functions. URBs
|
| 1417 | * are submitted using usb_submit_urb(), and pending requests may be canceled
|
| 1418 | * using usb_unlink_urb() or usb_kill_urb().
|
| 1419 | *
|
| 1420 | * Data Transfer Buffers:
|
| 1421 | *
|
| 1422 | * Normally drivers provide I/O buffers allocated with kmalloc() or otherwise
|
| 1423 | * taken from the general page pool. That is provided by transfer_buffer
|
| 1424 | * (control requests also use setup_packet), and host controller drivers
|
| 1425 | * perform a dma mapping (and unmapping) for each buffer transferred. Those
|
| 1426 | * mapping operations can be expensive on some platforms (perhaps using a dma
|
| 1427 | * bounce buffer or talking to an IOMMU),
|
| 1428 | * although they're cheap on commodity x86 and ppc hardware.
|
| 1429 | *
|
| 1430 | * Alternatively, drivers may pass the URB_NO_TRANSFER_DMA_MAP transfer flag,
|
| 1431 | * which tells the host controller driver that no such mapping is needed for
|
| 1432 | * the transfer_buffer since
|
| 1433 | * the device driver is DMA-aware. For example, a device driver might
|
| 1434 | * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map().
|
| 1435 | * When this transfer flag is provided, host controller drivers will
|
| 1436 | * attempt to use the dma address found in the transfer_dma
|
| 1437 | * field rather than determining a dma address themselves.
|
| 1438 | *
|
| 1439 | * Note that transfer_buffer must still be set if the controller
|
| 1440 | * does not support DMA (as indicated by bus.uses_dma) and when talking
|
| 1441 | * to root hub. If you have to trasfer between highmem zone and the device
|
| 1442 | * on such controller, create a bounce buffer or bail out with an error.
|
| 1443 | * If transfer_buffer cannot be set (is in highmem) and the controller is DMA
|
| 1444 | * capable, assign NULL to it, so that usbmon knows not to use the value.
|
| 1445 | * The setup_packet must always be set, so it cannot be located in highmem.
|
| 1446 | *
|
| 1447 | * Initialization:
|
| 1448 | *
|
| 1449 | * All URBs submitted must initialize the dev, pipe, transfer_flags (may be
|
| 1450 | * zero), and complete fields. All URBs must also initialize
|
| 1451 | * transfer_buffer and transfer_buffer_length. They may provide the
|
| 1452 | * URB_SHORT_NOT_OK transfer flag, indicating that short reads are
|
| 1453 | * to be treated as errors; that flag is invalid for write requests.
|
| 1454 | *
|
| 1455 | * Bulk URBs may
|
| 1456 | * use the URB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
|
| 1457 | * should always terminate with a short packet, even if it means adding an
|
| 1458 | * extra zero length packet.
|
| 1459 | *
|
| 1460 | * Control URBs must provide a valid pointer in the setup_packet field.
|
| 1461 | * Unlike the transfer_buffer, the setup_packet may not be mapped for DMA
|
| 1462 | * beforehand.
|
| 1463 | *
|
| 1464 | * Interrupt URBs must provide an interval, saying how often (in milliseconds
|
| 1465 | * or, for highspeed devices, 125 microsecond units)
|
| 1466 | * to poll for transfers. After the URB has been submitted, the interval
|
| 1467 | * field reflects how the transfer was actually scheduled.
|
| 1468 | * The polling interval may be more frequent than requested.
|
| 1469 | * For example, some controllers have a maximum interval of 32 milliseconds,
|
| 1470 | * while others support intervals of up to 1024 milliseconds.
|
| 1471 | * Isochronous URBs also have transfer intervals. (Note that for isochronous
|
| 1472 | * endpoints, as well as high speed interrupt endpoints, the encoding of
|
| 1473 | * the transfer interval in the endpoint descriptor is logarithmic.
|
| 1474 | * Device drivers must convert that value to linear units themselves.)
|
| 1475 | *
|
| 1476 | * If an isochronous endpoint queue isn't already running, the host
|
| 1477 | * controller will schedule a new URB to start as soon as bandwidth
|
| 1478 | * utilization allows. If the queue is running then a new URB will be
|
| 1479 | * scheduled to start in the first transfer slot following the end of the
|
| 1480 | * preceding URB, if that slot has not already expired. If the slot has
|
| 1481 | * expired (which can happen when IRQ delivery is delayed for a long time),
|
| 1482 | * the scheduling behavior depends on the URB_ISO_ASAP flag. If the flag
|
| 1483 | * is clear then the URB will be scheduled to start in the expired slot,
|
| 1484 | * implying that some of its packets will not be transferred; if the flag
|
| 1485 | * is set then the URB will be scheduled in the first unexpired slot,
|
| 1486 | * breaking the queue's synchronization. Upon URB completion, the
|
| 1487 | * start_frame field will be set to the (micro)frame number in which the
|
| 1488 | * transfer was scheduled. Ranges for frame counter values are HC-specific
|
| 1489 | * and can go from as low as 256 to as high as 65536 frames.
|
| 1490 | *
|
| 1491 | * Isochronous URBs have a different data transfer model, in part because
|
| 1492 | * the quality of service is only "best effort". Callers provide specially
|
| 1493 | * allocated URBs, with number_of_packets worth of iso_frame_desc structures
|
| 1494 | * at the end. Each such packet is an individual ISO transfer. Isochronous
|
| 1495 | * URBs are normally queued, submitted by drivers to arrange that
|
| 1496 | * transfers are at least double buffered, and then explicitly resubmitted
|
| 1497 | * in completion handlers, so
|
| 1498 | * that data (such as audio or video) streams at as constant a rate as the
|
| 1499 | * host controller scheduler can support.
|
| 1500 | *
|
| 1501 | * Completion Callbacks:
|
| 1502 | *
|
| 1503 | * The completion callback is made in_interrupt(), and one of the first
|
| 1504 | * things that a completion handler should do is check the status field.
|
| 1505 | * The status field is provided for all URBs. It is used to report
|
| 1506 | * unlinked URBs, and status for all non-ISO transfers. It should not
|
| 1507 | * be examined before the URB is returned to the completion handler.
|
| 1508 | *
|
| 1509 | * The context field is normally used to link URBs back to the relevant
|
| 1510 | * driver or request state.
|
| 1511 | *
|
| 1512 | * When the completion callback is invoked for non-isochronous URBs, the
|
| 1513 | * actual_length field tells how many bytes were transferred. This field
|
| 1514 | * is updated even when the URB terminated with an error or was unlinked.
|
| 1515 | *
|
| 1516 | * ISO transfer status is reported in the status and actual_length fields
|
| 1517 | * of the iso_frame_desc array, and the number of errors is reported in
|
| 1518 | * error_count. Completion callbacks for ISO transfers will normally
|
| 1519 | * (re)submit URBs to ensure a constant transfer rate.
|
| 1520 | *
|
| 1521 | * Note that even fields marked "public" should not be touched by the driver
|
| 1522 | * when the urb is owned by the hcd, that is, since the call to
|
| 1523 | * usb_submit_urb() till the entry into the completion routine.
|
| 1524 |
|
| 1525 | struct urb {
|
| 1526 |
|
| 1527 | struct kref kref;
|
| 1528 | void *hcpriv;
|
| 1529 | atomic_t use_count;
|
| 1530 | atomic_t reject;
|
| 1531 | int unlinked;
|
| 1532 |
|
| 1533 |
|
| 1534 | struct list_head urb_list; |
| 1535 | * current owner
|
| 1536 | struct list_head anchor_list;
|
| 1537 | struct usb_anchor *anchor;
|
| 1538 | struct usb_device *dev;
|
| 1539 | struct usb_host_endpoint *ep;
|
| 1540 | unsigned int pipe;
|
| 1541 | unsigned int stream_id;
|
| 1542 | int status;
|
| 1543 | unsigned int transfer_flags;
|
| 1544 | void *transfer_buffer;
|
| 1545 | dma_addr_t transfer_dma;
|
| 1546 | struct scatterlist *sg;
|
| 1547 | int num_mapped_sgs;
|
| 1548 | int num_sgs;
|
| 1549 | u32 transfer_buffer_length;
|
| 1550 | u32 actual_length;
|
| 1551 | unsigned char *setup_packet;
|
| 1552 | dma_addr_t setup_dma;
|
| 1553 | int start_frame;
|
| 1554 | int number_of_packets;
|
| 1555 | int interval; |
| 1556 | * (INT/ISO)
|
| 1557 | int error_count;
|
| 1558 | void *context;
|
| 1559 | usb_complete_t complete;
|
| 1560 | struct usb_iso_packet_descriptor iso_frame_desc[0];
|
| 1561 |
|
| 1562 | };
|
| 1563 |
|
| 1564 |
|
| 1565 |
|
| 1566 | |
| 1567 | * usb_fill_control_urb - initializes a control urb
|
| 1568 | * @urb: pointer to the urb to initialize.
|
| 1569 | * @dev: pointer to the struct usb_device for this urb.
|
| 1570 | * @pipe: the endpoint pipe
|
| 1571 | * @setup_packet: pointer to the setup_packet buffer
|
| 1572 | * @transfer_buffer: pointer to the transfer buffer
|
| 1573 | * @buffer_length: length of the transfer buffer
|
| 1574 | * @complete_fn: pointer to the usb_complete_t function
|
| 1575 | * @context: what to set the urb context to.
|
| 1576 | *
|
| 1577 | * Initializes a control urb with the proper information needed to submit
|
| 1578 | * it to a device.
|
| 1579 |
|
| 1580 | static inline void usb_fill_control_urb(struct urb *urb,
|
| 1581 | struct usb_device *dev,
|
| 1582 | unsigned int pipe,
|
| 1583 | unsigned char *setup_packet,
|
| 1584 | void *transfer_buffer,
|
| 1585 | int buffer_length,
|
| 1586 | usb_complete_t complete_fn,
|
| 1587 | void *context)
|
| 1588 | {
|
| 1589 | urb->dev = dev;
|
| 1590 | urb->pipe = pipe;
|
| 1591 | urb->setup_packet = setup_packet;
|
| 1592 | urb->transfer_buffer = transfer_buffer;
|
| 1593 | urb->transfer_buffer_length = buffer_length;
|
| 1594 | urb->complete = complete_fn;
|
| 1595 | urb->context = context;
|
| 1596 | }
|
| 1597 |
|
| 1598 | |
| 1599 | * usb_fill_bulk_urb - macro to help initialize a bulk urb
|
| 1600 | * @urb: pointer to the urb to initialize.
|
| 1601 | * @dev: pointer to the struct usb_device for this urb.
|
| 1602 | * @pipe: the endpoint pipe
|
| 1603 | * @transfer_buffer: pointer to the transfer buffer
|
| 1604 | * @buffer_length: length of the transfer buffer
|
| 1605 | * @complete_fn: pointer to the usb_complete_t function
|
| 1606 | * @context: what to set the urb context to.
|
| 1607 | *
|
| 1608 | * Initializes a bulk urb with the proper information needed to submit it
|
| 1609 | * to a device.
|
| 1610 |
|
| 1611 | static inline void usb_fill_bulk_urb(struct urb *urb,
|
| 1612 | struct usb_device *dev,
|
| 1613 | unsigned int pipe,
|
| 1614 | void *transfer_buffer,
|
| 1615 | int buffer_length,
|
| 1616 | usb_complete_t complete_fn,
|
| 1617 | void *context)
|
| 1618 | {
|
| 1619 | urb->dev = dev;
|
| 1620 | urb->pipe = pipe;
|
| 1621 | urb->transfer_buffer = transfer_buffer;
|
| 1622 | urb->transfer_buffer_length = buffer_length;
|
| 1623 | urb->complete = complete_fn;
|
| 1624 | urb->context = context;
|
| 1625 | }
|
| 1626 |
|
| 1627 | |
| 1628 | * usb_fill_int_urb - macro to help initialize a interrupt urb
|
| 1629 | * @urb: pointer to the urb to initialize.
|
| 1630 | * @dev: pointer to the struct usb_device for this urb.
|
| 1631 | * @pipe: the endpoint pipe
|
| 1632 | * @transfer_buffer: pointer to the transfer buffer
|
| 1633 | * @buffer_length: length of the transfer buffer
|
| 1634 | * @complete_fn: pointer to the usb_complete_t function
|
| 1635 | * @context: what to set the urb context to.
|
| 1636 | * @interval: what to set the urb interval to, encoded like
|
| 1637 | * the endpoint descriptor's bInterval value.
|
| 1638 | *
|
| 1639 | * Initializes a interrupt urb with the proper information needed to submit
|
| 1640 | * it to a device.
|
| 1641 | *
|
| 1642 | * Note that High Speed and SuperSpeed(+) interrupt endpoints use a logarithmic
|
| 1643 | * encoding of the endpoint interval, and express polling intervals in
|
| 1644 | * microframes (eight per millisecond) rather than in frames (one per
|
| 1645 | * millisecond).
|
| 1646 | *
|
| 1647 | * Wireless USB also uses the logarithmic encoding, but specifies it in units of
|
| 1648 | * 128us instead of 125us. For Wireless USB devices, the interval is passed
|
| 1649 | * through to the host controller, rather than being translated into microframe
|
| 1650 | * units.
|
| 1651 |
|
| 1652 | static inline void usb_fill_int_urb(struct urb *urb,
|
| 1653 | struct usb_device *dev,
|
| 1654 | unsigned int pipe,
|
| 1655 | void *transfer_buffer,
|
| 1656 | int buffer_length,
|
| 1657 | usb_complete_t complete_fn,
|
| 1658 | void *context,
|
| 1659 | int interval)
|
| 1660 | {
|
| 1661 | urb->dev = dev;
|
| 1662 | urb->pipe = pipe;
|
| 1663 | urb->transfer_buffer = transfer_buffer;
|
| 1664 | urb->transfer_buffer_length = buffer_length;
|
| 1665 | urb->complete = complete_fn;
|
| 1666 | urb->context = context;
|
| 1667 |
|
| 1668 | if (dev->speed == USB_SPEED_HIGH || dev->speed >= USB_SPEED_SUPER) {
|
| 1669 |
|
| 1670 | interval = clamp(interval, 1, 16);
|
| 1671 |
|
| 1672 | urb->interval = 1 << (interval - 1);
|
| 1673 | } else {
|
| 1674 | urb->interval = interval;
|
| 1675 | }
|
| 1676 |
|
| 1677 | urb->start_frame = -1;
|
| 1678 | }
|
| 1679 |
|
| 1680 | extern void usb_init_urb(struct urb *urb);
|
| 1681 | extern struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags);
|
| 1682 | extern void usb_free_urb(struct urb *urb);
|
| 1683 | #define usb_put_urb usb_free_urb
|
| 1684 | extern struct urb *usb_get_urb(struct urb *urb);
|
| 1685 | extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);
|
| 1686 | extern int usb_unlink_urb(struct urb *urb);
|
| 1687 | extern void usb_kill_urb(struct urb *urb);
|
| 1688 | extern void usb_poison_urb(struct urb *urb);
|
| 1689 | extern void usb_unpoison_urb(struct urb *urb);
|
| 1690 | extern void usb_block_urb(struct urb *urb);
|
| 1691 | extern void usb_kill_anchored_urbs(struct usb_anchor *anchor);
|
| 1692 | extern void usb_poison_anchored_urbs(struct usb_anchor *anchor);
|
| 1693 | extern void usb_unpoison_anchored_urbs(struct usb_anchor *anchor);
|
| 1694 | extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor);
|
| 1695 | extern void usb_anchor_suspend_wakeups(struct usb_anchor *anchor);
|
| 1696 | extern void usb_anchor_resume_wakeups(struct usb_anchor *anchor);
|
| 1697 | extern void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor);
|
| 1698 | extern void usb_unanchor_urb(struct urb *urb);
|
| 1699 | extern int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,
|
| 1700 | unsigned int timeout);
|
| 1701 | extern struct urb *usb_get_from_anchor(struct usb_anchor *anchor);
|
| 1702 | extern void usb_scuttle_anchored_urbs(struct usb_anchor *anchor);
|
| 1703 | extern int usb_anchor_empty(struct usb_anchor *anchor);
|
| 1704 |
|
| 1705 | #define usb_unblock_urb usb_unpoison_urb
|
| 1706 |
|
| 1707 | |
| 1708 | * usb_urb_dir_in - check if an URB describes an IN transfer
|
| 1709 | * @urb: URB to be checked
|
| 1710 | *
|
| 1711 | * Return: 1 if @urb describes an IN transfer (device-to-host),
|
| 1712 | * otherwise 0.
|
| 1713 |
|
| 1714 | static inline int usb_urb_dir_in(struct urb *urb)
|
| 1715 | {
|
| 1716 | return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_IN;
|
| 1717 | }
|
| 1718 |
|
| 1719 | |
| 1720 | * usb_urb_dir_out - check if an URB describes an OUT transfer
|
| 1721 | * @urb: URB to be checked
|
| 1722 | *
|
| 1723 | * Return: 1 if @urb describes an OUT transfer (host-to-device),
|
| 1724 | * otherwise 0.
|
| 1725 |
|
| 1726 | static inline int usb_urb_dir_out(struct urb *urb)
|
| 1727 | {
|
| 1728 | return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_OUT;
|
| 1729 | }
|
| 1730 |
|
| 1731 | void *usb_alloc_coherent(struct usb_device *dev, size_t size,
|
| 1732 | gfp_t mem_flags, dma_addr_t *dma);
|
| 1733 | void usb_free_coherent(struct usb_device *dev, size_t size,
|
| 1734 | void *addr, dma_addr_t dma);
|
| 1735 |
|
| 1736 | #if 0 |
| 1737 | struct urb *usb_buffer_map(struct urb *urb);
|
| 1738 | void usb_buffer_dmasync(struct urb *urb);
|
| 1739 | void usb_buffer_unmap(struct urb *urb);
|
| 1740 | #endif
|
| 1741 |
|
| 1742 | struct scatterlist;
|
| 1743 | int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
|
| 1744 | struct scatterlist *sg, int nents);
|
| 1745 | #if 0 |
| 1746 | void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
|
| 1747 | struct scatterlist *sg, int n_hw_ents);
|
| 1748 | #endif
|
| 1749 | void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
|
| 1750 | struct scatterlist *sg, int n_hw_ents);
|
| 1751 |
|
| 1752 | |
| 1753 | * SYNCHRONOUS CALL SUPPORT *
|
| 1754 | *-------------------------------------------------------------------
|
| 1755 |
|
| 1756 | extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,
|
| 1757 | __u8 request, __u8 requesttype, __u16 value, __u16 index,
|
| 1758 | void *data, __u16 size, int timeout);
|
| 1759 | extern int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,
|
| 1760 | void *data, int len, int *actual_length, int timeout);
|
| 1761 | extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
|
| 1762 | void *data, int len, int *actual_length,
|
| 1763 | int timeout);
|
| 1764 |
|
| 1765 |
|
| 1766 | extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
|
| 1767 | unsigned char descindex, void *buf, int size);
|
| 1768 | extern int usb_get_status(struct usb_device *dev,
|
| 1769 | int type, int target, void *data);
|
| 1770 | extern int usb_string(struct usb_device *dev, int index,
|
| 1771 | char *buf, size_t size);
|
| 1772 |
|
| 1773 |
|
| 1774 | extern int usb_clear_halt(struct usb_device *dev, int pipe);
|
| 1775 | extern int usb_reset_configuration(struct usb_device *dev);
|
| 1776 | extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
|
| 1777 | extern void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr);
|
| 1778 |
|
| 1779 |
|
| 1780 | extern int usb_driver_set_configuration(struct usb_device *udev, int config);
|
| 1781 |
|
| 1782 |
|
| 1783 | extern int usb_choose_configuration(struct usb_device *udev);
|
| 1784 | extern int usb_set_configuration(struct usb_device *dev, int configuration);
|
| 1785 |
|
| 1786 | |
| 1787 | * timeouts, in milliseconds, used for sending/receiving control messages
|
| 1788 | * they typically complete within a few frames (msec) after they're issued
|
| 1789 | * USB identifies 5 second timeouts, maybe more in a few cases, and a few
|
| 1790 | * slow devices (like some MGE Ellipse UPSes) actually push that limit.
|
| 1791 |
|
| 1792 | #define USB_CTRL_GET_TIMEOUT 5000
|
| 1793 | #define USB_CTRL_SET_TIMEOUT 5000
|
| 1794 |
|
| 1795 |
|
| 1796 | |
| 1797 | * struct usb_sg_request - support for scatter/gather I/O
|
| 1798 | * @status: zero indicates success, else negative errno
|
| 1799 | * @bytes: counts bytes transferred.
|
| 1800 | *
|
| 1801 | * These requests are initialized using usb_sg_init(), and then are used
|
| 1802 | * as request handles passed to usb_sg_wait() or usb_sg_cancel(). Most
|
| 1803 | * members of the request object aren't for driver access.
|
| 1804 | *
|
| 1805 | * The status and bytecount values are valid only after usb_sg_wait()
|
| 1806 | * returns. If the status is zero, then the bytecount matches the total
|
| 1807 | * from the request.
|
| 1808 | *
|
| 1809 | * After an error completion, drivers may need to clear a halt condition
|
| 1810 | * on the endpoint.
|
| 1811 |
|
| 1812 | struct usb_sg_request {
|
| 1813 | int status;
|
| 1814 | size_t bytes;
|
| 1815 |
|
| 1816 | |
| 1817 | * members below are private to usbcore,
|
| 1818 | * and are not provided for driver access!
|
| 1819 |
|
| 1820 | spinlock_t lock;
|
| 1821 |
|
| 1822 | struct usb_device *dev;
|
| 1823 | int pipe;
|
| 1824 |
|
| 1825 | int entries;
|
| 1826 | struct urb **urbs;
|
| 1827 |
|
| 1828 | int count;
|
| 1829 | struct completion complete;
|
| 1830 | };
|
| 1831 |
|
| 1832 | int usb_sg_init(
|
| 1833 | struct usb_sg_request *io,
|
| 1834 | struct usb_device *dev,
|
| 1835 | unsigned pipe,
|
| 1836 | unsigned period,
|
| 1837 | struct scatterlist *sg,
|
| 1838 | int nents,
|
| 1839 | size_t length,
|
| 1840 | gfp_t mem_flags
|
| 1841 | );
|
| 1842 | void usb_sg_cancel(struct usb_sg_request *io);
|
| 1843 | void usb_sg_wait(struct usb_sg_request *io);
|
| 1844 |
|
| 1845 |
|
| 1846 |
|
| 1847 |
|
| 1848 | |
| 1849 | * For various legacy reasons, Linux has a small cookie that's paired with
|
| 1850 | * a struct usb_device to identify an endpoint queue. Queue characteristics
|
| 1851 | * are defined by the endpoint's descriptor. This cookie is called a "pipe",
|
| 1852 | * an unsigned int encoded as:
|
| 1853 | *
|
| 1854 | * - direction: bit 7 (0 = Host-to-Device [Out],
|
| 1855 | * 1 = Device-to-Host [In] ...
|
| 1856 | * like endpoint bEndpointAddress)
|
| 1857 | * - device address: bits 8-14 ... bit positions known to uhci-hcd
|
| 1858 | * - endpoint: bits 15-18 ... bit positions known to uhci-hcd
|
| 1859 | * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,
|
| 1860 | * 10 = control, 11 = bulk)
|
| 1861 | *
|
| 1862 | * Given the device address and endpoint descriptor, pipes are redundant.
|
| 1863 |
|
| 1864 |
|
| 1865 |
|
| 1866 |
|
| 1867 | #define PIPE_ISOCHRONOUS 0
|
| 1868 | #define PIPE_INTERRUPT 1
|
| 1869 | #define PIPE_CONTROL 2
|
| 1870 | #define PIPE_BULK 3
|
| 1871 |
|
| 1872 | #define usb_pipein(pipe) ((pipe) & USB_DIR_IN)
|
| 1873 | #define usb_pipeout(pipe) (!usb_pipein(pipe))
|
| 1874 |
|
| 1875 | #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f)
|
| 1876 | #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf)
|
| 1877 |
|
| 1878 | #define usb_pipetype(pipe) (((pipe) >> 30) & 3)
|
| 1879 | #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
|
| 1880 | #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT)
|
| 1881 | #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL)
|
| 1882 | #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK)
|
| 1883 |
|
| 1884 | static inline unsigned int __create_pipe(struct usb_device *dev,
|
| 1885 | unsigned int endpoint)
|
| 1886 | {
|
| 1887 | return (dev->devnum << 8) | (endpoint << 15);
|
| 1888 | }
|
| 1889 |
|
| 1890 |
|
| 1891 | #define usb_sndctrlpipe(dev, endpoint) \
|
| 1892 | ((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint))
|
| 1893 | #define usb_rcvctrlpipe(dev, endpoint) \
|
| 1894 | ((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
|
| 1895 | #define usb_sndisocpipe(dev, endpoint) \
|
| 1896 | ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint))
|
| 1897 | #define usb_rcvisocpipe(dev, endpoint) \
|
| 1898 | ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
|
| 1899 | #define usb_sndbulkpipe(dev, endpoint) \
|
| 1900 | ((PIPE_BULK << 30) | __create_pipe(dev, endpoint))
|
| 1901 | #define usb_rcvbulkpipe(dev, endpoint) \
|
| 1902 | ((PIPE_BULK << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
|
| 1903 | #define usb_sndintpipe(dev, endpoint) \
|
| 1904 | ((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint))
|
| 1905 | #define usb_rcvintpipe(dev, endpoint) \
|
| 1906 | ((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
|
| 1907 |
|
| 1908 | static inline struct usb_host_endpoint *
|
| 1909 | usb_pipe_endpoint(struct usb_device *dev, unsigned int pipe)
|
| 1910 | {
|
| 1911 | struct usb_host_endpoint **eps;
|
| 1912 | eps = usb_pipein(pipe) ? dev->ep_in : dev->ep_out;
|
| 1913 | return eps[usb_pipeendpoint(pipe)];
|
| 1914 | }
|
| 1915 |
|
| 1916 |
|
| 1917 |
|
| 1918 | static inline __u16
|
| 1919 | usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
|
| 1920 | {
|
| 1921 | struct usb_host_endpoint *ep;
|
| 1922 | unsigned epnum = usb_pipeendpoint(pipe);
|
| 1923 |
|
| 1924 | if (is_out) {
|
| 1925 | WARN_ON(usb_pipein(pipe));
|
| 1926 | ep = udev->ep_out[epnum];
|
| 1927 | } else {
|
| 1928 | WARN_ON(usb_pipeout(pipe));
|
| 1929 | ep = udev->ep_in[epnum];
|
| 1930 | }
|
| 1931 | if (!ep)
|
| 1932 | return 0;
|
| 1933 |
|
| 1934 |
|
| 1935 | return usb_endpoint_maxp(&ep->desc);
|
| 1936 | }
|
| 1937 |
|
| 1938 |
|
| 1939 |
|
| 1940 |
|
| 1941 | static inline int usb_translate_errors(int error_code)
|
| 1942 | {
|
| 1943 | switch (error_code) {
|
| 1944 | case 0:
|
| 1945 | case -ENOMEM:
|
| 1946 | case -ENODEV:
|
| 1947 | case -EOPNOTSUPP:
|
| 1948 | return error_code;
|
| 1949 | default:
|
| 1950 | return -EIO;
|
| 1951 | }
|
| 1952 | }
|
| 1953 |
|
| 1954 |
|
| 1955 | #define USB_DEVICE_ADD 0x0001
|
| 1956 | #define USB_DEVICE_REMOVE 0x0002
|
| 1957 | #define USB_BUS_ADD 0x0003
|
| 1958 | #define USB_BUS_REMOVE 0x0004
|
| 1959 | extern void usb_register_notify(struct notifier_block *nb);
|
| 1960 | extern void usb_unregister_notify(struct notifier_block *nb);
|
| 1961 |
|
| 1962 |
|
| 1963 | extern struct dentry *usb_debug_root;
|
| 1964 |
|
| 1965 |
|
| 1966 | enum usb_led_event {
|
| 1967 | USB_LED_EVENT_HOST = 0,
|
| 1968 | USB_LED_EVENT_GADGET = 1,
|
| 1969 | };
|
| 1970 |
|
| 1971 | #ifdef CONFIG_USB_LED_TRIG
|
| 1972 | extern void usb_led_activity(enum usb_led_event ev);
|
| 1973 | #else
|
| 1974 | static inline void usb_led_activity(enum usb_led_event ev) {}
|
| 1975 | #endif
|
| 1976 |
|
| 1977 | #endif
|
| 1978 |
|
| 1979 | #endif
|