blob: 4f248513c92953a6736bf8eac9615b6e1714090a
1 | /* |
2 | * (C) Copyright 2001 |
3 | * Denis Peter, MPL AG Switzerland |
4 | * |
5 | * SPDX-License-Identifier: GPL-2.0+ |
6 | * Note: Part of this code has been derived from linux |
7 | * |
8 | */ |
9 | #ifndef _USB_H_ |
10 | #define _USB_H_ |
11 | |
12 | #include <usb_defs.h> |
13 | #include <linux/usb/ch9.h> |
14 | #include <asm/cache.h> |
15 | #include <part.h> |
16 | #include <asm/arch/timer.h> |
17 | |
18 | /* |
19 | * The EHCI spec says that we must align to at least 32 bytes. However, |
20 | * some platforms require larger alignment. |
21 | */ |
22 | #if ARCH_DMA_MINALIGN > 32 |
23 | #define USB_DMA_MINALIGN ARCH_DMA_MINALIGN |
24 | #else |
25 | #define USB_DMA_MINALIGN 32 |
26 | #endif |
27 | |
28 | /* Everything is aribtrary */ |
29 | #define USB_ALTSETTINGALLOC 4 |
30 | #define USB_MAXALTSETTING 128 /* Hard limit */ |
31 | |
32 | #define USB_MAX_DEVICE 32 |
33 | #define USB_MAXCONFIG 8 |
34 | #define USB_MAXINTERFACES 8 |
35 | #define USB_MAXENDPOINTS 16 |
36 | #define USB_MAXCHILDREN 8 /* This is arbitrary */ |
37 | #define USB_MAX_HUB 16 |
38 | |
39 | #define USB_CNTL_TIMEOUT 100 /* 100ms timeout */ |
40 | |
41 | /* |
42 | * This is the timeout to allow for submitting an urb in ms. We allow more |
43 | * time for a BULK device to react - some are slow. |
44 | */ |
45 | #define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000) |
46 | |
47 | /* device request (setup) */ |
48 | struct devrequest { |
49 | unsigned char requesttype; |
50 | unsigned char request; |
51 | unsigned short value; |
52 | unsigned short index; |
53 | unsigned short length; |
54 | } __attribute__ ((packed)); |
55 | |
56 | /* Interface */ |
57 | struct usb_interface { |
58 | struct usb_interface_descriptor desc; |
59 | |
60 | unsigned char no_of_ep; |
61 | unsigned char num_altsetting; |
62 | unsigned char act_altsetting; |
63 | |
64 | struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; |
65 | /* |
66 | * Super Speed Device will have Super Speed Endpoint |
67 | * Companion Descriptor (section 9.6.7 of usb 3.0 spec) |
68 | * Revision 1.0 June 6th 2011 |
69 | */ |
70 | struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS]; |
71 | } __attribute__ ((packed)); |
72 | |
73 | /* Configuration information.. */ |
74 | struct usb_config { |
75 | struct usb_config_descriptor desc; |
76 | |
77 | unsigned char no_of_if; /* number of interfaces */ |
78 | struct usb_interface if_desc[USB_MAXINTERFACES]; |
79 | } __attribute__ ((packed)); |
80 | |
81 | enum { |
82 | /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */ |
83 | PACKET_SIZE_8 = 0, |
84 | PACKET_SIZE_16 = 1, |
85 | PACKET_SIZE_32 = 2, |
86 | PACKET_SIZE_64 = 3, |
87 | }; |
88 | |
89 | struct usb_device { |
90 | int devnum; /* Device number on USB bus */ |
91 | int speed; /* full/low/high */ |
92 | char mf[32]; /* manufacturer */ |
93 | char prod[32]; /* product */ |
94 | char serial[32]; /* serial number */ |
95 | |
96 | /* Maximum packet size; one of: PACKET_SIZE_* */ |
97 | int maxpacketsize; |
98 | /* one bit for each endpoint ([0] = IN, [1] = OUT) */ |
99 | unsigned int toggle[2]; |
100 | /* endpoint halts; one bit per endpoint # & direction; |
101 | * [0] = IN, [1] = OUT |
102 | */ |
103 | unsigned int halted[2]; |
104 | int epmaxpacketin[16]; /* INput endpoint specific maximums */ |
105 | int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ |
106 | |
107 | int configno; /* selected config number */ |
108 | /* Device Descriptor */ |
109 | struct usb_device_descriptor descriptor |
110 | __attribute__((aligned(ARCH_DMA_MINALIGN))); |
111 | struct usb_config config; /* config descriptor */ |
112 | |
113 | int have_langid; /* whether string_langid is valid yet */ |
114 | int string_langid; /* language ID for strings */ |
115 | int (*irq_handle)(struct usb_device *dev); |
116 | unsigned long irq_status; |
117 | int irq_act_len; /* transfered bytes */ |
118 | void *privptr; |
119 | /* |
120 | * Child devices - if this is a hub device |
121 | * Each instance needs its own set of data structures. |
122 | */ |
123 | unsigned long status; |
124 | int act_len; /* transfered bytes */ |
125 | int maxchild; /* Number of ports if hub */ |
126 | int portnr; |
127 | struct usb_device *parent; |
128 | struct usb_device *children[USB_MAXCHILDREN]; |
129 | |
130 | void *controller; /* hardware controller private data */ |
131 | /* slot_id - for xHCI enabled devices */ |
132 | unsigned int slot_id; |
133 | unsigned int connect_status; |
134 | }; |
135 | |
136 | struct int_queue; |
137 | |
138 | /* |
139 | * You can initialize platform's USB host or device |
140 | * ports by passing this enum as an argument to |
141 | * board_usb_init(). |
142 | */ |
143 | enum usb_init_type { |
144 | USB_INIT_HOST, |
145 | USB_INIT_DEVICE |
146 | }; |
147 | |
148 | /********************************************************************** |
149 | * this is how the lowlevel part communicate with the outer world |
150 | */ |
151 | |
152 | #if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \ |
153 | defined(CONFIG_USB_EHCI) || defined(CONFIG_USB_OHCI_NEW) || \ |
154 | defined(CONFIG_USB_SL811HS) || defined(CONFIG_USB_ISP116X_HCD) || \ |
155 | defined(CONFIG_USB_R8A66597_HCD) || defined(CONFIG_USB_DAVINCI) || \ |
156 | defined(CONFIG_USB_OMAP3) || defined(CONFIG_USB_DA8XX) || \ |
157 | defined(CONFIG_USB_BLACKFIN) || defined(CONFIG_USB_AM35X) || \ |
158 | defined(CONFIG_USB_MUSB_DSPS) || defined(CONFIG_USB_MUSB_AM35X) || \ |
159 | defined(CONFIG_USB_MUSB_OMAP2PLUS) || defined(CONFIG_USB_XHCI) || \ |
160 | defined(CONFIG_USB_DWC2) |
161 | |
162 | //void wait_ms(unsigned long ms); |
163 | void _mdelay(unsigned long ms); |
164 | |
165 | int usb_lowlevel_init(int index, enum usb_init_type init, void **controller); |
166 | int usb_lowlevel_stop(int index); |
167 | |
168 | int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, |
169 | void *buffer, int transfer_len); |
170 | int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, |
171 | int transfer_len, struct devrequest *setup); |
172 | int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, |
173 | int transfer_len, int interval); |
174 | |
175 | #ifdef CONFIG_USB_EHCI /* Only the ehci code has pollable int support */ |
176 | struct int_queue *create_int_queue(struct usb_device *dev, unsigned long pipe, |
177 | int queuesize, int elementsize, void *buffer); |
178 | int destroy_int_queue(struct usb_device *dev, struct int_queue *queue); |
179 | void *poll_int_queue(struct usb_device *dev, struct int_queue *queue); |
180 | #endif |
181 | |
182 | /* Defines */ |
183 | #define USB_UHCI_VEND_ID 0x8086 |
184 | #define USB_UHCI_DEV_ID 0x7112 |
185 | |
186 | /* |
187 | * PXA25x can only act as USB device. There are drivers |
188 | * which works with USB CDC gadgets implementations. |
189 | * Some of them have common routines which can be used |
190 | * in boards init functions e.g. udc_disconnect() used for |
191 | * forced device disconnection from host. |
192 | */ |
193 | #elif defined(CONFIG_USB_GADGET_PXA2XX) |
194 | |
195 | extern void udc_disconnect(void); |
196 | |
197 | #endif |
198 | |
199 | /* |
200 | * board-specific hardware initialization, called by |
201 | * usb drivers and u-boot commands |
202 | * |
203 | * @param index USB controller number |
204 | * @param init initializes controller as USB host or device |
205 | */ |
206 | //int board_usb_init(int index, enum usb_init_type init); |
207 | |
208 | /* |
209 | * can be used to clean up after failed USB initialization attempt |
210 | * vide: board_usb_init() |
211 | * |
212 | * @param index USB controller number for selective cleanup |
213 | * @param init usb_init_type passed to board_usb_init() |
214 | */ |
215 | int board_usb_cleanup(int index, enum usb_init_type init); |
216 | |
217 | #ifdef CONFIG_USB_STORAGE |
218 | |
219 | #define USB_MAX_STOR_DEV 5 |
220 | block_dev_desc_t *usb_stor_get_dev(int index); |
221 | int usb_stor_scan(int mode); |
222 | int usb_stor_info(void); |
223 | |
224 | #endif |
225 | |
226 | #ifdef CONFIG_USB_HOST_ETHER |
227 | |
228 | #define USB_MAX_ETH_DEV 5 |
229 | int usb_host_eth_scan(int mode); |
230 | |
231 | #endif |
232 | |
233 | #ifdef CONFIG_USB_KEYBOARD |
234 | |
235 | int drv_usb_kbd_init(void); |
236 | int usb_kbd_deregister(int force); |
237 | |
238 | #endif |
239 | /* routines */ |
240 | int usb_init(void); /* initialize the USB Controller */ |
241 | int usb_stop(void); /* stop the USB Controller */ |
242 | |
243 | |
244 | int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol); |
245 | int usb_set_idle(struct usb_device *dev, int ifnum, int duration, |
246 | int report_id); |
247 | struct usb_device *usb_get_dev_index(int index); |
248 | int usb_control_msg(struct usb_device *dev, unsigned int pipe, |
249 | unsigned char request, unsigned char requesttype, |
250 | unsigned short value, unsigned short index, |
251 | void *data, unsigned short size, int timeout); |
252 | int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, |
253 | void *data, int len, int *actual_length, int timeout); |
254 | int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, |
255 | void *buffer, int transfer_len, int interval); |
256 | int usb_disable_asynch(int disable); |
257 | int usb_maxpacket(struct usb_device *dev, unsigned long pipe); |
258 | int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer, |
259 | int cfgno); |
260 | int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, |
261 | unsigned char id, void *buf, int size); |
262 | int usb_get_class_descriptor(struct usb_device *dev, int ifnum, |
263 | unsigned char type, unsigned char id, void *buf, |
264 | int size); |
265 | int usb_clear_halt(struct usb_device *dev, int pipe); |
266 | int usb_string(struct usb_device *dev, int index, char *buf, size_t size); |
267 | int usb_set_interface(struct usb_device *dev, int interface, int alternate); |
268 | |
269 | /* big endian -> little endian conversion */ |
270 | /* some CPUs are already little endian e.g. the ARM920T */ |
271 | #define __swap_16(x) \ |
272 | ({ unsigned short x_ = (unsigned short)x; \ |
273 | (unsigned short)( \ |
274 | ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \ |
275 | }) |
276 | #define __swap_32(x) \ |
277 | ({ unsigned long x_ = (unsigned long)x; \ |
278 | (unsigned long)( \ |
279 | ((x_ & 0x000000FFUL) << 24) | \ |
280 | ((x_ & 0x0000FF00UL) << 8) | \ |
281 | ((x_ & 0x00FF0000UL) >> 8) | \ |
282 | ((x_ & 0xFF000000UL) >> 24)); \ |
283 | }) |
284 | |
285 | #ifdef __LITTLE_ENDIAN |
286 | # define swap_16(x) (x) |
287 | # define swap_32(x) (x) |
288 | #else |
289 | # define swap_16(x) __swap_16(x) |
290 | # define swap_32(x) __swap_32(x) |
291 | #endif |
292 | |
293 | /* |
294 | * Calling this entity a "pipe" is glorifying it. A USB pipe |
295 | * is something embarrassingly simple: it basically consists |
296 | * of the following information: |
297 | * - device number (7 bits) |
298 | * - endpoint number (4 bits) |
299 | * - current Data0/1 state (1 bit) |
300 | * - direction (1 bit) |
301 | * - speed (2 bits) |
302 | * - max packet size (2 bits: 8, 16, 32 or 64) |
303 | * - pipe type (2 bits: control, interrupt, bulk, isochronous) |
304 | * |
305 | * That's 18 bits. Really. Nothing more. And the USB people have |
306 | * documented these eighteen bits as some kind of glorious |
307 | * virtual data structure. |
308 | * |
309 | * Let's not fall in that trap. We'll just encode it as a simple |
310 | * unsigned int. The encoding is: |
311 | * |
312 | * - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64) |
313 | * - direction: bit 7 (0 = Host-to-Device [Out], |
314 | * (1 = Device-to-Host [In]) |
315 | * - device: bits 8-14 |
316 | * - endpoint: bits 15-18 |
317 | * - Data0/1: bit 19 |
318 | * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt, |
319 | * 10 = control, 11 = bulk) |
320 | * |
321 | * Why? Because it's arbitrary, and whatever encoding we select is really |
322 | * up to us. This one happens to share a lot of bit positions with the UHCI |
323 | * specification, so that much of the uhci driver can just mask the bits |
324 | * appropriately. |
325 | */ |
326 | /* Create various pipes... */ |
327 | #define create_pipe(dev,endpoint) \ |
328 | (((dev)->devnum << 8) | ((endpoint) << 15) | \ |
329 | (dev)->maxpacketsize) |
330 | #define default_pipe(dev) ((dev)->speed << 26) |
331 | |
332 | #define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ |
333 | create_pipe(dev, endpoint)) |
334 | #define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ |
335 | create_pipe(dev, endpoint) | \ |
336 | USB_DIR_IN) |
337 | #define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ |
338 | create_pipe(dev, endpoint)) |
339 | #define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ |
340 | create_pipe(dev, endpoint) | \ |
341 | USB_DIR_IN) |
342 | #define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ |
343 | create_pipe(dev, endpoint)) |
344 | #define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ |
345 | create_pipe(dev, endpoint) | \ |
346 | USB_DIR_IN) |
347 | #define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ |
348 | create_pipe(dev, endpoint)) |
349 | #define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ |
350 | create_pipe(dev, endpoint) | \ |
351 | USB_DIR_IN) |
352 | #define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \ |
353 | default_pipe(dev)) |
354 | #define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \ |
355 | default_pipe(dev) | \ |
356 | USB_DIR_IN) |
357 | |
358 | /* The D0/D1 toggle bits */ |
359 | #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1) |
360 | #define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep)) |
361 | #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \ |
362 | ((dev)->toggle[out] & \ |
363 | ~(1 << ep)) | ((bit) << ep)) |
364 | |
365 | /* Endpoint halt control/status */ |
366 | #define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1) |
367 | #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep))) |
368 | #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep))) |
369 | #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep))) |
370 | |
371 | #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \ |
372 | USB_PID_OUT) |
373 | |
374 | #define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1) |
375 | #define usb_pipein(pipe) (((pipe) >> 7) & 1) |
376 | #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f) |
377 | #define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff) |
378 | #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf) |
379 | #define usb_pipedata(pipe) (((pipe) >> 19) & 1) |
380 | #define usb_pipetype(pipe) (((pipe) >> 30) & 3) |
381 | #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS) |
382 | #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT) |
383 | #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL) |
384 | #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK) |
385 | |
386 | #define usb_pipe_ep_index(pipe) \ |
387 | usb_pipecontrol(pipe) ? (usb_pipeendpoint(pipe) * 2) : \ |
388 | ((usb_pipeendpoint(pipe) * 2) - \ |
389 | (usb_pipein(pipe) ? 0 : 1)) |
390 | |
391 | /************************************************************************* |
392 | * Hub Stuff |
393 | */ |
394 | struct usb_port_status { |
395 | unsigned short wPortStatus; |
396 | unsigned short wPortChange; |
397 | } __attribute__ ((packed)); |
398 | |
399 | struct usb_hub_status { |
400 | unsigned short wHubStatus; |
401 | unsigned short wHubChange; |
402 | } __attribute__ ((packed)); |
403 | |
404 | |
405 | /* Hub descriptor */ |
406 | struct usb_hub_descriptor { |
407 | unsigned char bLength; |
408 | unsigned char bDescriptorType; |
409 | unsigned char bNbrPorts; |
410 | unsigned short wHubCharacteristics; |
411 | unsigned char bPwrOn2PwrGood; |
412 | unsigned char bHubContrCurrent; |
413 | unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8]; |
414 | unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8]; |
415 | /* DeviceRemovable and PortPwrCtrlMask want to be variable-length |
416 | bitmaps that hold max 255 entries. (bit0 is ignored) */ |
417 | } __attribute__ ((packed)); |
418 | |
419 | |
420 | struct usb_hub_device { |
421 | struct usb_device *pusb_dev; |
422 | struct usb_hub_descriptor desc; |
423 | }; |
424 | |
425 | int usb_hub_probe(struct usb_device *dev, int ifnum); |
426 | void usb_hub_reset(void); |
427 | int hub_port_reset(struct usb_device *dev, int port, |
428 | unsigned short *portstat); |
429 | |
430 | struct usb_device *usb_alloc_new_device(void *controller); |
431 | |
432 | int usb_new_device(struct usb_device *dev); |
433 | void usb_free_device(void); |
434 | int usb_alloc_device(struct usb_device *dev); |
435 | |
436 | #endif /*_USB_H_ */ |
437 |