Merge branch 'master' of git://git.denx.de/u-boot-usb
[kernel/u-boot.git] / include / usb.h
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
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
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 #include <usbdescriptors.h>
31
32 /* Everything is aribtrary */
33 #define USB_ALTSETTINGALLOC             4
34 #define USB_MAXALTSETTING               128     /* Hard limit */
35
36 #define USB_MAX_DEVICE                  32
37 #define USB_MAXCONFIG                   8
38 #define USB_MAXINTERFACES               8
39 #define USB_MAXENDPOINTS                16
40 #define USB_MAXCHILDREN                 8       /* This is arbitrary */
41 #define USB_MAX_HUB                     16
42
43 #define USB_CNTL_TIMEOUT 100 /* 100ms timeout */
44
45 /* device request (setup) */
46 struct devrequest {
47         unsigned char   requesttype;
48         unsigned char   request;
49         unsigned short  value;
50         unsigned short  index;
51         unsigned short  length;
52 } __attribute__ ((packed));
53
54 /* All standard descriptors have these 2 fields in common */
55 struct usb_descriptor_header {
56         unsigned char   bLength;
57         unsigned char   bDescriptorType;
58 } __attribute__ ((packed));
59
60 /* Interface */
61 struct usb_interface {
62         struct usb_interface_descriptor desc;
63
64         unsigned char   no_of_ep;
65         unsigned char   num_altsetting;
66         unsigned char   act_altsetting;
67
68         struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS];
69 } __attribute__ ((packed));
70
71 /* Configuration information.. */
72 struct usb_config {
73         struct usb_configuration_descriptor desc;
74
75         unsigned char   no_of_if;       /* number of interfaces */
76         struct usb_interface if_desc[USB_MAXINTERFACES];
77 } __attribute__ ((packed));
78
79 enum {
80         /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */
81         PACKET_SIZE_8   = 0,
82         PACKET_SIZE_16  = 1,
83         PACKET_SIZE_32  = 2,
84         PACKET_SIZE_64  = 3,
85 };
86
87 struct usb_device {
88         int     devnum;                 /* Device number on USB bus */
89         int     speed;                  /* full/low/high */
90         char    mf[32];                 /* manufacturer */
91         char    prod[32];               /* product */
92         char    serial[32];             /* serial number */
93
94         /* Maximum packet size; one of: PACKET_SIZE_* */
95         int maxpacketsize;
96         /* one bit for each endpoint ([0] = IN, [1] = OUT) */
97         unsigned int toggle[2];
98         /* endpoint halts; one bit per endpoint # & direction;
99          * [0] = IN, [1] = OUT
100          */
101         unsigned int halted[2];
102         int epmaxpacketin[16];          /* INput endpoint specific maximums */
103         int epmaxpacketout[16];         /* OUTput endpoint specific maximums */
104
105         int configno;                   /* selected config number */
106         struct usb_device_descriptor descriptor; /* Device Descriptor */
107         struct usb_config config; /* config descriptor */
108
109         int have_langid;                /* whether string_langid is valid yet */
110         int string_langid;              /* language ID for strings */
111         int (*irq_handle)(struct usb_device *dev);
112         unsigned long irq_status;
113         int irq_act_len;                /* transfered bytes */
114         void *privptr;
115         /*
116          * Child devices -  if this is a hub device
117          * Each instance needs its own set of data structures.
118          */
119         unsigned long status;
120         int act_len;                    /* transfered bytes */
121         int maxchild;                   /* Number of ports if hub */
122         int portnr;
123         struct usb_device *parent;
124         struct usb_device *children[USB_MAXCHILDREN];
125 };
126
127 /**********************************************************************
128  * this is how the lowlevel part communicate with the outer world
129  */
130
131 #if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \
132         defined(CONFIG_USB_EHCI) || defined(CONFIG_USB_OHCI_NEW) || \
133         defined(CONFIG_USB_SL811HS) || defined(CONFIG_USB_ISP116X_HCD) || \
134         defined(CONFIG_USB_R8A66597_HCD) || defined(CONFIG_USB_DAVINCI) || \
135         defined(CONFIG_USB_OMAP3) || defined(CONFIG_USB_DA8XX) || \
136         defined(CONFIG_USB_BLACKFIN)
137
138 int usb_lowlevel_init(void);
139 int usb_lowlevel_stop(void);
140 int submit_bulk_msg(struct usb_device *dev, unsigned long pipe,
141                         void *buffer, int transfer_len);
142 int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
143                         int transfer_len, struct devrequest *setup);
144 int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
145                         int transfer_len, int interval);
146 void usb_event_poll(void);
147
148 /* Defines */
149 #define USB_UHCI_VEND_ID        0x8086
150 #define USB_UHCI_DEV_ID         0x7112
151
152 #else
153 #error USB Lowlevel not defined
154 #endif
155
156 #ifdef CONFIG_USB_STORAGE
157
158 #define USB_MAX_STOR_DEV 5
159 block_dev_desc_t *usb_stor_get_dev(int index);
160 int usb_stor_scan(int mode);
161 int usb_stor_info(void);
162
163 #endif
164
165 #ifdef CONFIG_USB_KEYBOARD
166
167 int drv_usb_kbd_init(void);
168 int usb_kbd_deregister(void);
169
170 #endif
171 /* routines */
172 int usb_init(void); /* initialize the USB Controller */
173 int usb_stop(void); /* stop the USB Controller */
174
175
176 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol);
177 int usb_set_idle(struct usb_device *dev, int ifnum, int duration,
178                         int report_id);
179 struct usb_device *usb_get_dev_index(int index);
180 int usb_control_msg(struct usb_device *dev, unsigned int pipe,
181                         unsigned char request, unsigned char requesttype,
182                         unsigned short value, unsigned short index,
183                         void *data, unsigned short size, int timeout);
184 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
185                         void *data, int len, int *actual_length, int timeout);
186 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
187                         void *buffer, int transfer_len, int interval);
188 void usb_disable_asynch(int disable);
189 int usb_maxpacket(struct usb_device *dev, unsigned long pipe);
190 inline void wait_ms(unsigned long ms);
191 int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer,
192                                 int cfgno);
193 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
194                         unsigned char id, void *buf, int size);
195 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
196                         unsigned char type, unsigned char id, void *buf,
197                         int size);
198 int usb_clear_halt(struct usb_device *dev, int pipe);
199 int usb_string(struct usb_device *dev, int index, char *buf, size_t size);
200 int usb_set_interface(struct usb_device *dev, int interface, int alternate);
201
202 /* big endian -> little endian conversion */
203 /* some CPUs are already little endian e.g. the ARM920T */
204 #define __swap_16(x) \
205         ({ unsigned short x_ = (unsigned short)x; \
206          (unsigned short)( \
207                 ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \
208         })
209 #define __swap_32(x) \
210         ({ unsigned long x_ = (unsigned long)x; \
211          (unsigned long)( \
212                 ((x_ & 0x000000FFUL) << 24) | \
213                 ((x_ & 0x0000FF00UL) <<  8) | \
214                 ((x_ & 0x00FF0000UL) >>  8) | \
215                 ((x_ & 0xFF000000UL) >> 24)); \
216         })
217
218 #ifdef __LITTLE_ENDIAN
219 # define swap_16(x) (x)
220 # define swap_32(x) (x)
221 #else
222 # define swap_16(x) __swap_16(x)
223 # define swap_32(x) __swap_32(x)
224 #endif
225
226 /*
227  * Calling this entity a "pipe" is glorifying it. A USB pipe
228  * is something embarrassingly simple: it basically consists
229  * of the following information:
230  *  - device number (7 bits)
231  *  - endpoint number (4 bits)
232  *  - current Data0/1 state (1 bit)
233  *  - direction (1 bit)
234  *  - speed (2 bits)
235  *  - max packet size (2 bits: 8, 16, 32 or 64)
236  *  - pipe type (2 bits: control, interrupt, bulk, isochronous)
237  *
238  * That's 18 bits. Really. Nothing more. And the USB people have
239  * documented these eighteen bits as some kind of glorious
240  * virtual data structure.
241  *
242  * Let's not fall in that trap. We'll just encode it as a simple
243  * unsigned int. The encoding is:
244  *
245  *  - max size:         bits 0-1        (00 = 8, 01 = 16, 10 = 32, 11 = 64)
246  *  - direction:        bit 7           (0 = Host-to-Device [Out],
247  *                                      (1 = Device-to-Host [In])
248  *  - device:           bits 8-14
249  *  - endpoint:         bits 15-18
250  *  - Data0/1:          bit 19
251  *  - speed:            bit 26          (0 = Full, 1 = Low Speed, 2 = High)
252  *  - pipe type:        bits 30-31      (00 = isochronous, 01 = interrupt,
253  *                                       10 = control, 11 = bulk)
254  *
255  * Why? Because it's arbitrary, and whatever encoding we select is really
256  * up to us. This one happens to share a lot of bit positions with the UHCI
257  * specification, so that much of the uhci driver can just mask the bits
258  * appropriately.
259  */
260 /* Create various pipes... */
261 #define create_pipe(dev,endpoint) \
262                 (((dev)->devnum << 8) | (endpoint << 15) | \
263                 ((dev)->speed << 26) | (dev)->maxpacketsize)
264 #define default_pipe(dev) ((dev)->speed << 26)
265
266 #define usb_sndctrlpipe(dev, endpoint)  ((PIPE_CONTROL << 30) | \
267                                          create_pipe(dev, endpoint))
268 #define usb_rcvctrlpipe(dev, endpoint)  ((PIPE_CONTROL << 30) | \
269                                          create_pipe(dev, endpoint) | \
270                                          USB_DIR_IN)
271 #define usb_sndisocpipe(dev, endpoint)  ((PIPE_ISOCHRONOUS << 30) | \
272                                          create_pipe(dev, endpoint))
273 #define usb_rcvisocpipe(dev, endpoint)  ((PIPE_ISOCHRONOUS << 30) | \
274                                          create_pipe(dev, endpoint) | \
275                                          USB_DIR_IN)
276 #define usb_sndbulkpipe(dev, endpoint)  ((PIPE_BULK << 30) | \
277                                          create_pipe(dev, endpoint))
278 #define usb_rcvbulkpipe(dev, endpoint)  ((PIPE_BULK << 30) | \
279                                          create_pipe(dev, endpoint) | \
280                                          USB_DIR_IN)
281 #define usb_sndintpipe(dev, endpoint)   ((PIPE_INTERRUPT << 30) | \
282                                          create_pipe(dev, endpoint))
283 #define usb_rcvintpipe(dev, endpoint)   ((PIPE_INTERRUPT << 30) | \
284                                          create_pipe(dev, endpoint) | \
285                                          USB_DIR_IN)
286 #define usb_snddefctrl(dev)             ((PIPE_CONTROL << 30) | \
287                                          default_pipe(dev))
288 #define usb_rcvdefctrl(dev)             ((PIPE_CONTROL << 30) | \
289                                          default_pipe(dev) | \
290                                          USB_DIR_IN)
291
292 /* The D0/D1 toggle bits */
293 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1)
294 #define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << ep))
295 #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \
296                                                 ((dev)->toggle[out] & \
297                                                  ~(1 << ep)) | ((bit) << ep))
298
299 /* Endpoint halt control/status */
300 #define usb_endpoint_out(ep_dir)        (((ep_dir >> 7) & 1) ^ 1)
301 #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep)))
302 #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep)))
303 #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep)))
304
305 #define usb_packetid(pipe)      (((pipe) & USB_DIR_IN) ? USB_PID_IN : \
306                                  USB_PID_OUT)
307
308 #define usb_pipeout(pipe)       ((((pipe) >> 7) & 1) ^ 1)
309 #define usb_pipein(pipe)        (((pipe) >> 7) & 1)
310 #define usb_pipedevice(pipe)    (((pipe) >> 8) & 0x7f)
311 #define usb_pipe_endpdev(pipe)  (((pipe) >> 8) & 0x7ff)
312 #define usb_pipeendpoint(pipe)  (((pipe) >> 15) & 0xf)
313 #define usb_pipedata(pipe)      (((pipe) >> 19) & 1)
314 #define usb_pipespeed(pipe)     (((pipe) >> 26) & 3)
315 #define usb_pipeslow(pipe)      (usb_pipespeed(pipe) == USB_SPEED_LOW)
316 #define usb_pipetype(pipe)      (((pipe) >> 30) & 3)
317 #define usb_pipeisoc(pipe)      (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
318 #define usb_pipeint(pipe)       (usb_pipetype((pipe)) == PIPE_INTERRUPT)
319 #define usb_pipecontrol(pipe)   (usb_pipetype((pipe)) == PIPE_CONTROL)
320 #define usb_pipebulk(pipe)      (usb_pipetype((pipe)) == PIPE_BULK)
321
322
323 /*************************************************************************
324  * Hub Stuff
325  */
326 struct usb_port_status {
327         unsigned short wPortStatus;
328         unsigned short wPortChange;
329 } __attribute__ ((packed));
330
331 struct usb_hub_status {
332         unsigned short wHubStatus;
333         unsigned short wHubChange;
334 } __attribute__ ((packed));
335
336
337 /* Hub descriptor */
338 struct usb_hub_descriptor {
339         unsigned char  bLength;
340         unsigned char  bDescriptorType;
341         unsigned char  bNbrPorts;
342         unsigned short wHubCharacteristics;
343         unsigned char  bPwrOn2PwrGood;
344         unsigned char  bHubContrCurrent;
345         unsigned char  DeviceRemovable[(USB_MAXCHILDREN+1+7)/8];
346         unsigned char  PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8];
347         /* DeviceRemovable and PortPwrCtrlMask want to be variable-length
348            bitmaps that hold max 255 entries. (bit0 is ignored) */
349 } __attribute__ ((packed));
350
351
352 struct usb_hub_device {
353         struct usb_device *pusb_dev;
354         struct usb_hub_descriptor desc;
355 };
356
357 #endif /*_USB_H_ */