]>
Commit | Line | Data |
---|---|---|
012771d8 WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Denis Peter, MPL AG Switzerland | |
4 | * | |
de31213f SG |
5 | * Adapted for U-Boot driver model |
6 | * (C) Copyright 2015 Google, Inc | |
7 | * | |
1a459660 | 8 | * SPDX-License-Identifier: GPL-2.0+ |
012771d8 WD |
9 | * Note: Part of this code has been derived from linux |
10 | * | |
11 | */ | |
12 | #ifndef _USB_H_ | |
13 | #define _USB_H_ | |
14 | ||
de31213f | 15 | #include <fdtdec.h> |
012771d8 | 16 | #include <usb_defs.h> |
c60795f4 | 17 | #include <linux/usb/ch9.h> |
a8c2ebcf MY |
18 | #include <asm/cache.h> |
19 | #include <part.h> | |
012771d8 | 20 | |
71c5de4f TR |
21 | /* |
22 | * The EHCI spec says that we must align to at least 32 bytes. However, | |
23 | * some platforms require larger alignment. | |
24 | */ | |
25 | #if ARCH_DMA_MINALIGN > 32 | |
26 | #define USB_DMA_MINALIGN ARCH_DMA_MINALIGN | |
27 | #else | |
28 | #define USB_DMA_MINALIGN 32 | |
29 | #endif | |
30 | ||
012771d8 | 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 | ||
96820a35 SG |
44 | /* |
45 | * This is the timeout to allow for submitting an urb in ms. We allow more | |
46 | * time for a BULK device to react - some are slow. | |
47 | */ | |
80b350a7 | 48 | #define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000) |
96820a35 | 49 | |
012771d8 WD |
50 | /* device request (setup) */ |
51 | struct devrequest { | |
b12242ac ST |
52 | __u8 requesttype; |
53 | __u8 request; | |
54 | __le16 value; | |
55 | __le16 index; | |
56 | __le16 length; | |
012771d8 WD |
57 | } __attribute__ ((packed)); |
58 | ||
8f8bd565 TR |
59 | /* Interface */ |
60 | struct usb_interface { | |
61 | struct usb_interface_descriptor desc; | |
de39f8c1 | 62 | |
b12242ac ST |
63 | __u8 no_of_ep; |
64 | __u8 num_altsetting; | |
65 | __u8 act_altsetting; | |
de39f8c1 | 66 | |
012771d8 | 67 | struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; |
6497c667 VG |
68 | /* |
69 | * Super Speed Device will have Super Speed Endpoint | |
70 | * Companion Descriptor (section 9.6.7 of usb 3.0 spec) | |
71 | * Revision 1.0 June 6th 2011 | |
72 | */ | |
73 | struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS]; | |
012771d8 WD |
74 | } __attribute__ ((packed)); |
75 | ||
8f8bd565 TR |
76 | /* Configuration information.. */ |
77 | struct usb_config { | |
c60795f4 | 78 | struct usb_config_descriptor desc; |
de39f8c1 | 79 | |
b12242ac | 80 | __u8 no_of_if; /* number of interfaces */ |
8f8bd565 | 81 | struct usb_interface if_desc[USB_MAXINTERFACES]; |
012771d8 WD |
82 | } __attribute__ ((packed)); |
83 | ||
48867208 RB |
84 | enum { |
85 | /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */ | |
86 | PACKET_SIZE_8 = 0, | |
87 | PACKET_SIZE_16 = 1, | |
88 | PACKET_SIZE_32 = 2, | |
89 | PACKET_SIZE_64 = 3, | |
90 | }; | |
012771d8 | 91 | |
de31213f SG |
92 | /** |
93 | * struct usb_device - information about a USB device | |
94 | * | |
95 | * With driver model both UCLASS_USB (the USB controllers) and UCLASS_USB_HUB | |
96 | * (the hubs) have this as parent data. Hubs are children of controllers or | |
97 | * other hubs and there is always a single root hub for each controller. | |
98 | * Therefore struct usb_device can always be accessed with | |
99 | * dev_get_parentdata(dev), where dev is a USB device. | |
100 | * | |
101 | * Pointers exist for obtaining both the device (could be any uclass) and | |
102 | * controller (UCLASS_USB) from this structure. The controller does not have | |
103 | * a struct usb_device since it is not a device. | |
104 | */ | |
012771d8 | 105 | struct usb_device { |
de39f8c1 | 106 | int devnum; /* Device number on USB bus */ |
3e126484 | 107 | int speed; /* full/low/high */ |
de39f8c1 MT |
108 | char mf[32]; /* manufacturer */ |
109 | char prod[32]; /* product */ | |
110 | char serial[32]; /* serial number */ | |
012771d8 | 111 | |
48867208 RB |
112 | /* Maximum packet size; one of: PACKET_SIZE_* */ |
113 | int maxpacketsize; | |
114 | /* one bit for each endpoint ([0] = IN, [1] = OUT) */ | |
115 | unsigned int toggle[2]; | |
de39f8c1 MT |
116 | /* endpoint halts; one bit per endpoint # & direction; |
117 | * [0] = IN, [1] = OUT | |
118 | */ | |
48867208 | 119 | unsigned int halted[2]; |
012771d8 WD |
120 | int epmaxpacketin[16]; /* INput endpoint specific maximums */ |
121 | int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ | |
122 | ||
123 | int configno; /* selected config number */ | |
f5766139 PS |
124 | /* Device Descriptor */ |
125 | struct usb_device_descriptor descriptor | |
126 | __attribute__((aligned(ARCH_DMA_MINALIGN))); | |
8f8bd565 | 127 | struct usb_config config; /* config descriptor */ |
012771d8 WD |
128 | |
129 | int have_langid; /* whether string_langid is valid yet */ | |
130 | int string_langid; /* language ID for strings */ | |
131 | int (*irq_handle)(struct usb_device *dev); | |
132 | unsigned long irq_status; | |
5cf91d6b | 133 | int irq_act_len; /* transfered bytes */ |
012771d8 WD |
134 | void *privptr; |
135 | /* | |
136 | * Child devices - if this is a hub device | |
137 | * Each instance needs its own set of data structures. | |
138 | */ | |
139 | unsigned long status; | |
904f2a83 | 140 | unsigned long int_pending; /* 1 bit per ep, used by int_queue */ |
012771d8 WD |
141 | int act_len; /* transfered bytes */ |
142 | int maxchild; /* Number of ports if hub */ | |
de31213f SG |
143 | int portnr; /* Port number, 1=first */ |
144 | #ifndef CONFIG_DM_USB | |
145 | /* parent hub, or NULL if this is the root hub */ | |
012771d8 WD |
146 | struct usb_device *parent; |
147 | struct usb_device *children[USB_MAXCHILDREN]; | |
c7e3b2b5 | 148 | void *controller; /* hardware controller private data */ |
de31213f | 149 | #endif |
5853e133 VG |
150 | /* slot_id - for xHCI enabled devices */ |
151 | unsigned int slot_id; | |
de31213f SG |
152 | #ifdef CONFIG_DM_USB |
153 | struct udevice *dev; /* Pointer to associated device */ | |
154 | struct udevice *controller_dev; /* Pointer to associated controller */ | |
155 | #endif | |
012771d8 WD |
156 | }; |
157 | ||
8460b89a HG |
158 | struct int_queue; |
159 | ||
bba67914 TK |
160 | /* |
161 | * You can initialize platform's USB host or device | |
162 | * ports by passing this enum as an argument to | |
163 | * board_usb_init(). | |
164 | */ | |
165 | enum usb_init_type { | |
166 | USB_INIT_HOST, | |
167 | USB_INIT_DEVICE | |
168 | }; | |
169 | ||
012771d8 WD |
170 | /********************************************************************** |
171 | * this is how the lowlevel part communicate with the outer world | |
172 | */ | |
173 | ||
822af351 | 174 | #if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \ |
51ab142b | 175 | defined(CONFIG_USB_EHCI) || defined(CONFIG_USB_OHCI_NEW) || \ |
3e126484 | 176 | defined(CONFIG_USB_SL811HS) || defined(CONFIG_USB_ISP116X_HCD) || \ |
f298e4b6 | 177 | defined(CONFIG_USB_R8A66597_HCD) || defined(CONFIG_USB_DAVINCI) || \ |
e608f221 | 178 | defined(CONFIG_USB_OMAP3) || defined(CONFIG_USB_DA8XX) || \ |
37931f02 | 179 | defined(CONFIG_USB_BLACKFIN) || defined(CONFIG_USB_AM35X) || \ |
673a524b | 180 | defined(CONFIG_USB_MUSB_DSPS) || defined(CONFIG_USB_MUSB_AM35X) || \ |
28a15ef7 HG |
181 | defined(CONFIG_USB_MUSB_OMAP2PLUS) || defined(CONFIG_USB_MUSB_SUNXI) || \ |
182 | defined(CONFIG_USB_XHCI) || defined(CONFIG_USB_DWC2) | |
822af351 | 183 | |
06d513ec | 184 | int usb_lowlevel_init(int index, enum usb_init_type init, void **controller); |
c7e3b2b5 | 185 | int usb_lowlevel_stop(int index); |
de31213f SG |
186 | |
187 | #if defined(CONFIG_MUSB_HOST) || defined(CONFIG_DM_USB) | |
188 | int usb_reset_root_port(void); | |
90cdc103 HG |
189 | #else |
190 | #define usb_reset_root_port() | |
191 | #endif | |
c7e3b2b5 | 192 | |
de39f8c1 MT |
193 | int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, |
194 | void *buffer, int transfer_len); | |
012771d8 | 195 | int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, |
de39f8c1 | 196 | int transfer_len, struct devrequest *setup); |
012771d8 WD |
197 | int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, |
198 | int transfer_len, int interval); | |
199 | ||
904f2a83 | 200 | #if defined CONFIG_USB_EHCI || defined CONFIG_MUSB_HOST |
8460b89a | 201 | struct int_queue *create_int_queue(struct usb_device *dev, unsigned long pipe, |
8bb6c1d1 | 202 | int queuesize, int elementsize, void *buffer, int interval); |
8460b89a HG |
203 | int destroy_int_queue(struct usb_device *dev, struct int_queue *queue); |
204 | void *poll_int_queue(struct usb_device *dev, struct int_queue *queue); | |
205 | #endif | |
206 | ||
012771d8 | 207 | /* Defines */ |
de39f8c1 MT |
208 | #define USB_UHCI_VEND_ID 0x8086 |
209 | #define USB_UHCI_DEV_ID 0x7112 | |
012771d8 | 210 | |
e5f24753 LD |
211 | /* |
212 | * PXA25x can only act as USB device. There are drivers | |
213 | * which works with USB CDC gadgets implementations. | |
214 | * Some of them have common routines which can be used | |
215 | * in boards init functions e.g. udc_disconnect() used for | |
216 | * forced device disconnection from host. | |
217 | */ | |
218 | #elif defined(CONFIG_USB_GADGET_PXA2XX) | |
219 | ||
220 | extern void udc_disconnect(void); | |
221 | ||
012771d8 WD |
222 | #endif |
223 | ||
16297cfb MZ |
224 | /* |
225 | * board-specific hardware initialization, called by | |
226 | * usb drivers and u-boot commands | |
227 | * | |
228 | * @param index USB controller number | |
229 | * @param init initializes controller as USB host or device | |
230 | */ | |
bba67914 | 231 | int board_usb_init(int index, enum usb_init_type init); |
16297cfb MZ |
232 | |
233 | /* | |
234 | * can be used to clean up after failed USB initialization attempt | |
235 | * vide: board_usb_init() | |
236 | * | |
237 | * @param index USB controller number for selective cleanup | |
bba67914 | 238 | * @param init usb_init_type passed to board_usb_init() |
16297cfb | 239 | */ |
bba67914 | 240 | int board_usb_cleanup(int index, enum usb_init_type init); |
16297cfb | 241 | |
012771d8 WD |
242 | #ifdef CONFIG_USB_STORAGE |
243 | ||
244 | #define USB_MAX_STOR_DEV 5 | |
245 | block_dev_desc_t *usb_stor_get_dev(int index); | |
246 | int usb_stor_scan(int mode); | |
e813eae3 | 247 | int usb_stor_info(void); |
012771d8 WD |
248 | |
249 | #endif | |
250 | ||
89d48367 SG |
251 | #ifdef CONFIG_USB_HOST_ETHER |
252 | ||
253 | #define USB_MAX_ETH_DEV 5 | |
254 | int usb_host_eth_scan(int mode); | |
255 | ||
256 | #endif | |
257 | ||
012771d8 WD |
258 | #ifdef CONFIG_USB_KEYBOARD |
259 | ||
260 | int drv_usb_kbd_init(void); | |
8a8a2257 | 261 | int usb_kbd_deregister(int force); |
012771d8 WD |
262 | |
263 | #endif | |
264 | /* routines */ | |
265 | int usb_init(void); /* initialize the USB Controller */ | |
266 | int usb_stop(void); /* stop the USB Controller */ | |
267 | ||
268 | ||
269 | int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol); | |
de39f8c1 MT |
270 | int usb_set_idle(struct usb_device *dev, int ifnum, int duration, |
271 | int report_id); | |
012771d8 WD |
272 | int usb_control_msg(struct usb_device *dev, unsigned int pipe, |
273 | unsigned char request, unsigned char requesttype, | |
274 | unsigned short value, unsigned short index, | |
275 | void *data, unsigned short size, int timeout); | |
276 | int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, | |
277 | void *data, int len, int *actual_length, int timeout); | |
278 | int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, | |
de39f8c1 | 279 | void *buffer, int transfer_len, int interval); |
89d48367 | 280 | int usb_disable_asynch(int disable); |
de39f8c1 | 281 | int usb_maxpacket(struct usb_device *dev, unsigned long pipe); |
de39f8c1 MT |
282 | int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer, |
283 | int cfgno); | |
284 | int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, | |
285 | unsigned char id, void *buf, int size); | |
012771d8 | 286 | int usb_get_class_descriptor(struct usb_device *dev, int ifnum, |
de39f8c1 MT |
287 | unsigned char type, unsigned char id, void *buf, |
288 | int size); | |
012771d8 WD |
289 | int usb_clear_halt(struct usb_device *dev, int pipe); |
290 | int usb_string(struct usb_device *dev, int index, char *buf, size_t size); | |
291 | int usb_set_interface(struct usb_device *dev, int interface, int alternate); | |
292 | ||
293 | /* big endian -> little endian conversion */ | |
149dded2 | 294 | /* some CPUs are already little endian e.g. the ARM920T */ |
ae3b770e | 295 | #define __swap_16(x) \ |
3f85ce27 WD |
296 | ({ unsigned short x_ = (unsigned short)x; \ |
297 | (unsigned short)( \ | |
de39f8c1 | 298 | ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \ |
3f85ce27 | 299 | }) |
ae3b770e | 300 | #define __swap_32(x) \ |
3f85ce27 WD |
301 | ({ unsigned long x_ = (unsigned long)x; \ |
302 | (unsigned long)( \ | |
303 | ((x_ & 0x000000FFUL) << 24) | \ | |
5cf91d6b WD |
304 | ((x_ & 0x0000FF00UL) << 8) | \ |
305 | ((x_ & 0x00FF0000UL) >> 8) | \ | |
de39f8c1 | 306 | ((x_ & 0xFF000000UL) >> 24)); \ |
3f85ce27 | 307 | }) |
ae3b770e | 308 | |
c7d703f3 | 309 | #ifdef __LITTLE_ENDIAN |
ae3b770e MK |
310 | # define swap_16(x) (x) |
311 | # define swap_32(x) (x) | |
312 | #else | |
313 | # define swap_16(x) __swap_16(x) | |
314 | # define swap_32(x) __swap_32(x) | |
c7d703f3 | 315 | #endif |
012771d8 WD |
316 | |
317 | /* | |
318 | * Calling this entity a "pipe" is glorifying it. A USB pipe | |
319 | * is something embarrassingly simple: it basically consists | |
320 | * of the following information: | |
321 | * - device number (7 bits) | |
322 | * - endpoint number (4 bits) | |
323 | * - current Data0/1 state (1 bit) | |
324 | * - direction (1 bit) | |
3e126484 | 325 | * - speed (2 bits) |
012771d8 WD |
326 | * - max packet size (2 bits: 8, 16, 32 or 64) |
327 | * - pipe type (2 bits: control, interrupt, bulk, isochronous) | |
328 | * | |
329 | * That's 18 bits. Really. Nothing more. And the USB people have | |
330 | * documented these eighteen bits as some kind of glorious | |
331 | * virtual data structure. | |
332 | * | |
333 | * Let's not fall in that trap. We'll just encode it as a simple | |
334 | * unsigned int. The encoding is: | |
335 | * | |
336 | * - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64) | |
de39f8c1 MT |
337 | * - direction: bit 7 (0 = Host-to-Device [Out], |
338 | * (1 = Device-to-Host [In]) | |
012771d8 WD |
339 | * - device: bits 8-14 |
340 | * - endpoint: bits 15-18 | |
341 | * - Data0/1: bit 19 | |
de39f8c1 MT |
342 | * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt, |
343 | * 10 = control, 11 = bulk) | |
012771d8 WD |
344 | * |
345 | * Why? Because it's arbitrary, and whatever encoding we select is really | |
346 | * up to us. This one happens to share a lot of bit positions with the UHCI | |
347 | * specification, so that much of the uhci driver can just mask the bits | |
348 | * appropriately. | |
349 | */ | |
350 | /* Create various pipes... */ | |
351 | #define create_pipe(dev,endpoint) \ | |
d0fe1128 | 352 | (((dev)->devnum << 8) | ((endpoint) << 15) | \ |
c60795f4 | 353 | (dev)->maxpacketsize) |
3e126484 | 354 | #define default_pipe(dev) ((dev)->speed << 26) |
de39f8c1 MT |
355 | |
356 | #define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ | |
357 | create_pipe(dev, endpoint)) | |
358 | #define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ | |
359 | create_pipe(dev, endpoint) | \ | |
360 | USB_DIR_IN) | |
361 | #define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ | |
362 | create_pipe(dev, endpoint)) | |
363 | #define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ | |
364 | create_pipe(dev, endpoint) | \ | |
365 | USB_DIR_IN) | |
366 | #define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ | |
367 | create_pipe(dev, endpoint)) | |
368 | #define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ | |
369 | create_pipe(dev, endpoint) | \ | |
370 | USB_DIR_IN) | |
371 | #define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ | |
372 | create_pipe(dev, endpoint)) | |
373 | #define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ | |
374 | create_pipe(dev, endpoint) | \ | |
375 | USB_DIR_IN) | |
376 | #define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \ | |
377 | default_pipe(dev)) | |
378 | #define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \ | |
379 | default_pipe(dev) | \ | |
380 | USB_DIR_IN) | |
012771d8 WD |
381 | |
382 | /* The D0/D1 toggle bits */ | |
383 | #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1) | |
5cf91d6b | 384 | #define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep)) |
de39f8c1 MT |
385 | #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \ |
386 | ((dev)->toggle[out] & \ | |
387 | ~(1 << ep)) | ((bit) << ep)) | |
012771d8 WD |
388 | |
389 | /* Endpoint halt control/status */ | |
390 | #define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1) | |
391 | #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep))) | |
392 | #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep))) | |
393 | #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep))) | |
394 | ||
de39f8c1 MT |
395 | #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \ |
396 | USB_PID_OUT) | |
012771d8 WD |
397 | |
398 | #define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1) | |
399 | #define usb_pipein(pipe) (((pipe) >> 7) & 1) | |
400 | #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f) | |
401 | #define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff) | |
402 | #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf) | |
403 | #define usb_pipedata(pipe) (((pipe) >> 19) & 1) | |
012771d8 WD |
404 | #define usb_pipetype(pipe) (((pipe) >> 30) & 3) |
405 | #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS) | |
406 | #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT) | |
407 | #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL) | |
408 | #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK) | |
409 | ||
5853e133 VG |
410 | #define usb_pipe_ep_index(pipe) \ |
411 | usb_pipecontrol(pipe) ? (usb_pipeendpoint(pipe) * 2) : \ | |
412 | ((usb_pipeendpoint(pipe) * 2) - \ | |
413 | (usb_pipein(pipe) ? 0 : 1)) | |
012771d8 WD |
414 | |
415 | /************************************************************************* | |
416 | * Hub Stuff | |
417 | */ | |
418 | struct usb_port_status { | |
419 | unsigned short wPortStatus; | |
420 | unsigned short wPortChange; | |
421 | } __attribute__ ((packed)); | |
422 | ||
423 | struct usb_hub_status { | |
424 | unsigned short wHubStatus; | |
425 | unsigned short wHubChange; | |
426 | } __attribute__ ((packed)); | |
427 | ||
428 | ||
429 | /* Hub descriptor */ | |
430 | struct usb_hub_descriptor { | |
431 | unsigned char bLength; | |
432 | unsigned char bDescriptorType; | |
433 | unsigned char bNbrPorts; | |
434 | unsigned short wHubCharacteristics; | |
435 | unsigned char bPwrOn2PwrGood; | |
436 | unsigned char bHubContrCurrent; | |
437 | unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8]; | |
438 | unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8]; | |
de39f8c1 | 439 | /* DeviceRemovable and PortPwrCtrlMask want to be variable-length |
012771d8 WD |
440 | bitmaps that hold max 255 entries. (bit0 is ignored) */ |
441 | } __attribute__ ((packed)); | |
442 | ||
443 | ||
444 | struct usb_hub_device { | |
445 | struct usb_device *pusb_dev; | |
446 | struct usb_hub_descriptor desc; | |
447 | }; | |
448 | ||
de31213f SG |
449 | #ifdef CONFIG_DM_USB |
450 | /** | |
451 | * struct usb_platdata - Platform data about a USB controller | |
452 | * | |
453 | * Given a USB controller (UCLASS_USB) dev this is dev_get_platdata(dev) | |
454 | */ | |
455 | struct usb_platdata { | |
456 | enum usb_init_type init_type; | |
457 | }; | |
458 | ||
459 | /** | |
460 | * struct usb_dev_platdata - Platform data about a USB device | |
461 | * | |
462 | * Given a USB device dev this structure is dev_get_parent_platdata(dev). | |
463 | * This is used by sandbox to provide emulation data also. | |
464 | * | |
465 | * @id: ID used to match this device | |
466 | * @speed: Stores the speed associated with a USB device | |
467 | * @devnum: Device address on the USB bus | |
468 | * @slot_id: USB3 slot ID, which is separate from the device address | |
469 | * @portnr: Port number of this device on its parent hub, numbered from 1 | |
470 | * (0 mean this device is the root hub) | |
471 | * @strings: List of descriptor strings (for sandbox emulation purposes) | |
472 | * @desc_list: List of descriptors (for sandbox emulation purposes) | |
473 | */ | |
474 | struct usb_dev_platdata { | |
475 | struct usb_device_id id; | |
476 | enum usb_device_speed speed; | |
477 | int devnum; | |
478 | int slot_id; | |
479 | int portnr; /* Hub port number, 1..n */ | |
480 | #ifdef CONFIG_SANDBOX | |
481 | struct usb_string *strings; | |
482 | /* NULL-terminated list of descriptor pointers */ | |
483 | struct usb_generic_descriptor **desc_list; | |
484 | #endif | |
485 | int configno; | |
486 | }; | |
487 | ||
488 | /** | |
489 | * struct usb_bus_priv - information about the USB controller | |
490 | * | |
491 | * Given a USB controller (UCLASS_USB) 'dev', this is | |
492 | * dev_get_uclass_priv(dev). | |
493 | * | |
494 | * @next_addr: Next device address to allocate minus 1. Incremented by 1 | |
495 | * each time a new device address is set, so this holds the | |
496 | * number of devices on the bus | |
497 | * @desc_before_addr: true if we can read a device descriptor before it | |
498 | * has been assigned an address. For XHCI this is not possible | |
499 | * so this will be false. | |
500 | */ | |
501 | struct usb_bus_priv { | |
502 | int next_addr; | |
503 | bool desc_before_addr; | |
504 | }; | |
505 | ||
506 | /** | |
507 | * struct dm_usb_ops - USB controller operations | |
508 | * | |
509 | * This defines the operations supoorted on a USB controller. Common | |
510 | * arguments are: | |
511 | * | |
512 | * @bus: USB bus (i.e. controller), which is in UCLASS_USB. | |
513 | * @udev: USB device parent data. Controllers are not expected to need | |
514 | * this, since the device address on the bus is encoded in @pipe. | |
515 | * It is used for sandbox, and can be handy for debugging and | |
516 | * logging. | |
517 | * @pipe: An assortment of bitfields which provide address and packet | |
518 | * type information. See create_pipe() above for encoding | |
519 | * details | |
520 | * @buffer: A buffer to use for sending/receiving. This should be | |
521 | * DMA-aligned. | |
522 | * @length: Buffer length in bytes | |
523 | */ | |
524 | struct dm_usb_ops { | |
525 | /** | |
526 | * control() - Send a control message | |
527 | * | |
528 | * Most parameters are as above. | |
529 | * | |
530 | * @setup: Additional setup information required by the message | |
531 | */ | |
532 | int (*control)(struct udevice *bus, struct usb_device *udev, | |
533 | unsigned long pipe, void *buffer, int length, | |
534 | struct devrequest *setup); | |
535 | /** | |
536 | * bulk() - Send a bulk message | |
537 | * | |
538 | * Parameters are as above. | |
539 | */ | |
540 | int (*bulk)(struct udevice *bus, struct usb_device *udev, | |
541 | unsigned long pipe, void *buffer, int length); | |
542 | /** | |
543 | * interrupt() - Send an interrupt message | |
544 | * | |
545 | * Most parameters are as above. | |
546 | * | |
547 | * @interval: Interrupt interval | |
548 | */ | |
549 | int (*interrupt)(struct udevice *bus, struct usb_device *udev, | |
550 | unsigned long pipe, void *buffer, int length, | |
551 | int interval); | |
552 | /** | |
553 | * alloc_device() - Allocate a new device context (XHCI) | |
554 | * | |
555 | * Before sending packets to a new device on an XHCI bus, a device | |
556 | * context must be created. If this method is not NULL it will be | |
557 | * called before the device is enumerated (even before its descriptor | |
558 | * is read). This should be NULL for EHCI, which does not need this. | |
559 | */ | |
560 | int (*alloc_device)(struct udevice *bus, struct usb_device *udev); | |
561 | }; | |
562 | ||
563 | #define usb_get_ops(dev) ((struct dm_usb_ops *)(dev)->driver->ops) | |
564 | #define usb_get_emul_ops(dev) ((struct dm_usb_ops *)(dev)->driver->ops) | |
565 | ||
566 | #ifdef CONFIG_MUSB_HOST | |
567 | int usb_reset_root_port(void); | |
568 | #endif | |
569 | ||
570 | /** | |
571 | * usb_get_dev_index() - look up a device index number | |
572 | * | |
573 | * Look up devices using their index number (starting at 0). This works since | |
574 | * in U-Boot device addresses are allocated starting at 1 with no gaps. | |
575 | * | |
576 | * TODO(sjg@chromium.org): Remove this function when usb_ether.c is modified | |
577 | * to work better with driver model. | |
578 | * | |
579 | * @bus: USB bus to check | |
580 | * @index: Index number of device to find (0=first). This is just the | |
581 | * device address less 1. | |
582 | */ | |
583 | struct usb_device *usb_get_dev_index(struct udevice *bus, int index); | |
584 | ||
585 | /** | |
586 | * usb_legacy_port_reset() - Legacy function to reset a hub port | |
587 | * | |
588 | * @hub: Hub device | |
589 | * @portnr: Port number (1=first) | |
590 | */ | |
591 | int usb_legacy_port_reset(struct usb_device *hub, int portnr); | |
592 | ||
593 | /** | |
594 | * usb_setup_device() - set up a device ready for use | |
595 | * | |
596 | * @dev: USB device pointer. This need not be a real device - it is | |
597 | * common for it to just be a local variable with its ->dev | |
598 | * member (i.e. @dev->dev) set to the parent device | |
599 | * @do_read: true to read the device descriptor before an address is set | |
600 | * (should be false for XHCI buses, true otherwise) | |
601 | * @parent: Parent device (either UCLASS_USB or UCLASS_USB_HUB) | |
602 | * @portnr: Port number on hub (1=first) or 0 for none | |
603 | * @return 0 if OK, -ve on error */ | |
604 | int usb_setup_device(struct usb_device *dev, bool do_read, | |
605 | struct usb_device *parent, int portnr); | |
606 | ||
607 | /** | |
608 | * usb_hub_scan() - Scan a hub and find its devices | |
609 | * | |
610 | * @hub: Hub device to scan | |
611 | */ | |
612 | int usb_hub_scan(struct udevice *hub); | |
613 | ||
614 | /** | |
615 | * usb_scan_device() - Scan a device on a bus | |
616 | * | |
617 | * Scan a device on a bus. It has already been detected and is ready to | |
618 | * be enumerated. This may be either the root hub (@parent is a bus) or a | |
619 | * normal device (@parent is a hub) | |
620 | * | |
621 | * @parent: Parent device | |
622 | * @port: Hub port number (numbered from 1) | |
623 | * @speed: USB speed to use for this device | |
624 | * @devp: Returns pointer to device if all is well | |
625 | * @return 0 if OK, -ve on error | |
626 | */ | |
627 | int usb_scan_device(struct udevice *parent, int port, | |
628 | enum usb_device_speed speed, struct udevice **devp); | |
629 | ||
630 | /** | |
631 | * usb_get_bus() - Find the bus for a device | |
632 | * | |
633 | * Search up through parents to find the bus this device is connected to. This | |
634 | * will be a device with uclass UCLASS_USB. | |
635 | * | |
636 | * @dev: Device to check | |
637 | * @busp: Returns bus, or NULL if not found | |
638 | * @return 0 if OK, -EXDEV is somehow this bus does not have a controller (this | |
639 | * indicates a critical error in the USB stack | |
640 | */ | |
641 | int usb_get_bus(struct udevice *dev, struct udevice **busp); | |
642 | ||
643 | /** | |
644 | * usb_select_config() - Set up a device ready for use | |
645 | * | |
646 | * This function assumes that the device already has an address and a driver | |
647 | * bound, and is ready to be set up. | |
648 | * | |
649 | * This re-reads the device and configuration descriptors and sets the | |
650 | * configuration | |
651 | * | |
652 | * @dev: Device to set up | |
653 | */ | |
654 | int usb_select_config(struct usb_device *dev); | |
655 | ||
656 | /** | |
657 | * usb_child_pre_probe() - Pre-probe function for USB devices | |
658 | * | |
659 | * This is called on all children of hubs and USB controllers (i.e. UCLASS_USB | |
660 | * and UCLASS_USB_HUB) when a new device is about to be probed. It sets up the | |
661 | * device from the saved platform data and calls usb_select_config() to | |
662 | * finish set up. | |
663 | * | |
664 | * Once this is done, the device's normal driver can take over, knowing the | |
665 | * device is accessible on the USB bus. | |
666 | * | |
667 | * This function is for use only by the internal USB stack. | |
668 | * | |
669 | * @dev: Device to set up | |
670 | */ | |
671 | int usb_child_pre_probe(struct udevice *dev); | |
672 | ||
673 | struct ehci_ctrl; | |
674 | ||
675 | /** | |
676 | * usb_setup_ehci_gadget() - Set up a USB device as a gadget | |
677 | * | |
678 | * TODO(sjg@chromium.org): Tidy this up when USB gadgets can use driver model | |
679 | * | |
680 | * This provides a way to tell a controller to start up as a USB device | |
681 | * instead of as a host. It is untested. | |
682 | */ | |
683 | int usb_setup_ehci_gadget(struct ehci_ctrl **ctlrp); | |
684 | ||
685 | /** | |
686 | * usb_stor_reset() - Prepare to scan USB storage devices | |
687 | * | |
688 | * Empty the list of USB storage devices in preparation for scanning them. | |
689 | * This must be called before a USB scan. | |
690 | */ | |
691 | void usb_stor_reset(void); | |
692 | ||
693 | #else /* !CONFIG_DM_USB */ | |
694 | ||
695 | struct usb_device *usb_get_dev_index(int index); | |
696 | ||
697 | #endif | |
698 | ||
699 | bool usb_device_has_child_on_port(struct usb_device *parent, int port); | |
700 | ||
23faf2bc MV |
701 | int usb_hub_probe(struct usb_device *dev, int ifnum); |
702 | void usb_hub_reset(void); | |
703 | int hub_port_reset(struct usb_device *dev, int port, | |
704 | unsigned short *portstat); | |
705 | ||
c7e3b2b5 LS |
706 | struct usb_device *usb_alloc_new_device(void *controller); |
707 | ||
23faf2bc | 708 | int usb_new_device(struct usb_device *dev); |
359439d2 | 709 | void usb_free_device(void); |
5853e133 | 710 | int usb_alloc_device(struct usb_device *dev); |
23faf2bc | 711 | |
012771d8 | 712 | #endif /*_USB_H_ */ |