v2.5.0.7 -> v2.5.0.8
[opensuse:kernel.git] / include / linux / usb.h
1 #ifndef __LINUX_USB_H
2 #define __LINUX_USB_H
3
4 /* USB constants */
5
6 /*
7  * Device and/or Interface Class codes
8  */
9 #define USB_CLASS_PER_INTERFACE         0       /* for DeviceClass */
10 #define USB_CLASS_AUDIO                 1
11 #define USB_CLASS_COMM                  2
12 #define USB_CLASS_HID                   3
13 #define USB_CLASS_PHYSICAL              5
14 #define USB_CLASS_STILL_IMAGE           6
15 #define USB_CLASS_PRINTER               7
16 #define USB_CLASS_MASS_STORAGE          8
17 #define USB_CLASS_HUB                   9
18 #define USB_CLASS_CDC_DATA              0x0a
19 #define USB_CLASS_CSCID         0x0b /* chip+ smart card */
20 #define USB_CLASS_CONTENT_SEC           0x0d /* content security */
21 #define USB_CLASS_APP_SPEC              0xfe
22 #define USB_CLASS_VENDOR_SPEC           0xff
23
24 /*
25  * USB types
26  */
27 #define USB_TYPE_MASK                   (0x03 << 5)
28 #define USB_TYPE_STANDARD               (0x00 << 5)
29 #define USB_TYPE_CLASS                  (0x01 << 5)
30 #define USB_TYPE_VENDOR                 (0x02 << 5)
31 #define USB_TYPE_RESERVED               (0x03 << 5)
32
33 /*
34  * USB recipients
35  */
36 #define USB_RECIP_MASK                  0x1f
37 #define USB_RECIP_DEVICE                0x00
38 #define USB_RECIP_INTERFACE             0x01
39 #define USB_RECIP_ENDPOINT              0x02
40 #define USB_RECIP_OTHER                 0x03
41
42 /*
43  * USB directions
44  */
45 #define USB_DIR_OUT                     0
46 #define USB_DIR_IN                      0x80
47
48 /*
49  * Endpoints
50  */
51 #define USB_ENDPOINT_NUMBER_MASK        0x0f    /* in bEndpointAddress */
52 #define USB_ENDPOINT_DIR_MASK           0x80
53
54 #define USB_ENDPOINT_XFERTYPE_MASK      0x03    /* in bmAttributes */
55 #define USB_ENDPOINT_XFER_CONTROL       0
56 #define USB_ENDPOINT_XFER_ISOC          1
57 #define USB_ENDPOINT_XFER_BULK          2
58 #define USB_ENDPOINT_XFER_INT           3
59
60 /*
61  * USB Packet IDs (PIDs)
62  */
63 #define USB_PID_UNDEF_0                        0xf0
64 #define USB_PID_OUT                            0xe1
65 #define USB_PID_ACK                            0xd2
66 #define USB_PID_DATA0                          0xc3
67 #define USB_PID_PING                           0xb4     /* USB 2.0 */
68 #define USB_PID_SOF                            0xa5
69 #define USB_PID_NYET                           0x96     /* USB 2.0 */
70 #define USB_PID_DATA2                          0x87     /* USB 2.0 */
71 #define USB_PID_SPLIT                          0x78     /* USB 2.0 */
72 #define USB_PID_IN                             0x69
73 #define USB_PID_NAK                            0x5a
74 #define USB_PID_DATA1                          0x4b
75 #define USB_PID_PREAMBLE                       0x3c     /* Token mode */
76 #define USB_PID_ERR                            0x3c     /* USB 2.0: handshake mode */
77 #define USB_PID_SETUP                          0x2d
78 #define USB_PID_STALL                          0x1e
79 #define USB_PID_MDATA                          0x0f     /* USB 2.0 */
80
81 /*
82  * Standard requests
83  */
84 #define USB_REQ_GET_STATUS              0x00
85 #define USB_REQ_CLEAR_FEATURE           0x01
86 #define USB_REQ_SET_FEATURE             0x03
87 #define USB_REQ_SET_ADDRESS             0x05
88 #define USB_REQ_GET_DESCRIPTOR          0x06
89 #define USB_REQ_SET_DESCRIPTOR          0x07
90 #define USB_REQ_GET_CONFIGURATION       0x08
91 #define USB_REQ_SET_CONFIGURATION       0x09
92 #define USB_REQ_GET_INTERFACE           0x0A
93 #define USB_REQ_SET_INTERFACE           0x0B
94 #define USB_REQ_SYNCH_FRAME             0x0C
95
96
97 #ifdef __KERNEL__
98
99 #include <linux/types.h>
100 #include <linux/ioctl.h>
101 #include <linux/version.h>
102 #include <linux/sched.h>
103 #include <linux/delay.h>
104 #include <linux/interrupt.h>    /* for in_interrupt() */
105 #include <linux/config.h>
106 #include <linux/list.h>
107
108 #define USB_MAJOR 180
109
110 static __inline__ void wait_ms(unsigned int ms)
111 {
112         if(!in_interrupt()) {
113                 current->state = TASK_UNINTERRUPTIBLE;
114                 schedule_timeout(1 + ms * HZ / 1000);
115         }
116         else
117                 mdelay(ms);
118 }
119
120 typedef struct {
121         __u8 requesttype;
122         __u8 request;
123         __u16 value;
124         __u16 index;
125         __u16 length;
126 } devrequest __attribute__ ((packed));
127
128 /*
129  * USB device number allocation bitmap. There's one bitmap
130  * per USB tree.
131  */
132 struct usb_devmap {
133         unsigned long devicemap[128 / (8*sizeof(unsigned long))];
134 };
135
136 #define USB_MAXBUS              64
137
138 struct usb_busmap {
139         unsigned long busmap[USB_MAXBUS / (8*sizeof(unsigned long))];
140 };
141
142 struct usb_device;
143
144 /*-------------------------------------------------------------------------*/
145
146 /*
147  * Standard USB Descriptor support.
148  * Devices may also have class-specific or vendor-specific descriptors.
149  */
150
151 /*
152  * Descriptor types ... USB 2.0 spec table 9.5
153  */
154 #define USB_DT_DEVICE                   0x01
155 #define USB_DT_CONFIG                   0x02
156 #define USB_DT_STRING                   0x03
157 #define USB_DT_INTERFACE                0x04
158 #define USB_DT_ENDPOINT                 0x05
159 #define USB_DT_DEVICE_QUALIFIER         0x06
160 #define USB_DT_OTHER_SPEED_CONFIG       0x07
161 #define USB_DT_INTERFACE_POWER          0x08
162
163 // FIXME should be internal to hub driver
164 #define USB_DT_HUB                      (USB_TYPE_CLASS | 0x09)
165 #define USB_DT_HUB_NONVAR_SIZE          7
166
167 /*
168  * Descriptor sizes per descriptor type
169  */
170 #define USB_DT_DEVICE_SIZE              18
171 #define USB_DT_CONFIG_SIZE              9
172 #define USB_DT_INTERFACE_SIZE           9
173 #define USB_DT_ENDPOINT_SIZE            7
174 #define USB_DT_ENDPOINT_AUDIO_SIZE      9       /* Audio extension */
175
176 /* most of these maximums are arbitrary */
177 #define USB_MAXCONFIG           8
178 #define USB_ALTSETTINGALLOC     4
179 #define USB_MAXALTSETTING       128  /* Hard limit */
180 #define USB_MAXINTERFACES       32
181 #define USB_MAXENDPOINTS        32   /* Hard limit */
182
183 /* All standard descriptors have these 2 fields in common */
184 struct usb_descriptor_header {
185         __u8  bLength;
186         __u8  bDescriptorType;
187 } __attribute__ ((packed));
188
189 /* USB_DT_DEVICE: Device descriptor */
190 struct usb_device_descriptor {
191         __u8  bLength;
192         __u8  bDescriptorType;
193         __u16 bcdUSB;
194         __u8  bDeviceClass;
195         __u8  bDeviceSubClass;
196         __u8  bDeviceProtocol;
197         __u8  bMaxPacketSize0;
198         __u16 idVendor;
199         __u16 idProduct;
200         __u16 bcdDevice;
201         __u8  iManufacturer;
202         __u8  iProduct;
203         __u8  iSerialNumber;
204         __u8  bNumConfigurations;
205 } __attribute__ ((packed));
206
207 /* USB_DT_ENDPOINT: Endpoint descriptor */
208 struct usb_endpoint_descriptor {
209         __u8  bLength           __attribute__ ((packed));
210         __u8  bDescriptorType   __attribute__ ((packed));
211         __u8  bEndpointAddress  __attribute__ ((packed));
212         __u8  bmAttributes      __attribute__ ((packed));
213         __u16 wMaxPacketSize    __attribute__ ((packed));
214         __u8  bInterval         __attribute__ ((packed));
215         __u8  bRefresh          __attribute__ ((packed));
216         __u8  bSynchAddress     __attribute__ ((packed));
217
218         /* the rest is internal to the Linux implementation */
219         unsigned char *extra;   /* Extra descriptors */
220         int extralen;
221 };
222
223 /* USB_DT_INTERFACE: Interface descriptor */
224 struct usb_interface_descriptor {
225         __u8  bLength           __attribute__ ((packed));
226         __u8  bDescriptorType   __attribute__ ((packed));
227         __u8  bInterfaceNumber  __attribute__ ((packed));
228         __u8  bAlternateSetting __attribute__ ((packed));
229         __u8  bNumEndpoints     __attribute__ ((packed));
230         __u8  bInterfaceClass   __attribute__ ((packed));
231         __u8  bInterfaceSubClass __attribute__ ((packed));
232         __u8  bInterfaceProtocol __attribute__ ((packed));
233         __u8  iInterface        __attribute__ ((packed));
234
235         /* the rest is internal to the Linux implementation */
236         struct usb_endpoint_descriptor *endpoint;
237
238         unsigned char *extra;   /* Extra descriptors */
239         int extralen;
240 };
241
242 struct usb_interface {
243         struct usb_interface_descriptor *altsetting;
244
245         int act_altsetting;             /* active alternate setting */
246         int num_altsetting;             /* number of alternate settings */
247         int max_altsetting;             /* total memory allocated */
248  
249         struct usb_driver *driver;      /* driver */
250         void *private_data;
251 };
252
253 /* USB_DT_CONFIG: Configuration descriptor information.
254  *
255  * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
256  * descriptor type is different.  Highspeed-capable devices can look
257  * different depending on what speed they're currently running.  Only
258  * devices with a USB_DT_DEVICE_QUALIFIER have an OTHER_SPEED_CONFIG.
259  */
260 struct usb_config_descriptor {
261         __u8  bLength           __attribute__ ((packed));
262         __u8  bDescriptorType   __attribute__ ((packed));
263         __u16 wTotalLength      __attribute__ ((packed));
264         __u8  bNumInterfaces    __attribute__ ((packed));
265         __u8  bConfigurationValue __attribute__ ((packed));
266         __u8  iConfiguration    __attribute__ ((packed));
267         __u8  bmAttributes      __attribute__ ((packed));
268         __u8  MaxPower          __attribute__ ((packed));
269
270         /* the rest is internal to the Linux implementation */
271         struct usb_interface *interface;
272
273         unsigned char *extra;   /* Extra descriptors */
274         int extralen;
275 };
276
277 /* USB_DT_STRING: String descriptor */
278 struct usb_string_descriptor {
279         __u8  bLength;
280         __u8  bDescriptorType;
281         __u16 wData[1];         /* UTF-16LE encoded */
282 } __attribute__ ((packed));
283
284 /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
285 struct usb_qualifier_descriptor {
286         __u8  bLength;
287         __u8  bDescriptorType;
288         __u16 bcdUSB;
289         __u8  bDeviceClass;
290         __u8  bDeviceSubClass;
291         __u8  bDeviceProtocol;
292         __u8  bMaxPacketSize0;
293         __u8  bNumConfigurations;
294         __u8  bRESERVED;
295 } __attribute__ ((packed));
296
297 /* helpers for driver access to descriptors */
298 extern struct usb_interface *
299         usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum);
300 extern struct usb_endpoint_descriptor *
301         usb_epnum_to_ep_desc(struct usb_device *dev, unsigned epnum);
302
303 int __usb_get_extra_descriptor(char *buffer, unsigned size,
304         unsigned char type, void **ptr);
305 #define usb_get_extra_descriptor(ifpoint,type,ptr)\
306         __usb_get_extra_descriptor((ifpoint)->extra,(ifpoint)->extralen,\
307                 type,(void**)ptr)
308
309 /*-------------------------------------------------------------------------*/
310
311 /*
312  * Device table entry for "new style" table-driven USB drivers.
313  * User mode code can read these tables to choose which modules to load.
314  * Declare the table as a MODULE_DEVICE_TABLE.
315  *
316  * The third probe() parameter will point to a matching entry from this
317  * table.  (Null value reserved.)  Use the driver_data field for each
318  * match to hold information tied to that match:  device quirks, etc.
319  * 
320  * Terminate the driver's table with an all-zeroes entry.
321  * Use the flag values to control which fields are compared.
322  */
323
324 /**
325  * struct usb_device_id - identifies USB devices for probing and hotplugging
326  * @match_flags: Bit mask controlling of the other fields are used to match
327  *      against new devices.  Any field except for driver_info may be used,
328  *      although some only make sense in conjunction with other fields.
329  *      This is usually set by a USB_DEVICE_*() macro, which sets all
330  *      other fields in this structure except for driver_info.
331  * @idVendor: USB vendor ID for a device; numbers are assigned
332  *      by the USB forum to its members.
333  * @idProduct: Vendor-assigned product ID.
334  * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers.
335  *      This is also used to identify individual product versions, for
336  *      a range consisting of a single device.
337  * @bcdDevice_hi: High end of version number range.  The range of product
338  *      versions is inclusive.
339  * @bDeviceClass: Class of device; numbers are assigned
340  *      by the USB forum.  Products may choose to implement classes,
341  *      or be vendor-specific.  Device classes specify behavior of all
342  *      the interfaces on a devices.
343  * @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
344  * @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
345  * @bInterfaceClass: Class of interface; numbers are assigned
346  *      by the USB forum.  Products may choose to implement classes,
347  *      or be vendor-specific.  Interface classes specify behavior only
348  *      of a given interface; other interfaces may support other classes.
349  * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass.
350  * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass.
351  * @driver_info: Holds information used by the driver.  Usually it holds
352  *      a pointer to a descriptor understood by the driver, or perhaps
353  *      device flags.
354  *
355  * In most cases, drivers will create a table of device IDs by using
356  * USB_DEVICE(), or similar macros designed for that purpose.
357  * They will then export it to userspace using MODULE_DEVICE_TABLE(),
358  * and provide it to the USB core through their usb_driver structure.
359  *
360  * See the usb_match_id() function for information about how matches are
361  * performed.  Briefly, you will normally use one of several macros to help
362  * construct these entries.  Each entry you provide will either identify
363  * one or more specific products, or will identify a class of products
364  * which have agreed to behave the same.  You should put the more specific
365  * matches towards the beginning of your table, so that driver_info can
366  * record quirks of specific products.
367  */
368 struct usb_device_id {
369         /* which fields to match against? */
370         __u16           match_flags;
371
372         /* Used for product specific matches; range is inclusive */
373         __u16           idVendor;
374         __u16           idProduct;
375         __u16           bcdDevice_lo;
376         __u16           bcdDevice_hi;
377
378         /* Used for device class matches */
379         __u8            bDeviceClass;
380         __u8            bDeviceSubClass;
381         __u8            bDeviceProtocol;
382
383         /* Used for interface class matches */
384         __u8            bInterfaceClass;
385         __u8            bInterfaceSubClass;
386         __u8            bInterfaceProtocol;
387
388         /* not matched against */
389         unsigned long   driver_info;
390 };
391
392 /* Some useful macros to use to create struct usb_device_id */
393 #define USB_DEVICE_ID_MATCH_VENDOR              0x0001
394 #define USB_DEVICE_ID_MATCH_PRODUCT             0x0002
395 #define USB_DEVICE_ID_MATCH_DEV_LO              0x0004
396 #define USB_DEVICE_ID_MATCH_DEV_HI              0x0008
397 #define USB_DEVICE_ID_MATCH_DEV_CLASS           0x0010
398 #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS        0x0020
399 #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL        0x0040
400 #define USB_DEVICE_ID_MATCH_INT_CLASS           0x0080
401 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100
402 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200
403
404 #define USB_DEVICE_ID_MATCH_DEVICE              (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
405 #define USB_DEVICE_ID_MATCH_DEV_RANGE           (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
406 #define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION  (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
407 #define USB_DEVICE_ID_MATCH_DEV_INFO \
408         (USB_DEVICE_ID_MATCH_DEV_CLASS | USB_DEVICE_ID_MATCH_DEV_SUBCLASS | USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
409 #define USB_DEVICE_ID_MATCH_INT_INFO \
410         (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)
411
412 /**
413  * USB_DEVICE - macro used to describe a specific usb device
414  * @vend: the 16 bit USB Vendor ID
415  * @prod: the 16 bit USB Product ID
416  *
417  * This macro is used to create a struct usb_device_id that matches a
418  * specific device.
419  */
420 #define USB_DEVICE(vend,prod) \
421         match_flags: USB_DEVICE_ID_MATCH_DEVICE, idVendor: (vend), idProduct: (prod)
422 /**
423  * USB_DEVICE_VER - macro used to describe a specific usb device with a version range
424  * @vend: the 16 bit USB Vendor ID
425  * @prod: the 16 bit USB Product ID
426  * @lo: the bcdDevice_lo value
427  * @hi: the bcdDevice_hi value
428  *
429  * This macro is used to create a struct usb_device_id that matches a
430  * specific device, with a version range.
431  */
432 #define USB_DEVICE_VER(vend,prod,lo,hi) \
433         match_flags: USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, idVendor: (vend), idProduct: (prod), bcdDevice_lo: (lo), bcdDevice_hi: (hi)
434
435 /**
436  * USB_DEVICE_INFO - macro used to describe a class of usb devices
437  * @cl: bDeviceClass value
438  * @sc: bDeviceSubClass value
439  * @pr: bDeviceProtocol value
440  *
441  * This macro is used to create a struct usb_device_id that matches a
442  * specific class of devices.
443  */
444 #define USB_DEVICE_INFO(cl,sc,pr) \
445         match_flags: USB_DEVICE_ID_MATCH_DEV_INFO, bDeviceClass: (cl), bDeviceSubClass: (sc), bDeviceProtocol: (pr)
446
447 /**
448  * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces 
449  * @cl: bInterfaceClass value
450  * @sc: bInterfaceSubClass value
451  * @pr: bInterfaceProtocol value
452  *
453  * This macro is used to create a struct usb_device_id that matches a
454  * specific class of interfaces.
455  */
456 #define USB_INTERFACE_INFO(cl,sc,pr) \
457         match_flags: USB_DEVICE_ID_MATCH_INT_INFO, bInterfaceClass: (cl), bInterfaceSubClass: (sc), bInterfaceProtocol: (pr)
458
459 /* -------------------------------------------------------------------------- */
460
461 /**
462  * struct usb_driver - identifies USB driver to usbcore
463  * @name: The driver name should be unique among USB drivers
464  * @probe: Called to see if the driver is willing to manage a particular
465  *      interface on a device.  The probe routine returns a handle that 
466  *      will later be provided to disconnect(), or a null pointer to
467  *      indicate that the driver will not handle the interface.
468  *      The handle is normally a pointer to driver-specific data.
469  *      If the probe() routine needs to access the interface
470  *      structure itself, use usb_ifnum_to_if() to make sure it's using
471  *      the right one.
472  * @disconnect: Called when the interface is no longer accessible, usually
473  *      because its device has been (or is being) disconnected.  The
474  *      handle passed is what was returned by probe(), or was provided
475  *      to usb_driver_claim_interface().
476  * @fops: USB drivers can reuse some character device framework in
477  *      the USB subsystem by providing a file operations vector and
478  *      a minor number.
479  * @minor: Used with fops to simplify creating USB character devices.
480  *      Such drivers have sixteen character devices, using the USB
481  *      major number and starting with this minor number.
482  * @ioctl: Used for drivers that want to talk to userspace through
483  *      the "usbfs" filesystem.  This lets devices provide ways to
484  *      expose information to user space regardless of where they
485  *      do (or don't) show up otherwise in the filesystem.
486  * @id_table: USB drivers use ID table to support hotplugging.
487  *      Export this with MODULE_DEVICE_TABLE(usb,...), or use NULL to
488  *      say that probe() should be called for any unclaimed interfce.
489  *
490  * USB drivers should provide a name, probe() and disconnect() methods,
491  * and an id_table.  Other driver fields are optional.
492  *
493  * The id_table is used in hotplugging.  It holds a set of descriptors,
494  * and specialized data may be associated with each entry.  That table
495  * is used by both user and kernel mode hotplugging support.
496  *
497  * The probe() and disconnect() methods are called in a context where
498  * they can sleep, but they should avoid abusing the privilage.  Most
499  * work to connect to a device should be done when the device is opened,
500  * and undone at the last close.  The disconnect code needs to address
501  * concurrency issues with respect to open() and close() methods, as
502  * well as cancel any I/O requests that are still pending.
503  */
504 struct usb_driver {
505         const char *name;
506
507         void *(*probe)(
508             struct usb_device *dev,             /* the device */
509             unsigned intf,                      /* what interface */
510             const struct usb_device_id *id      /* from id_table */
511             );
512         void (*disconnect)(
513             struct usb_device *dev,             /* the device */
514             void *handle                        /* as returned by probe() */
515             );
516
517         struct list_head driver_list;
518
519         struct file_operations *fops;
520         int minor;
521
522         struct semaphore serialize;
523
524         /* ioctl -- userspace apps can talk to drivers through usbdevfs */
525         int (*ioctl)(struct usb_device *dev, unsigned int code, void *buf);
526
527         /* support for "new-style" USB hotplugging */
528         const struct usb_device_id *id_table;
529
530         /* suspend before the bus suspends;
531          * disconnect or resume when the bus resumes */
532         /* void (*suspend)(struct usb_device *dev); */
533         /* void (*resume)(struct usb_device *dev); */
534 };
535
536 /*
537  * use these in module_init()/module_exit()
538  * and don't forget MODULE_DEVICE_TABLE(usb, ...)
539  */
540 extern int usb_register(struct usb_driver *);
541 extern void usb_deregister(struct usb_driver *);
542
543 /* -------------------------------------------------------------------------- */
544
545 /*
546  * URB support, for asynchronous request completions
547  */
548
549 /*
550  * urb->transfer_flags:
551  *
552  * FIXME should be URB_* flags
553  */
554 #define USB_DISABLE_SPD         0x0001
555 #define USB_ISO_ASAP            0x0002
556 #define USB_ASYNC_UNLINK        0x0008
557 #define USB_QUEUE_BULK          0x0010
558 #define USB_NO_FSBR             0x0020
559 #define USB_ZERO_PACKET         0x0040  /* Finish bulk OUTs with short packet */
560 #define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt needed */
561                                         /* ... less overhead for QUEUE_BULK */
562 #define USB_TIMEOUT_KILLED      0x1000  /* only set by HCD! */
563
564 typedef struct
565 {
566         unsigned int offset;
567         unsigned int length;            /* expected length */
568         unsigned int actual_length;
569         unsigned int status;
570 } iso_packet_descriptor_t, *piso_packet_descriptor_t;
571
572 struct urb;
573
574 typedef void (*usb_complete_t)(struct urb *);
575
576 /**
577  * struct urb - USB Request Block
578  * @urb_list: For use by current owner of the URB.
579  * @next: Used primarily to link ISO requests into rings.
580  * @pipe: Holds endpoint number, direction, type, and max packet size.
581  *      Create these values with the eight macros available;
582  *      usb_{snd,rcv}TYPEpipe(dev,endpoint), where the type is "ctrl"
583  *      (control), "bulk", "int" (interrupt), or "iso" (isochronous).
584  *      For example usb_sndbulkpipe() or usb_rcvintpipe().  Endpoint
585  *      numbers range from zero to fifteen.  Note that "in" endpoint two
586  *      is a different endpoint (and pipe) from "out" endpoint two.
587  *      The current configuration controls the existence, type, and
588  *      maximum packet size of any given endpoint.
589  * @dev: Identifies the USB device to perform the request.
590  * @status: This is read in non-iso completion functions to get the
591  *      status of the particular request.  ISO requests only use it
592  *      to tell whether the URB was unlinked; detailed status for
593  *      each frame is in the fields of the iso_frame-desc.
594  * @transfer_flags: A variety of flags may be used to affect how URB
595  *      submission, unlinking, or operation are handled.  Different
596  *      kinds of URB can use different flags.
597  * @transfer_buffer: For non-iso transfers, this identifies the buffer
598  *      to (or from) which the I/O request will be performed.  This
599  *      buffer must be suitable for DMA; allocate it with kmalloc()
600  *      or equivalent.  For transfers to "in" endpoints, contents of
601  *      this buffer will be modified.
602  * @transfer_buffer_length: How big is transfer_buffer.  The transfer may
603  *      be broken up into chunks according to the current maximum packet
604  *      size for the endpoint, which is a function of the configuration
605  *      and is encoded in the pipe.
606  * @actual_length: This is read in non-iso completion functions, and
607  *      it tells how many bytes (out of transfer_buffer_length) were
608  *      transferred.  It will normally be the same as requested, unless
609  *      either an error was reported or a short read was performed and
610  *      the USB_DISABLE_SPD transfer flag was used to say that such
611  *      short reads are not errors. 
612  * @setup_packet: Only used for control transfers, this points to eight bytes
613  *      of setup data.  Control transfers always start by sending this data
614  *      to the device.  Then transfer_buffer is read or written, if needed.
615  * @start_frame: Returns the initial frame for interrupt or isochronous
616  *      transfers.
617  * @number_of_packets: Lists the number of ISO transfer buffers.
618  * @interval: Specifies the polling interval for interrupt transfers, in
619  *      milliseconds.
620  * @error_count: Returns the number of ISO transfers that reported errors.
621  * @context: For use in completion functions.  This normally points to
622  *      request-specific driver context.
623  * @complete: Completion handler. This URB is passed as the parameter to the
624  *      completion function.  Except for interrupt or isochronous transfers
625  *      that aren't being unlinked, the completion function may then do what
626  *      it likes with the URB, including resubmitting or freeing it.
627  * @iso_frame_desc: Used to provide arrays of ISO transfer buffers and to 
628  *      collect the transfer status for each buffer.
629  *
630  * This structure identifies USB transfer requests.  URBs may be allocated
631  * in any way, although usb_alloc_urb() is often convenient.  Initialization
632  * may be done using various FILL_*_URB() macros.  URBs are submitted
633  * using usb_submit_urb(), and pending requests may be canceled using
634  * usb_unlink_urb().
635  *
636  * Initialization:
637  *
638  * All URBs submitted must initialize dev, pipe, next (may be null),
639  * transfer_flags (may be zero), complete, timeout (may be zero).
640  * The USB_ASYNC_UNLINK transfer flag affects later invocations of
641  * the usb_unlink_urb() routine.
642  *
643  * All non-isochronous URBs must also initialize 
644  * transfer_buffer and transfer_buffer_length.  They may provide the
645  * USB_DISABLE_SPD transfer flag, indicating that short reads are
646  * not to be treated as errors.
647  *
648  * Bulk URBs may pass the USB_QUEUE_BULK transfer flag, telling the host
649  * controller driver never to report an error if several bulk requests get
650  * queued to the same endpoint.  Such queueing supports more efficient use
651  * of bus bandwidth, minimizing delays due to interrupts and scheduling,
652  * if the host controller hardware is smart enough.  Bulk URBs can also
653  * use the USB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
654  * should always terminate with a short packet, even if it means adding an
655  * extra zero length packet.
656  *
657  * Control URBs must provide a setup_packet.
658  *
659  * Interupt UBS must provide an interval, saying how often (in milliseconds)
660  * to poll for transfers.  After the URB has been submitted, the interval
661  * and start_frame fields reflect how the transfer was actually scheduled.
662  * The polling interval may be more frequent than requested.
663  * For example, some controllers have a maximum interval of 32 microseconds,
664  * while others support intervals of up to 1024 microseconds.
665  *
666  * Isochronous URBs normally use the USB_ISO_ASAP transfer flag, telling
667  * the host controller to schedule the transfer as soon as bandwidth
668  * utilization allows, and then set start_frame to reflect the actual frame
669  * selected during submission.  Otherwise drivers must specify the start_frame
670  * and handle the case where the transfer can't begin then.  However, drivers
671  * won't know how bandwidth is currently allocated, and while they can
672  * find the current frame using usb_get_current_frame_number () they can't
673  * know the range for that frame number.  (Common ranges for the frame
674  * counter include 256, 512, and 1024 frames.)
675  *
676  * Isochronous URBs have a different data transfer model, in part because
677  * the quality of service is only "best effort".  Callers provide specially
678  * allocated URBs, with number_of_packets worth of iso_frame_desc structures
679  * at the end.  Each such packet is an individual ISO transfer.  Isochronous
680  * URBs are normally submitted with urb->next fields set up as a ring, so
681  * that data (such as audio or video) streams at as constant a rate as the
682  * host controller scheduler can support.
683  *
684  * Completion Callbacks:
685  *
686  * The completion callback is made in_interrupt(), and one of the first
687  * things that a completion handler should do is check the status field.
688  * The status field is provided for all URBs.  It is used to report
689  * unlinked URBs, and status for all non-ISO transfers.  It should not
690  * be examined outside of the completion handler.
691  *
692  * The context field is normally used to link URBs back to the relevant
693  * driver or request state.
694  *
695  * When completion callback is invoked for non-isochronous URBs, the
696  * actual_length field tells how many bytes were transferred.
697  *
698  * For interrupt and isochronous URBs, the URB provided to the callback
699  * function is still "owned" by the USB core subsystem unless the status
700  * indicates that the URB has been unlinked.  Completion handlers should
701  * not modify such URBs until they have been unlinked.
702  *
703  * ISO transfer status is reported in the status and actual_length fields
704  * of the iso_frame_desc array, and the number of errors is reported in
705  * error_count.
706  */
707 struct urb
708 {
709         spinlock_t lock;                /* lock for the URB */
710         void *hcpriv;                   /* private data for host controller */
711         struct list_head urb_list;      /* list pointer to all active urbs */
712         struct urb *next;               /* (in) pointer to next URB */
713         struct usb_device *dev;         /* (in) pointer to associated device */
714         unsigned int pipe;              /* (in) pipe information */
715         int status;                     /* (return) non-ISO status */
716         unsigned int transfer_flags;    /* (in) USB_DISABLE_SPD | ...*/
717         void *transfer_buffer;          /* (in) associated data buffer */
718         int transfer_buffer_length;     /* (in) data buffer length */
719         int actual_length;              /* (return) actual transfer length */
720         int bandwidth;                  /* bandwidth for INT/ISO request */
721         unsigned char *setup_packet;    /* (in) setup packet (control only) */
722         int start_frame;                /* (modify) start frame (INT/ISO) */
723         int number_of_packets;          /* (in) number of ISO packets */
724         int interval;                   /* (in) polling interval (INT only) */
725         int error_count;                /* (return) number of ISO errors */
726         int timeout;                    /* (in) timeout, in jiffies */
727         void *context;                  /* (in) context for completion */
728         usb_complete_t complete;        /* (in) completion routine */
729         iso_packet_descriptor_t iso_frame_desc[0];      /* (in) ISO ONLY */
730 };
731
732 typedef struct urb urb_t, *purb_t;
733
734 /**
735  * FILL_CONTROL_URB - macro to help initialize a control urb
736  * @URB: pointer to the urb to initialize.
737  * @DEV: pointer to the struct usb_device for this urb.
738  * @PIPE: the endpoint pipe
739  * @SETUP_PACKET: pointer to the setup_packet buffer
740  * @TRANSFER_BUFFER: pointer to the transfer buffer
741  * @BUFFER_LENGTH: length of the transfer buffer
742  * @COMPLETE: pointer to the usb_complete_t function
743  * @CONTEXT: what to set the urb context to.
744  *
745  * Initializes a control urb with the proper information needed to submit
746  * it to a device.  This macro is depreciated, the usb_fill_control_urb()
747  * function should be used instead.
748  */
749 #define FILL_CONTROL_URB(URB,DEV,PIPE,SETUP_PACKET,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT) \
750     do {\
751         spin_lock_init(&(URB)->lock);\
752         (URB)->dev=DEV;\
753         (URB)->pipe=PIPE;\
754         (URB)->setup_packet=SETUP_PACKET;\
755         (URB)->transfer_buffer=TRANSFER_BUFFER;\
756         (URB)->transfer_buffer_length=BUFFER_LENGTH;\
757         (URB)->complete=COMPLETE;\
758         (URB)->context=CONTEXT;\
759     } while (0)
760
761 /**
762  * FILL_BULK_URB - macro to help initialize a bulk urb
763  * @URB: pointer to the urb to initialize.
764  * @DEV: pointer to the struct usb_device for this urb.
765  * @PIPE: the endpoint pipe
766  * @TRANSFER_BUFFER: pointer to the transfer buffer
767  * @BUFFER_LENGTH: length of the transfer buffer
768  * @COMPLETE: pointer to the usb_complete_t function
769  * @CONTEXT: what to set the urb context to.
770  *
771  * Initializes a bulk urb with the proper information needed to submit it
772  * to a device.  This macro is depreciated, the usb_fill_bulk_urb()
773  * function should be used instead.
774  */
775 #define FILL_BULK_URB(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT) \
776     do {\
777         spin_lock_init(&(URB)->lock);\
778         (URB)->dev=DEV;\
779         (URB)->pipe=PIPE;\
780         (URB)->transfer_buffer=TRANSFER_BUFFER;\
781         (URB)->transfer_buffer_length=BUFFER_LENGTH;\
782         (URB)->complete=COMPLETE;\
783         (URB)->context=CONTEXT;\
784     } while (0)
785     
786 /**
787  * FILL_INT_URB - macro to help initialize a interrupt urb
788  * @URB: pointer to the urb to initialize.
789  * @DEV: pointer to the struct usb_device for this urb.
790  * @PIPE: the endpoint pipe
791  * @TRANSFER_BUFFER: pointer to the transfer buffer
792  * @BUFFER_LENGTH: length of the transfer buffer
793  * @COMPLETE: pointer to the usb_complete_t function
794  * @CONTEXT: what to set the urb context to.
795  * @INTERVAL: what to set the urb interval to.
796  *
797  * Initializes a interrupt urb with the proper information needed to submit
798  * it to a device.  This macro is depreciated, the usb_fill_int_urb()
799  * function should be used instead.
800  */
801 #define FILL_INT_URB(URB,DEV,PIPE,TRANSFER_BUFFER,BUFFER_LENGTH,COMPLETE,CONTEXT,INTERVAL) \
802     do {\
803         spin_lock_init(&(URB)->lock);\
804         (URB)->dev=DEV;\
805         (URB)->pipe=PIPE;\
806         (URB)->transfer_buffer=TRANSFER_BUFFER;\
807         (URB)->transfer_buffer_length=BUFFER_LENGTH;\
808         (URB)->complete=COMPLETE;\
809         (URB)->context=CONTEXT;\
810         (URB)->interval=INTERVAL;\
811         (URB)->start_frame=-1;\
812     } while (0)
813
814 /**
815  * usb_fill_control_urb - initializes a control urb
816  * @urb: pointer to the urb to initialize.
817  * @dev: pointer to the struct usb_device for this urb.
818  * @pipe: the endpoint pipe
819  * @setup_packet: pointer to the setup_packet buffer
820  * @transfer_buffer: pointer to the transfer buffer
821  * @buffer_length: length of the transfer buffer
822  * @complete: pointer to the usb_complete_t function
823  * @context: what to set the urb context to.
824  *
825  * Initializes a control urb with the proper information needed to submit
826  * it to a device.
827  */
828 static inline void usb_fill_control_urb (struct urb *urb,
829                                          struct usb_device *dev,
830                                          unsigned int pipe,
831                                          unsigned char *setup_packet,
832                                          void *transfer_buffer,
833                                          int buffer_length,
834                                          usb_complete_t complete,
835                                          void *context)
836 {
837         spin_lock_init(&urb->lock);
838         urb->dev = dev;
839         urb->pipe = pipe;
840         urb->setup_packet = setup_packet;
841         urb->transfer_buffer = transfer_buffer;
842         urb->transfer_buffer_length = buffer_length;
843         urb->complete = complete;
844         urb->context = context;
845 }
846
847 /**
848  * usb_fill_bulk_urb - macro to help initialize a bulk urb
849  * @urb: pointer to the urb to initialize.
850  * @dev: pointer to the struct usb_device for this urb.
851  * @pipe: the endpoint pipe
852  * @transfer_buffer: pointer to the transfer buffer
853  * @buffer_length: length of the transfer buffer
854  * @complete: pointer to the usb_complete_t function
855  * @context: what to set the urb context to.
856  *
857  * Initializes a bulk urb with the proper information needed to submit it
858  * to a device.
859  */
860 static inline void usb_fill_bulk_urb (struct urb *urb,
861                                       struct usb_device *dev,
862                                       unsigned int pipe,
863                                       void *transfer_buffer,
864                                       int buffer_length,
865                                       usb_complete_t complete,
866                                       void *context)
867                                       
868 {
869         spin_lock_init(&urb->lock);
870         urb->dev = dev;
871         urb->pipe = pipe;
872         urb->transfer_buffer = transfer_buffer;
873         urb->transfer_buffer_length = buffer_length;
874         urb->complete = complete;
875         urb->context = context;
876 }
877     
878 /**
879  * usb_fill_int_urb - macro to help initialize a interrupt urb
880  * @urb: pointer to the urb to initialize.
881  * @dev: pointer to the struct usb_device for this urb.
882  * @pipe: the endpoint pipe
883  * @transfer_buffer: pointer to the transfer buffer
884  * @buffer_length: length of the transfer buffer
885  * @complete: pointer to the usb_complete_t function
886  * @context: what to set the urb context to.
887  * @interval: what to set the urb interval to.
888  *
889  * Initializes a interrupt urb with the proper information needed to submit
890  * it to a device.
891  */
892 static inline void usb_fill_int_urb (struct urb *urb,
893                                      struct usb_device *dev,
894                                      unsigned int pipe,
895                                      void *transfer_buffer,
896                                      int buffer_length,
897                                      usb_complete_t complete,
898                                      void *context,
899                                      int interval)
900 {
901         spin_lock_init(&urb->lock);
902         urb->dev = dev;
903         urb->pipe = pipe;
904         urb->transfer_buffer = transfer_buffer;
905         urb->transfer_buffer_length = buffer_length;
906         urb->complete = complete;
907         urb->context = context;
908         urb->interval = interval;
909         urb->start_frame = -1;
910 }
911     
912 extern struct urb *usb_alloc_urb(int iso_packets);
913 extern void usb_free_urb(struct urb *purb);
914 extern int usb_submit_urb(struct urb *purb);
915 extern int usb_unlink_urb(struct urb *purb);
916
917 /*-------------------------------------------------------------------*
918  *                         SYNCHRONOUS CALL SUPPORT                  *
919  *-------------------------------------------------------------------*/
920
921 extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,
922         __u8 request, __u8 requesttype, __u16 value, __u16 index,
923         void *data, __u16 size, int timeout);
924 extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
925         void *data, int len, int *actual_length,
926         int timeout);
927
928 /* wrappers around usb_control_msg() for the most common standard requests */
929 extern int usb_clear_halt(struct usb_device *dev, int pipe);
930 extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
931         unsigned char descindex, void *buf, int size);
932 extern int usb_get_device_descriptor(struct usb_device *dev);
933 extern int usb_get_status(struct usb_device *dev,
934         int type, int target, void *data);
935 extern int usb_get_string(struct usb_device *dev,
936         unsigned short langid, unsigned char index, void *buf, int size);
937 extern int usb_string(struct usb_device *dev, int index,
938         char *buf, size_t size);
939 extern int usb_set_configuration(struct usb_device *dev, int configuration);
940 extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
941
942 /*
943  * timeouts, in seconds, used for sending/receiving control messages
944  * they typically complete within a few frames (msec) after they're issued
945  */
946 #ifdef CONFIG_USB_LONG_TIMEOUT
947 #define USB_CTRL_GET_TIMEOUT 4
948 #else
949 #define USB_CTRL_GET_TIMEOUT 3
950 #endif
951
952 #define USB_CTRL_SET_TIMEOUT 3
953
954 /* -------------------------------------------------------------------------- */
955
956 /* Host Controller Driver (HCD) support */
957
958 struct usb_operations {
959         int (*allocate)(struct usb_device *);
960         int (*deallocate)(struct usb_device *);
961         int (*get_frame_number) (struct usb_device *usb_dev);
962         int (*submit_urb) (struct urb* purb);
963         int (*unlink_urb) (struct urb* purb);
964 };
965
966 #define DEVNUM_ROUND_ROBIN      /***** OPTION *****/
967
968 /*
969  * Allocated per bus we have
970  */
971 struct usb_bus {
972         int busnum;                     /* Bus number (in order of reg) */
973
974 #ifdef DEVNUM_ROUND_ROBIN
975         int devnum_next;                /* Next open device number in round-robin allocation */
976 #endif /* DEVNUM_ROUND_ROBIN */
977
978         struct usb_devmap devmap;       /* Device map */
979         struct usb_operations *op;      /* Operations (specific to the HC) */
980         struct usb_device *root_hub;    /* Root hub */
981         struct list_head bus_list;
982         void *hcpriv;                   /* Host Controller private data */
983
984         int bandwidth_allocated;        /* on this Host Controller; */
985                                           /* applies to Int. and Isoc. pipes; */
986                                           /* measured in microseconds/frame; */
987                                           /* range is 0..900, where 900 = */
988                                           /* 90% of a 1-millisecond frame */
989         int bandwidth_int_reqs;         /* number of Interrupt requesters */
990         int bandwidth_isoc_reqs;        /* number of Isoc. requesters */
991
992         /* usbdevfs inode list */
993         struct list_head inodes;
994
995         atomic_t refcnt;
996 };
997
998 extern struct usb_bus *usb_alloc_bus(struct usb_operations *);
999 extern void usb_free_bus(struct usb_bus *);
1000 extern void usb_register_bus(struct usb_bus *);
1001 extern void usb_deregister_bus(struct usb_bus *);
1002
1003 extern int usb_check_bandwidth (struct usb_device *dev, struct urb *urb);
1004 extern void usb_claim_bandwidth (struct usb_device *dev, struct urb *urb,
1005                 int bustime, int isoc);
1006 extern void usb_release_bandwidth(struct usb_device *dev, struct urb *urb,
1007                 int isoc);
1008 extern int usb_root_hub_string(int id, int serial,
1009                 char *type, __u8 *data, int len);
1010
1011 /*
1012  * Some USB 1.1 bandwidth allocation constants.
1013  */
1014 #define BW_HOST_DELAY   1000L           /* nanoseconds */
1015 #define BW_HUB_LS_SETUP 333L            /* nanoseconds */
1016                         /* 4 full-speed bit times (est.) */
1017
1018 #define FRAME_TIME_BITS         12000L          /* frame = 1 millisecond */
1019 #define FRAME_TIME_MAX_BITS_ALLOC       (90L * FRAME_TIME_BITS / 100L)
1020 #define FRAME_TIME_USECS        1000L
1021 #define FRAME_TIME_MAX_USECS_ALLOC      (90L * FRAME_TIME_USECS / 100L)
1022
1023 #define BitTime(bytecount)  (7 * 8 * bytecount / 6)  /* with integer truncation */
1024                 /* Trying not to use worst-case bit-stuffing
1025                    of (7/6 * 8 * bytecount) = 9.33 * bytecount */
1026                 /* bytecount = data payload byte count */
1027
1028 #define NS_TO_US(ns)    ((ns + 500L) / 1000L)
1029                         /* convert & round nanoseconds to microseconds */
1030
1031
1032 /* -------------------------------------------------------------------------- */
1033
1034 /* Enumeration is only for the hub driver, or HCD virtual root hubs */
1035 extern struct usb_device *usb_alloc_dev(struct usb_device *parent,
1036         struct usb_bus *);
1037 extern void usb_free_dev(struct usb_device *);
1038 extern int usb_new_device(struct usb_device *dev);
1039 extern void usb_connect(struct usb_device *dev);
1040 extern void usb_disconnect(struct usb_device **);
1041
1042 #ifndef _LINUX_HUB_H
1043 /* exported to hub driver ONLY to support usb_reset_device () */
1044 extern int usb_get_configuration(struct usb_device *dev);
1045 extern void usb_set_maxpacket(struct usb_device *dev);
1046 extern void usb_destroy_configuration(struct usb_device *dev);
1047 extern int usb_set_address(struct usb_device *dev);
1048 #endif /* _LINUX_HUB_H */
1049
1050 /* -------------------------------------------------------------------------- */
1051
1052 /* This is arbitrary.
1053  * From USB 2.0 spec Table 11-13, offset 7, a hub can
1054  * have up to 255 ports. The most yet reported is 10.
1055  */
1056 #define USB_MAXCHILDREN         (16)
1057
1058 struct usb_device {
1059         int devnum;                     /* Device number on USB bus */
1060
1061         enum {
1062                 USB_SPEED_UNKNOWN = 0,                  /* enumerating */
1063                 USB_SPEED_LOW, USB_SPEED_FULL,          /* usb 1.1 */
1064                 USB_SPEED_HIGH                          /* usb 2.0 */
1065         } speed;
1066
1067         struct usb_device *tt;          /* usb1.1 device on usb2.0 bus */
1068         int ttport;                     /* device/hub port on that tt */
1069
1070         atomic_t refcnt;                /* Reference count */
1071         struct semaphore serialize;
1072
1073         unsigned int toggle[2];         /* one bit for each endpoint ([0] = IN, [1] = OUT) */
1074         unsigned int halted[2];         /* endpoint halts; one bit per endpoint # & direction; */
1075                                         /* [0] = IN, [1] = OUT */
1076         int epmaxpacketin[16];          /* INput endpoint specific maximums */
1077         int epmaxpacketout[16];         /* OUTput endpoint specific maximums */
1078
1079         struct usb_device *parent;
1080         struct usb_bus *bus;            /* Bus we're part of */
1081
1082         struct usb_device_descriptor descriptor;/* Descriptor */
1083         struct usb_config_descriptor *config;   /* All of the configs */
1084         struct usb_config_descriptor *actconfig;/* the active configuration */
1085
1086         char **rawdescriptors;          /* Raw descriptors for each config */
1087
1088         int have_langid;                /* whether string_langid is valid yet */
1089         int string_langid;              /* language ID for strings */
1090   
1091         void *hcpriv;                   /* Host Controller private data */
1092         
1093         /* usbdevfs inode list */
1094         struct list_head inodes;
1095         struct list_head filelist;
1096
1097         /*
1098          * Child devices - these can be either new devices
1099          * (if this is a hub device), or different instances
1100          * of this same device.
1101          *
1102          * Each instance needs its own set of data structures.
1103          */
1104
1105         int maxchild;                   /* Number of ports if hub */
1106         struct usb_device *children[USB_MAXCHILDREN];
1107 };
1108
1109 /* for when layers above USB add new non-USB drivers */
1110 extern void usb_scan_devices(void);
1111
1112 /* mostly for devices emulating SCSI over USB */
1113 extern int usb_reset_device(struct usb_device *dev);
1114
1115 /* for drivers using iso endpoints */
1116 extern int usb_get_current_frame_number (struct usb_device *usb_dev);
1117
1118 /* drivers must track when they bind to a device's interfaces */
1119 extern void usb_inc_dev_use(struct usb_device *);
1120 #define usb_dec_dev_use usb_free_dev
1121
1122 /* used these for multi-interface device registration */
1123 extern void usb_driver_claim_interface(struct usb_driver *driver,
1124                         struct usb_interface *iface, void* priv);
1125 extern int usb_interface_claimed(struct usb_interface *iface);
1126 extern void usb_driver_release_interface(struct usb_driver *driver,
1127                         struct usb_interface *iface);
1128 const struct usb_device_id *usb_match_id(struct usb_device *dev,
1129                                          struct usb_interface *interface,
1130                                          const struct usb_device_id *id);
1131
1132 /* -------------------------------------------------------------------------- */
1133
1134 /*
1135  * Calling this entity a "pipe" is glorifying it. A USB pipe
1136  * is something embarrassingly simple: it basically consists
1137  * of the following information:
1138  *  - device number (7 bits)
1139  *  - endpoint number (4 bits)
1140  *  - current Data0/1 state (1 bit) [Historical; now gone]
1141  *  - direction (1 bit)
1142  *  - speed (1 bit)
1143  *  - max packet size (2 bits: 8, 16, 32 or 64) [Historical; now gone.]
1144  *  - pipe type (2 bits: control, interrupt, bulk, isochronous)
1145  *
1146  * That's 18 bits. Really. Nothing more. And the USB people have
1147  * documented these eighteen bits as some kind of glorious
1148  * virtual data structure.
1149  *
1150  * Let's not fall in that trap. We'll just encode it as a simple
1151  * unsigned int. The encoding is:
1152  *
1153  *  - max size:         bits 0-1        (00 = 8, 01 = 16, 10 = 32, 11 = 64) [Historical; now gone.]
1154  *  - direction:        bit 7           (0 = Host-to-Device [Out], 1 = Device-to-Host [In])
1155  *  - device:           bits 8-14
1156  *  - endpoint:         bits 15-18
1157  *  - Data0/1:          bit 19          [Historical; now gone. ]
1158  *  - speed:            bit 26          (0 = Full, 1 = Low Speed)
1159  *  - pipe type:        bits 30-31      (00 = isochronous, 01 = interrupt, 10 = control, 11 = bulk)
1160  *
1161  * Why? Because it's arbitrary, and whatever encoding we select is really
1162  * up to us. This one happens to share a lot of bit positions with the UHCI
1163  * specification, so that much of the uhci driver can just mask the bits
1164  * appropriately.
1165  *
1166  * NOTE:  there's no encoding (yet?) for a "high speed" endpoint; treat them
1167  * like full speed devices.
1168  */
1169
1170 // FIXME 2.5 get rid of usb_pipeslow(), just use dev->speed
1171
1172 #define PIPE_ISOCHRONOUS                0
1173 #define PIPE_INTERRUPT                  1
1174 #define PIPE_CONTROL                    2
1175 #define PIPE_BULK                       3
1176
1177 #define usb_maxpacket(dev, pipe, out)   (out \
1178                                 ? (dev)->epmaxpacketout[usb_pipeendpoint(pipe)] \
1179                                 : (dev)->epmaxpacketin [usb_pipeendpoint(pipe)] )
1180 #define usb_packetid(pipe)      (((pipe) & USB_DIR_IN) ? USB_PID_IN : USB_PID_OUT)
1181
1182 #define usb_pipeout(pipe)       ((((pipe) >> 7) & 1) ^ 1)
1183 #define usb_pipein(pipe)        (((pipe) >> 7) & 1)
1184 #define usb_pipedevice(pipe)    (((pipe) >> 8) & 0x7f)
1185 #define usb_pipe_endpdev(pipe)  (((pipe) >> 8) & 0x7ff)
1186 #define usb_pipeendpoint(pipe)  (((pipe) >> 15) & 0xf)
1187 #define usb_pipeslow(pipe)      (((pipe) >> 26) & 1)
1188 #define usb_pipetype(pipe)      (((pipe) >> 30) & 3)
1189 #define usb_pipeisoc(pipe)      (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
1190 #define usb_pipeint(pipe)       (usb_pipetype((pipe)) == PIPE_INTERRUPT)
1191 #define usb_pipecontrol(pipe)   (usb_pipetype((pipe)) == PIPE_CONTROL)
1192 #define usb_pipebulk(pipe)      (usb_pipetype((pipe)) == PIPE_BULK)
1193
1194 #define PIPE_DEVEP_MASK         0x0007ff00
1195
1196 /* The D0/D1 toggle bits */
1197 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1)
1198 #define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << ep))
1199 #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << ep)) | ((bit) << ep))
1200
1201 /* Endpoint halt control/status */
1202 #define usb_endpoint_out(ep_dir)        (((ep_dir >> 7) & 1) ^ 1)
1203 #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep)))
1204 #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep)))
1205 #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep)))
1206
1207 static inline unsigned int __create_pipe(struct usb_device *dev, unsigned int endpoint)
1208 {
1209         return (dev->devnum << 8) | (endpoint << 15) |
1210                 ((dev->speed == USB_SPEED_LOW) << 26);
1211 }
1212
1213 static inline unsigned int __default_pipe(struct usb_device *dev)
1214 {
1215         return ((dev->speed == USB_SPEED_LOW) << 26);
1216 }
1217
1218 /* Create various pipes... */
1219 #define usb_sndctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
1220 #define usb_rcvctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
1221 #define usb_sndisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
1222 #define usb_rcvisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
1223 #define usb_sndbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
1224 #define usb_rcvbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
1225 #define usb_sndintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
1226 #define usb_rcvintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
1227 #define usb_snddefctrl(dev)             ((PIPE_CONTROL << 30) | __default_pipe(dev))
1228 #define usb_rcvdefctrl(dev)             ((PIPE_CONTROL << 30) | __default_pipe(dev) | USB_DIR_IN)
1229
1230 /* -------------------------------------------------------------------------- */
1231
1232 /*
1233  * Debugging and troubleshooting/diagnostic helpers.
1234  */
1235 void usb_show_device_descriptor(struct usb_device_descriptor *);
1236 void usb_show_config_descriptor(struct usb_config_descriptor *);
1237 void usb_show_interface_descriptor(struct usb_interface_descriptor *);
1238 void usb_show_endpoint_descriptor(struct usb_endpoint_descriptor *);
1239 void usb_show_device(struct usb_device *);
1240 void usb_show_string(struct usb_device *dev, char *id, int index);
1241
1242 #ifdef DEBUG
1243 #define dbg(format, arg...) printk(KERN_DEBUG __FILE__ ": " format "\n" , ## arg)
1244 #else
1245 #define dbg(format, arg...) do {} while (0)
1246 #endif
1247
1248 #define err(format, arg...) printk(KERN_ERR __FILE__ ": " format "\n" , ## arg)
1249 #define info(format, arg...) printk(KERN_INFO __FILE__ ": " format "\n" , ## arg)
1250 #define warn(format, arg...) printk(KERN_WARNING __FILE__ ": " format "\n" , ## arg)
1251
1252
1253 /* -------------------------------------------------------------------------- */
1254
1255 /*
1256  * bus and driver list
1257  * exported only for usbdevfs (not visible outside usbcore)
1258  */
1259
1260 extern struct list_head usb_driver_list;
1261 extern struct list_head usb_bus_list;
1262 extern struct semaphore usb_bus_list_lock;
1263
1264 /*
1265  * USB device fs stuff
1266  */
1267
1268 #ifdef CONFIG_USB_DEVICEFS
1269
1270 /*
1271  * these are expected to be called from the USB core/hub thread
1272  * with the kernel lock held
1273  */
1274 extern void usbdevfs_add_bus(struct usb_bus *bus);
1275 extern void usbdevfs_remove_bus(struct usb_bus *bus);
1276 extern void usbdevfs_add_device(struct usb_device *dev);
1277 extern void usbdevfs_remove_device(struct usb_device *dev);
1278
1279 extern int usbdevfs_init(void);
1280 extern void usbdevfs_cleanup(void);
1281
1282 #else /* CONFIG_USB_DEVICEFS */
1283
1284 static inline void usbdevfs_add_bus(struct usb_bus *bus) {}
1285 static inline void usbdevfs_remove_bus(struct usb_bus *bus) {}
1286 static inline void usbdevfs_add_device(struct usb_device *dev) {}
1287 static inline void usbdevfs_remove_device(struct usb_device *dev) {}
1288
1289 static inline int usbdevfs_init(void) { return 0; }
1290 static inline void usbdevfs_cleanup(void) { }
1291
1292 #endif /* CONFIG_USB_DEVICEFS */
1293
1294 #endif  /* __KERNEL__ */
1295
1296 #endif