]>
Commit | Line | Data |
---|---|---|
012771d8 WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Denis Peter, MPL AG Switzerland | |
4 | * | |
5 | * See file CREDITS for list of people who contributed to this | |
6 | * project. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License as | |
10 | * published by the Free Software Foundation; either version 2 of | |
11 | * the License, or (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
5cf91d6b | 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
012771d8 WD |
16 | * GNU General Public License for more details. |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
21 | * MA 02111-1307 USA | |
22 | * | |
23 | * Note: Part of this code has been derived from linux | |
24 | * | |
25 | */ | |
26 | #ifndef _USB_H_ | |
27 | #define _USB_H_ | |
28 | ||
29 | #include <usb_defs.h> | |
30 | ||
31 | /* Everything is aribtrary */ | |
5cf91d6b WD |
32 | #define USB_ALTSETTINGALLOC 4 |
33 | #define USB_MAXALTSETTING 128 /* Hard limit */ | |
012771d8 | 34 | |
5cf91d6b WD |
35 | #define USB_MAX_DEVICE 32 |
36 | #define USB_MAXCONFIG 8 | |
37 | #define USB_MAXINTERFACES 8 | |
38 | #define USB_MAXENDPOINTS 16 | |
39 | #define USB_MAXCHILDREN 8 /* This is arbitrary */ | |
40 | #define USB_MAX_HUB 16 | |
012771d8 WD |
41 | |
42 | #define USB_CNTL_TIMEOUT 100 /* 100ms timeout */ | |
43 | ||
012771d8 WD |
44 | /* String descriptor */ |
45 | struct usb_string_descriptor { | |
de39f8c1 MT |
46 | unsigned char bLength; |
47 | unsigned char bDescriptorType; | |
48 | unsigned short wData[1]; | |
012771d8 WD |
49 | } __attribute__ ((packed)); |
50 | ||
51 | /* device request (setup) */ | |
52 | struct devrequest { | |
de39f8c1 MT |
53 | unsigned char requesttype; |
54 | unsigned char request; | |
55 | unsigned short value; | |
56 | unsigned short index; | |
57 | unsigned short length; | |
012771d8 WD |
58 | } __attribute__ ((packed)); |
59 | ||
012771d8 WD |
60 | /* All standard descriptors have these 2 fields in common */ |
61 | struct usb_descriptor_header { | |
de39f8c1 MT |
62 | unsigned char bLength; |
63 | unsigned char bDescriptorType; | |
012771d8 WD |
64 | } __attribute__ ((packed)); |
65 | ||
66 | /* Device descriptor */ | |
67 | struct usb_device_descriptor { | |
de39f8c1 MT |
68 | unsigned char bLength; |
69 | unsigned char bDescriptorType; | |
70 | unsigned short bcdUSB; | |
71 | unsigned char bDeviceClass; | |
72 | unsigned char bDeviceSubClass; | |
73 | unsigned char bDeviceProtocol; | |
74 | unsigned char bMaxPacketSize0; | |
75 | unsigned short idVendor; | |
76 | unsigned short idProduct; | |
77 | unsigned short bcdDevice; | |
78 | unsigned char iManufacturer; | |
79 | unsigned char iProduct; | |
80 | unsigned char iSerialNumber; | |
81 | unsigned char bNumConfigurations; | |
012771d8 WD |
82 | } __attribute__ ((packed)); |
83 | ||
012771d8 WD |
84 | /* Endpoint descriptor */ |
85 | struct usb_endpoint_descriptor { | |
de39f8c1 MT |
86 | unsigned char bLength; |
87 | unsigned char bDescriptorType; | |
88 | unsigned char bEndpointAddress; | |
89 | unsigned char bmAttributes; | |
90 | unsigned short wMaxPacketSize; | |
91 | unsigned char bInterval; | |
92 | unsigned char bRefresh; | |
93 | unsigned char bSynchAddress; | |
d2776827 | 94 | } __attribute__ ((packed)) __attribute__ ((aligned(2))); |
de39f8c1 | 95 | |
012771d8 WD |
96 | /* Interface descriptor */ |
97 | struct usb_interface_descriptor { | |
de39f8c1 MT |
98 | unsigned char bLength; |
99 | unsigned char bDescriptorType; | |
100 | unsigned char bInterfaceNumber; | |
101 | unsigned char bAlternateSetting; | |
102 | unsigned char bNumEndpoints; | |
103 | unsigned char bInterfaceClass; | |
104 | unsigned char bInterfaceSubClass; | |
105 | unsigned char bInterfaceProtocol; | |
106 | unsigned char iInterface; | |
107 | ||
108 | unsigned char no_of_ep; | |
109 | unsigned char num_altsetting; | |
110 | unsigned char act_altsetting; | |
111 | ||
012771d8 WD |
112 | struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; |
113 | } __attribute__ ((packed)); | |
114 | ||
115 | ||
116 | /* Configuration descriptor information.. */ | |
117 | struct usb_config_descriptor { | |
de39f8c1 MT |
118 | unsigned char bLength; |
119 | unsigned char bDescriptorType; | |
120 | unsigned short wTotalLength; | |
121 | unsigned char bNumInterfaces; | |
122 | unsigned char bConfigurationValue; | |
123 | unsigned char iConfiguration; | |
124 | unsigned char bmAttributes; | |
125 | unsigned char MaxPower; | |
126 | ||
127 | unsigned char no_of_if; /* number of interfaces */ | |
012771d8 WD |
128 | struct usb_interface_descriptor if_desc[USB_MAXINTERFACES]; |
129 | } __attribute__ ((packed)); | |
130 | ||
48867208 RB |
131 | enum { |
132 | /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */ | |
133 | PACKET_SIZE_8 = 0, | |
134 | PACKET_SIZE_16 = 1, | |
135 | PACKET_SIZE_32 = 2, | |
136 | PACKET_SIZE_64 = 3, | |
137 | }; | |
012771d8 WD |
138 | |
139 | struct usb_device { | |
de39f8c1 | 140 | int devnum; /* Device number on USB bus */ |
3e126484 | 141 | int speed; /* full/low/high */ |
de39f8c1 MT |
142 | char mf[32]; /* manufacturer */ |
143 | char prod[32]; /* product */ | |
144 | char serial[32]; /* serial number */ | |
012771d8 | 145 | |
48867208 RB |
146 | /* Maximum packet size; one of: PACKET_SIZE_* */ |
147 | int maxpacketsize; | |
148 | /* one bit for each endpoint ([0] = IN, [1] = OUT) */ | |
149 | unsigned int toggle[2]; | |
de39f8c1 MT |
150 | /* endpoint halts; one bit per endpoint # & direction; |
151 | * [0] = IN, [1] = OUT | |
152 | */ | |
48867208 | 153 | unsigned int halted[2]; |
012771d8 WD |
154 | int epmaxpacketin[16]; /* INput endpoint specific maximums */ |
155 | int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ | |
156 | ||
157 | int configno; /* selected config number */ | |
158 | struct usb_device_descriptor descriptor; /* Device Descriptor */ | |
159 | struct usb_config_descriptor config; /* config descriptor */ | |
160 | ||
161 | int have_langid; /* whether string_langid is valid yet */ | |
162 | int string_langid; /* language ID for strings */ | |
163 | int (*irq_handle)(struct usb_device *dev); | |
164 | unsigned long irq_status; | |
5cf91d6b | 165 | int irq_act_len; /* transfered bytes */ |
012771d8 WD |
166 | void *privptr; |
167 | /* | |
168 | * Child devices - if this is a hub device | |
169 | * Each instance needs its own set of data structures. | |
170 | */ | |
171 | unsigned long status; | |
172 | int act_len; /* transfered bytes */ | |
173 | int maxchild; /* Number of ports if hub */ | |
3e126484 | 174 | int portnr; |
012771d8 WD |
175 | struct usb_device *parent; |
176 | struct usb_device *children[USB_MAXCHILDREN]; | |
177 | }; | |
178 | ||
179 | /********************************************************************** | |
180 | * this is how the lowlevel part communicate with the outer world | |
181 | */ | |
182 | ||
822af351 | 183 | #if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \ |
51ab142b | 184 | defined(CONFIG_USB_EHCI) || defined(CONFIG_USB_OHCI_NEW) || \ |
3e126484 | 185 | defined(CONFIG_USB_SL811HS) || defined(CONFIG_USB_ISP116X_HCD) || \ |
538ef967 | 186 | defined(CONFIG_USB_R8A66597_HCD) || defined(CONFIG_USB_DAVINCI) |
822af351 | 187 | |
012771d8 WD |
188 | int usb_lowlevel_init(void); |
189 | int usb_lowlevel_stop(void); | |
de39f8c1 MT |
190 | int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, |
191 | void *buffer, int transfer_len); | |
012771d8 | 192 | int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, |
de39f8c1 | 193 | int transfer_len, struct devrequest *setup); |
012771d8 WD |
194 | int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, |
195 | int transfer_len, int interval); | |
fdcfaa1b | 196 | void usb_event_poll(void); |
012771d8 WD |
197 | |
198 | /* Defines */ | |
de39f8c1 MT |
199 | #define USB_UHCI_VEND_ID 0x8086 |
200 | #define USB_UHCI_DEV_ID 0x7112 | |
012771d8 WD |
201 | |
202 | #else | |
203 | #error USB Lowlevel not defined | |
204 | #endif | |
205 | ||
206 | #ifdef CONFIG_USB_STORAGE | |
207 | ||
208 | #define USB_MAX_STOR_DEV 5 | |
209 | block_dev_desc_t *usb_stor_get_dev(int index); | |
210 | int usb_stor_scan(int mode); | |
e813eae3 | 211 | int usb_stor_info(void); |
012771d8 WD |
212 | |
213 | #endif | |
214 | ||
215 | #ifdef CONFIG_USB_KEYBOARD | |
216 | ||
217 | int drv_usb_kbd_init(void); | |
218 | int usb_kbd_deregister(void); | |
219 | ||
220 | #endif | |
221 | /* routines */ | |
222 | int usb_init(void); /* initialize the USB Controller */ | |
223 | int usb_stop(void); /* stop the USB Controller */ | |
224 | ||
225 | ||
226 | int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol); | |
de39f8c1 MT |
227 | int usb_set_idle(struct usb_device *dev, int ifnum, int duration, |
228 | int report_id); | |
229 | struct usb_device *usb_get_dev_index(int index); | |
012771d8 WD |
230 | int usb_control_msg(struct usb_device *dev, unsigned int pipe, |
231 | unsigned char request, unsigned char requesttype, | |
232 | unsigned short value, unsigned short index, | |
233 | void *data, unsigned short size, int timeout); | |
234 | int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, | |
235 | void *data, int len, int *actual_length, int timeout); | |
236 | int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, | |
de39f8c1 | 237 | void *buffer, int transfer_len, int interval); |
012771d8 | 238 | void usb_disable_asynch(int disable); |
de39f8c1 MT |
239 | int usb_maxpacket(struct usb_device *dev, unsigned long pipe); |
240 | inline void wait_ms(unsigned long ms); | |
241 | int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer, | |
242 | int cfgno); | |
243 | int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, | |
244 | unsigned char id, void *buf, int size); | |
012771d8 | 245 | int usb_get_class_descriptor(struct usb_device *dev, int ifnum, |
de39f8c1 MT |
246 | unsigned char type, unsigned char id, void *buf, |
247 | int size); | |
012771d8 WD |
248 | int usb_clear_halt(struct usb_device *dev, int pipe); |
249 | int usb_string(struct usb_device *dev, int index, char *buf, size_t size); | |
250 | int usb_set_interface(struct usb_device *dev, int interface, int alternate); | |
251 | ||
252 | /* big endian -> little endian conversion */ | |
149dded2 | 253 | /* some CPUs are already little endian e.g. the ARM920T */ |
ae3b770e | 254 | #define __swap_16(x) \ |
3f85ce27 WD |
255 | ({ unsigned short x_ = (unsigned short)x; \ |
256 | (unsigned short)( \ | |
de39f8c1 | 257 | ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \ |
3f85ce27 | 258 | }) |
ae3b770e | 259 | #define __swap_32(x) \ |
3f85ce27 WD |
260 | ({ unsigned long x_ = (unsigned long)x; \ |
261 | (unsigned long)( \ | |
262 | ((x_ & 0x000000FFUL) << 24) | \ | |
5cf91d6b WD |
263 | ((x_ & 0x0000FF00UL) << 8) | \ |
264 | ((x_ & 0x00FF0000UL) >> 8) | \ | |
de39f8c1 | 265 | ((x_ & 0xFF000000UL) >> 24)); \ |
3f85ce27 | 266 | }) |
ae3b770e | 267 | |
c7d703f3 | 268 | #ifdef __LITTLE_ENDIAN |
ae3b770e MK |
269 | # define swap_16(x) (x) |
270 | # define swap_32(x) (x) | |
271 | #else | |
272 | # define swap_16(x) __swap_16(x) | |
273 | # define swap_32(x) __swap_32(x) | |
c7d703f3 | 274 | #endif |
012771d8 WD |
275 | |
276 | /* | |
277 | * Calling this entity a "pipe" is glorifying it. A USB pipe | |
278 | * is something embarrassingly simple: it basically consists | |
279 | * of the following information: | |
280 | * - device number (7 bits) | |
281 | * - endpoint number (4 bits) | |
282 | * - current Data0/1 state (1 bit) | |
283 | * - direction (1 bit) | |
3e126484 | 284 | * - speed (2 bits) |
012771d8 WD |
285 | * - max packet size (2 bits: 8, 16, 32 or 64) |
286 | * - pipe type (2 bits: control, interrupt, bulk, isochronous) | |
287 | * | |
288 | * That's 18 bits. Really. Nothing more. And the USB people have | |
289 | * documented these eighteen bits as some kind of glorious | |
290 | * virtual data structure. | |
291 | * | |
292 | * Let's not fall in that trap. We'll just encode it as a simple | |
293 | * unsigned int. The encoding is: | |
294 | * | |
295 | * - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64) | |
de39f8c1 MT |
296 | * - direction: bit 7 (0 = Host-to-Device [Out], |
297 | * (1 = Device-to-Host [In]) | |
012771d8 WD |
298 | * - device: bits 8-14 |
299 | * - endpoint: bits 15-18 | |
300 | * - Data0/1: bit 19 | |
3e126484 | 301 | * - speed: bit 26 (0 = Full, 1 = Low Speed, 2 = High) |
de39f8c1 MT |
302 | * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt, |
303 | * 10 = control, 11 = bulk) | |
012771d8 WD |
304 | * |
305 | * Why? Because it's arbitrary, and whatever encoding we select is really | |
306 | * up to us. This one happens to share a lot of bit positions with the UHCI | |
307 | * specification, so that much of the uhci driver can just mask the bits | |
308 | * appropriately. | |
309 | */ | |
310 | /* Create various pipes... */ | |
311 | #define create_pipe(dev,endpoint) \ | |
de39f8c1 | 312 | (((dev)->devnum << 8) | (endpoint << 15) | \ |
3e126484 MT |
313 | ((dev)->speed << 26) | (dev)->maxpacketsize) |
314 | #define default_pipe(dev) ((dev)->speed << 26) | |
de39f8c1 MT |
315 | |
316 | #define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ | |
317 | create_pipe(dev, endpoint)) | |
318 | #define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ | |
319 | create_pipe(dev, endpoint) | \ | |
320 | USB_DIR_IN) | |
321 | #define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ | |
322 | create_pipe(dev, endpoint)) | |
323 | #define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ | |
324 | create_pipe(dev, endpoint) | \ | |
325 | USB_DIR_IN) | |
326 | #define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ | |
327 | create_pipe(dev, endpoint)) | |
328 | #define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ | |
329 | create_pipe(dev, endpoint) | \ | |
330 | USB_DIR_IN) | |
331 | #define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ | |
332 | create_pipe(dev, endpoint)) | |
333 | #define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ | |
334 | create_pipe(dev, endpoint) | \ | |
335 | USB_DIR_IN) | |
336 | #define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \ | |
337 | default_pipe(dev)) | |
338 | #define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \ | |
339 | default_pipe(dev) | \ | |
340 | USB_DIR_IN) | |
012771d8 WD |
341 | |
342 | /* The D0/D1 toggle bits */ | |
343 | #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1) | |
5cf91d6b | 344 | #define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep)) |
de39f8c1 MT |
345 | #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \ |
346 | ((dev)->toggle[out] & \ | |
347 | ~(1 << ep)) | ((bit) << ep)) | |
012771d8 WD |
348 | |
349 | /* Endpoint halt control/status */ | |
350 | #define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1) | |
351 | #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep))) | |
352 | #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep))) | |
353 | #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep))) | |
354 | ||
de39f8c1 MT |
355 | #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \ |
356 | USB_PID_OUT) | |
012771d8 WD |
357 | |
358 | #define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1) | |
359 | #define usb_pipein(pipe) (((pipe) >> 7) & 1) | |
360 | #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f) | |
361 | #define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff) | |
362 | #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf) | |
363 | #define usb_pipedata(pipe) (((pipe) >> 19) & 1) | |
3e126484 MT |
364 | #define usb_pipespeed(pipe) (((pipe) >> 26) & 3) |
365 | #define usb_pipeslow(pipe) (usb_pipespeed(pipe) == USB_SPEED_LOW) | |
012771d8 WD |
366 | #define usb_pipetype(pipe) (((pipe) >> 30) & 3) |
367 | #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS) | |
368 | #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT) | |
369 | #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL) | |
370 | #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK) | |
371 | ||
372 | ||
373 | /************************************************************************* | |
374 | * Hub Stuff | |
375 | */ | |
376 | struct usb_port_status { | |
377 | unsigned short wPortStatus; | |
378 | unsigned short wPortChange; | |
379 | } __attribute__ ((packed)); | |
380 | ||
381 | struct usb_hub_status { | |
382 | unsigned short wHubStatus; | |
383 | unsigned short wHubChange; | |
384 | } __attribute__ ((packed)); | |
385 | ||
386 | ||
387 | /* Hub descriptor */ | |
388 | struct usb_hub_descriptor { | |
389 | unsigned char bLength; | |
390 | unsigned char bDescriptorType; | |
391 | unsigned char bNbrPorts; | |
392 | unsigned short wHubCharacteristics; | |
393 | unsigned char bPwrOn2PwrGood; | |
394 | unsigned char bHubContrCurrent; | |
395 | unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8]; | |
396 | unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8]; | |
de39f8c1 | 397 | /* DeviceRemovable and PortPwrCtrlMask want to be variable-length |
012771d8 WD |
398 | bitmaps that hold max 255 entries. (bit0 is ignored) */ |
399 | } __attribute__ ((packed)); | |
400 | ||
401 | ||
402 | struct usb_hub_device { | |
403 | struct usb_device *pusb_dev; | |
404 | struct usb_hub_descriptor desc; | |
405 | }; | |
406 | ||
407 | #endif /*_USB_H_ */ |