Eric Lee / smarc-uboot

Download as
Browse Code ยป

Commit b335fe681075bd6bd3e6842bad12a0ccb573dc4f

Authored by Hans de Goede
Committed by Marek Vasut
1 parent c6265f7f34
Exists in v2017.01-smarct4x and in 34 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf_v2022.04, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc-imx6_v2018.03_4.14.98_2.0.0_ga, smarc-imx7_v2017.03_4.9.11_1.0.0_ga, smarc-imx7_v2018.03_4.14.98_2.0.0_ga, smarc-imx_v2017.03_4.9.11_1.0.0_ga, smarc-imx_v2017.03_4.9.88_2.0.0_ga, smarc-imx_v2017.03_o8.1.0_1.3.0_8m, smarc-imx_v2018.03_4.14.78_1.0.0_ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_2.0.0_ga, smarc_8m-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8m_00d0-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0, smarc_8mq_lf_v2020.04, ti-u-boot-2015.07, v2015.07-smarct33, v2015.07-smarct33-emmc, v2015.07-smarct4x, v2016.05-dlt, v2016.05-smarct3x, v2016.05-smarct3x-emmc, v2016.05-smarct4x, v2017.01-smarct3x, v2017.01-smarct3x-emmc

usb.h: Always declare usb function prototypes 

There is no harm in declaring the function prototypes even if nothing
implements them, and when CONFIG_DM_USB=y the various usb functions are
available regardless of any controller drivers being enabled.

This fixes compile warnings due to missing prototypes on ARCHs where
the ARCH Kconfig always enables CONFIG_DM_USB and various usb drivers.

One could argue that in the case of no controllers CONFIG_DM_USB should not
be set, but this problem is typically seen during bringup of boards which
do actually have usb controllers.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>

Showing 1 changed file with 0 additions and 15 deletions Inline Diff

1 /* 1 /*
2 * (C) Copyright 2001 2 * (C) Copyright 2001
3 * Denis Peter, MPL AG Switzerland 3 * Denis Peter, MPL AG Switzerland
4 * 4 *
5 * Adapted for U-Boot driver model 5 * Adapted for U-Boot driver model
6 * (C) Copyright 2015 Google, Inc 6 * (C) Copyright 2015 Google, Inc
7 * 7 *
8 * SPDX-License-Identifier: GPL-2.0+ 8 * SPDX-License-Identifier: GPL-2.0+
9 * Note: Part of this code has been derived from linux 9 * Note: Part of this code has been derived from linux
10 * 10 *
11 */ 11 */
12 #ifndef _USB_H_ 12 #ifndef _USB_H_
13 #define _USB_H_ 13 #define _USB_H_
14 14
15 #include <fdtdec.h> 15 #include <fdtdec.h>
16 #include <usb_defs.h> 16 #include <usb_defs.h>
17 #include <linux/usb/ch9.h> 17 #include <linux/usb/ch9.h>
18 #include <asm/cache.h> 18 #include <asm/cache.h>
19 #include <part.h> 19 #include <part.h>
20 20
21 /* 21 /*
22 * The EHCI spec says that we must align to at least 32 bytes. However, 22 * The EHCI spec says that we must align to at least 32 bytes. However,
23 * some platforms require larger alignment. 23 * some platforms require larger alignment.
24 */ 24 */
25 #if ARCH_DMA_MINALIGN > 32 25 #if ARCH_DMA_MINALIGN > 32
26 #define USB_DMA_MINALIGN ARCH_DMA_MINALIGN 26 #define USB_DMA_MINALIGN ARCH_DMA_MINALIGN
27 #else 27 #else
28 #define USB_DMA_MINALIGN 32 28 #define USB_DMA_MINALIGN 32
29 #endif 29 #endif
30 30
31 /* Everything is aribtrary */ 31 /* Everything is aribtrary */
32 #define USB_ALTSETTINGALLOC 4 32 #define USB_ALTSETTINGALLOC 4
33 #define USB_MAXALTSETTING 128 /* Hard limit */ 33 #define USB_MAXALTSETTING 128 /* Hard limit */
34 34
35 #define USB_MAX_DEVICE 32 35 #define USB_MAX_DEVICE 32
36 #define USB_MAXCONFIG 8 36 #define USB_MAXCONFIG 8
37 #define USB_MAXINTERFACES 8 37 #define USB_MAXINTERFACES 8
38 #define USB_MAXENDPOINTS 16 38 #define USB_MAXENDPOINTS 16
39 #define USB_MAXCHILDREN 8 /* This is arbitrary */ 39 #define USB_MAXCHILDREN 8 /* This is arbitrary */
40 #define USB_MAX_HUB 16 40 #define USB_MAX_HUB 16
41 41
42 #define USB_CNTL_TIMEOUT 100 /* 100ms timeout */ 42 #define USB_CNTL_TIMEOUT 100 /* 100ms timeout */
43 43
44 /* 44 /*
45 * This is the timeout to allow for submitting an urb in ms. We allow more 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. 46 * time for a BULK device to react - some are slow.
47 */ 47 */
48 #define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000) 48 #define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000)
49 49
50 /* device request (setup) */ 50 /* device request (setup) */
51 struct devrequest { 51 struct devrequest {
52 __u8 requesttype; 52 __u8 requesttype;
53 __u8 request; 53 __u8 request;
54 __le16 value; 54 __le16 value;
55 __le16 index; 55 __le16 index;
56 __le16 length; 56 __le16 length;
57 } __attribute__ ((packed)); 57 } __attribute__ ((packed));
58 58
59 /* Interface */ 59 /* Interface */
60 struct usb_interface { 60 struct usb_interface {
61 struct usb_interface_descriptor desc; 61 struct usb_interface_descriptor desc;
62 62
63 __u8 no_of_ep; 63 __u8 no_of_ep;
64 __u8 num_altsetting; 64 __u8 num_altsetting;
65 __u8 act_altsetting; 65 __u8 act_altsetting;
66 66
67 struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; 67 struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS];
68 /* 68 /*
69 * Super Speed Device will have Super Speed Endpoint 69 * Super Speed Device will have Super Speed Endpoint
70 * Companion Descriptor (section 9.6.7 of usb 3.0 spec) 70 * Companion Descriptor (section 9.6.7 of usb 3.0 spec)
71 * Revision 1.0 June 6th 2011 71 * Revision 1.0 June 6th 2011
72 */ 72 */
73 struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS]; 73 struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS];
74 } __attribute__ ((packed)); 74 } __attribute__ ((packed));
75 75
76 /* Configuration information.. */ 76 /* Configuration information.. */
77 struct usb_config { 77 struct usb_config {
78 struct usb_config_descriptor desc; 78 struct usb_config_descriptor desc;
79 79
80 __u8 no_of_if; /* number of interfaces */ 80 __u8 no_of_if; /* number of interfaces */
81 struct usb_interface if_desc[USB_MAXINTERFACES]; 81 struct usb_interface if_desc[USB_MAXINTERFACES];
82 } __attribute__ ((packed)); 82 } __attribute__ ((packed));
83 83
84 enum { 84 enum {
85 /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */ 85 /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */
86 PACKET_SIZE_8 = 0, 86 PACKET_SIZE_8 = 0,
87 PACKET_SIZE_16 = 1, 87 PACKET_SIZE_16 = 1,
88 PACKET_SIZE_32 = 2, 88 PACKET_SIZE_32 = 2,
89 PACKET_SIZE_64 = 3, 89 PACKET_SIZE_64 = 3,
90 }; 90 };
91 91
92 /** 92 /**
93 * struct usb_device - information about a USB device 93 * struct usb_device - information about a USB device
94 * 94 *
95 * With driver model both UCLASS_USB (the USB controllers) and UCLASS_USB_HUB 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 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. 97 * other hubs and there is always a single root hub for each controller.
98 * Therefore struct usb_device can always be accessed with 98 * Therefore struct usb_device can always be accessed with
99 * dev_get_parentdata(dev), where dev is a USB device. 99 * dev_get_parentdata(dev), where dev is a USB device.
100 * 100 *
101 * Pointers exist for obtaining both the device (could be any uclass) and 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 102 * controller (UCLASS_USB) from this structure. The controller does not have
103 * a struct usb_device since it is not a device. 103 * a struct usb_device since it is not a device.
104 */ 104 */
105 struct usb_device { 105 struct usb_device {
106 int devnum; /* Device number on USB bus */ 106 int devnum; /* Device number on USB bus */
107 int speed; /* full/low/high */ 107 int speed; /* full/low/high */
108 char mf[32]; /* manufacturer */ 108 char mf[32]; /* manufacturer */
109 char prod[32]; /* product */ 109 char prod[32]; /* product */
110 char serial[32]; /* serial number */ 110 char serial[32]; /* serial number */
111 111
112 /* Maximum packet size; one of: PACKET_SIZE_* */ 112 /* Maximum packet size; one of: PACKET_SIZE_* */
113 int maxpacketsize; 113 int maxpacketsize;
114 /* one bit for each endpoint ([0] = IN, [1] = OUT) */ 114 /* one bit for each endpoint ([0] = IN, [1] = OUT) */
115 unsigned int toggle[2]; 115 unsigned int toggle[2];
116 /* endpoint halts; one bit per endpoint # & direction; 116 /* endpoint halts; one bit per endpoint # & direction;
117 * [0] = IN, [1] = OUT 117 * [0] = IN, [1] = OUT
118 */ 118 */
119 unsigned int halted[2]; 119 unsigned int halted[2];
120 int epmaxpacketin[16]; /* INput endpoint specific maximums */ 120 int epmaxpacketin[16]; /* INput endpoint specific maximums */
121 int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ 121 int epmaxpacketout[16]; /* OUTput endpoint specific maximums */
122 122
123 int configno; /* selected config number */ 123 int configno; /* selected config number */
124 /* Device Descriptor */ 124 /* Device Descriptor */
125 struct usb_device_descriptor descriptor 125 struct usb_device_descriptor descriptor
126 __attribute__((aligned(ARCH_DMA_MINALIGN))); 126 __attribute__((aligned(ARCH_DMA_MINALIGN)));
127 struct usb_config config; /* config descriptor */ 127 struct usb_config config; /* config descriptor */
128 128
129 int have_langid; /* whether string_langid is valid yet */ 129 int have_langid; /* whether string_langid is valid yet */
130 int string_langid; /* language ID for strings */ 130 int string_langid; /* language ID for strings */
131 int (*irq_handle)(struct usb_device *dev); 131 int (*irq_handle)(struct usb_device *dev);
132 unsigned long irq_status; 132 unsigned long irq_status;
133 int irq_act_len; /* transfered bytes */ 133 int irq_act_len; /* transfered bytes */
134 void *privptr; 134 void *privptr;
135 /* 135 /*
136 * Child devices - if this is a hub device 136 * Child devices - if this is a hub device
137 * Each instance needs its own set of data structures. 137 * Each instance needs its own set of data structures.
138 */ 138 */
139 unsigned long status; 139 unsigned long status;
140 unsigned long int_pending; /* 1 bit per ep, used by int_queue */ 140 unsigned long int_pending; /* 1 bit per ep, used by int_queue */
141 int act_len; /* transfered bytes */ 141 int act_len; /* transfered bytes */
142 int maxchild; /* Number of ports if hub */ 142 int maxchild; /* Number of ports if hub */
143 int portnr; /* Port number, 1=first */ 143 int portnr; /* Port number, 1=first */
144 #ifndef CONFIG_DM_USB 144 #ifndef CONFIG_DM_USB
145 /* parent hub, or NULL if this is the root hub */ 145 /* parent hub, or NULL if this is the root hub */
146 struct usb_device *parent; 146 struct usb_device *parent;
147 struct usb_device *children[USB_MAXCHILDREN]; 147 struct usb_device *children[USB_MAXCHILDREN];
148 void *controller; /* hardware controller private data */ 148 void *controller; /* hardware controller private data */
149 #endif 149 #endif
150 /* slot_id - for xHCI enabled devices */ 150 /* slot_id - for xHCI enabled devices */
151 unsigned int slot_id; 151 unsigned int slot_id;
152 #ifdef CONFIG_DM_USB 152 #ifdef CONFIG_DM_USB
153 struct udevice *dev; /* Pointer to associated device */ 153 struct udevice *dev; /* Pointer to associated device */
154 struct udevice *controller_dev; /* Pointer to associated controller */ 154 struct udevice *controller_dev; /* Pointer to associated controller */
155 #endif 155 #endif
156 }; 156 };
157 157
158 struct int_queue; 158 struct int_queue;
159 159
160 /* 160 /*
161 * You can initialize platform's USB host or device 161 * You can initialize platform's USB host or device
162 * ports by passing this enum as an argument to 162 * ports by passing this enum as an argument to
163 * board_usb_init(). 163 * board_usb_init().
164 */ 164 */
165 enum usb_init_type { 165 enum usb_init_type {
166 USB_INIT_HOST, 166 USB_INIT_HOST,
167 USB_INIT_DEVICE 167 USB_INIT_DEVICE
168 }; 168 };
169 169
170 /********************************************************************** 170 /**********************************************************************
171 * this is how the lowlevel part communicate with the outer world 171 * this is how the lowlevel part communicate with the outer world
172 */ 172 */
173 173
174 #if defined(CONFIG_USB_UHCI) || defined(CONFIG_USB_OHCI) || \
175 defined(CONFIG_USB_EHCI) || defined(CONFIG_USB_OHCI_NEW) || \
176 defined(CONFIG_USB_SL811HS) || defined(CONFIG_USB_ISP116X_HCD) || \
177 defined(CONFIG_USB_R8A66597_HCD) || defined(CONFIG_USB_DAVINCI) || \
178 defined(CONFIG_USB_OMAP3) || defined(CONFIG_USB_DA8XX) || \
179 defined(CONFIG_USB_BLACKFIN) || defined(CONFIG_USB_AM35X) || \
180 defined(CONFIG_USB_MUSB_DSPS) || defined(CONFIG_USB_MUSB_AM35X) || \
181 defined(CONFIG_USB_MUSB_OMAP2PLUS) || defined(CONFIG_USB_MUSB_SUNXI) || \
182 defined(CONFIG_USB_XHCI) || defined(CONFIG_USB_DWC2) || \
183 defined(CONFIG_USB_EMUL)
184
185 int usb_lowlevel_init(int index, enum usb_init_type init, void **controller); 174 int usb_lowlevel_init(int index, enum usb_init_type init, void **controller);
186 int usb_lowlevel_stop(int index); 175 int usb_lowlevel_stop(int index);
187 176
188 #if defined(CONFIG_MUSB_HOST) || defined(CONFIG_DM_USB) 177 #if defined(CONFIG_MUSB_HOST) || defined(CONFIG_DM_USB)
189 int usb_reset_root_port(void); 178 int usb_reset_root_port(void);
190 #else 179 #else
191 #define usb_reset_root_port() 180 #define usb_reset_root_port()
192 #endif 181 #endif
193 182
194 int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, 183 int submit_bulk_msg(struct usb_device *dev, unsigned long pipe,
195 void *buffer, int transfer_len); 184 void *buffer, int transfer_len);
196 int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, 185 int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
197 int transfer_len, struct devrequest *setup); 186 int transfer_len, struct devrequest *setup);
198 int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, 187 int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
199 int transfer_len, int interval); 188 int transfer_len, int interval);
200 189
201 #if defined CONFIG_USB_EHCI || defined CONFIG_MUSB_HOST || defined(CONFIG_DM_USB) 190 #if defined CONFIG_USB_EHCI || defined CONFIG_MUSB_HOST || defined(CONFIG_DM_USB)
202 struct int_queue *create_int_queue(struct usb_device *dev, unsigned long pipe, 191 struct int_queue *create_int_queue(struct usb_device *dev, unsigned long pipe,
203 int queuesize, int elementsize, void *buffer, int interval); 192 int queuesize, int elementsize, void *buffer, int interval);
204 int destroy_int_queue(struct usb_device *dev, struct int_queue *queue); 193 int destroy_int_queue(struct usb_device *dev, struct int_queue *queue);
205 void *poll_int_queue(struct usb_device *dev, struct int_queue *queue); 194 void *poll_int_queue(struct usb_device *dev, struct int_queue *queue);
206 #endif 195 #endif
207 196
208 /* Defines */ 197 /* Defines */
209 #define USB_UHCI_VEND_ID 0x8086 198 #define USB_UHCI_VEND_ID 0x8086
210 #define USB_UHCI_DEV_ID 0x7112 199 #define USB_UHCI_DEV_ID 0x7112
211 200
212 /* 201 /*
213 * PXA25x can only act as USB device. There are drivers 202 * PXA25x can only act as USB device. There are drivers
214 * which works with USB CDC gadgets implementations. 203 * which works with USB CDC gadgets implementations.
215 * Some of them have common routines which can be used 204 * Some of them have common routines which can be used
216 * in boards init functions e.g. udc_disconnect() used for 205 * in boards init functions e.g. udc_disconnect() used for
217 * forced device disconnection from host. 206 * forced device disconnection from host.
218 */ 207 */
219 #elif defined(CONFIG_USB_GADGET_PXA2XX)
220
221 extern void udc_disconnect(void); 208 extern void udc_disconnect(void);
222
223 #endif
224 209
225 /* 210 /*
226 * board-specific hardware initialization, called by 211 * board-specific hardware initialization, called by
227 * usb drivers and u-boot commands 212 * usb drivers and u-boot commands
228 * 213 *
229 * @param index USB controller number 214 * @param index USB controller number
230 * @param init initializes controller as USB host or device 215 * @param init initializes controller as USB host or device
231 */ 216 */
232 int board_usb_init(int index, enum usb_init_type init); 217 int board_usb_init(int index, enum usb_init_type init);
233 218
234 /* 219 /*
235 * can be used to clean up after failed USB initialization attempt 220 * can be used to clean up after failed USB initialization attempt
236 * vide: board_usb_init() 221 * vide: board_usb_init()
237 * 222 *
238 * @param index USB controller number for selective cleanup 223 * @param index USB controller number for selective cleanup
239 * @param init usb_init_type passed to board_usb_init() 224 * @param init usb_init_type passed to board_usb_init()
240 */ 225 */
241 int board_usb_cleanup(int index, enum usb_init_type init); 226 int board_usb_cleanup(int index, enum usb_init_type init);
242 227
243 #ifdef CONFIG_USB_STORAGE 228 #ifdef CONFIG_USB_STORAGE
244 229
245 #define USB_MAX_STOR_DEV 5 230 #define USB_MAX_STOR_DEV 5
246 block_dev_desc_t *usb_stor_get_dev(int index); 231 block_dev_desc_t *usb_stor_get_dev(int index);
247 int usb_stor_scan(int mode); 232 int usb_stor_scan(int mode);
248 int usb_stor_info(void); 233 int usb_stor_info(void);
249 234
250 #endif 235 #endif
251 236
252 #ifdef CONFIG_USB_HOST_ETHER 237 #ifdef CONFIG_USB_HOST_ETHER
253 238
254 #define USB_MAX_ETH_DEV 5 239 #define USB_MAX_ETH_DEV 5
255 int usb_host_eth_scan(int mode); 240 int usb_host_eth_scan(int mode);
256 241
257 #endif 242 #endif
258 243
259 #ifdef CONFIG_USB_KEYBOARD 244 #ifdef CONFIG_USB_KEYBOARD
260 245
261 int drv_usb_kbd_init(void); 246 int drv_usb_kbd_init(void);
262 int usb_kbd_deregister(int force); 247 int usb_kbd_deregister(int force);
263 248
264 #endif 249 #endif
265 /* routines */ 250 /* routines */
266 int usb_init(void); /* initialize the USB Controller */ 251 int usb_init(void); /* initialize the USB Controller */
267 int usb_stop(void); /* stop the USB Controller */ 252 int usb_stop(void); /* stop the USB Controller */
268 int usb_detect_change(void); /* detect if a USB device has been (un)plugged */ 253 int usb_detect_change(void); /* detect if a USB device has been (un)plugged */
269 254
270 255
271 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol); 256 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol);
272 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, 257 int usb_set_idle(struct usb_device *dev, int ifnum, int duration,
273 int report_id); 258 int report_id);
274 int usb_control_msg(struct usb_device *dev, unsigned int pipe, 259 int usb_control_msg(struct usb_device *dev, unsigned int pipe,
275 unsigned char request, unsigned char requesttype, 260 unsigned char request, unsigned char requesttype,
276 unsigned short value, unsigned short index, 261 unsigned short value, unsigned short index,
277 void *data, unsigned short size, int timeout); 262 void *data, unsigned short size, int timeout);
278 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, 263 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
279 void *data, int len, int *actual_length, int timeout); 264 void *data, int len, int *actual_length, int timeout);
280 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, 265 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
281 void *buffer, int transfer_len, int interval); 266 void *buffer, int transfer_len, int interval);
282 int usb_disable_asynch(int disable); 267 int usb_disable_asynch(int disable);
283 int usb_maxpacket(struct usb_device *dev, unsigned long pipe); 268 int usb_maxpacket(struct usb_device *dev, unsigned long pipe);
284 int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer, 269 int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer,
285 int cfgno); 270 int cfgno);
286 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, 271 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
287 unsigned char id, void *buf, int size); 272 unsigned char id, void *buf, int size);
288 int usb_get_class_descriptor(struct usb_device *dev, int ifnum, 273 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
289 unsigned char type, unsigned char id, void *buf, 274 unsigned char type, unsigned char id, void *buf,
290 int size); 275 int size);
291 int usb_clear_halt(struct usb_device *dev, int pipe); 276 int usb_clear_halt(struct usb_device *dev, int pipe);
292 int usb_string(struct usb_device *dev, int index, char *buf, size_t size); 277 int usb_string(struct usb_device *dev, int index, char *buf, size_t size);
293 int usb_set_interface(struct usb_device *dev, int interface, int alternate); 278 int usb_set_interface(struct usb_device *dev, int interface, int alternate);
294 int usb_get_port_status(struct usb_device *dev, int port, void *data); 279 int usb_get_port_status(struct usb_device *dev, int port, void *data);
295 280
296 /* big endian -> little endian conversion */ 281 /* big endian -> little endian conversion */
297 /* some CPUs are already little endian e.g. the ARM920T */ 282 /* some CPUs are already little endian e.g. the ARM920T */
298 #define __swap_16(x) \ 283 #define __swap_16(x) \
299 ({ unsigned short x_ = (unsigned short)x; \ 284 ({ unsigned short x_ = (unsigned short)x; \
300 (unsigned short)( \ 285 (unsigned short)( \
301 ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \ 286 ((x_ & 0x00FFU) << 8) | ((x_ & 0xFF00U) >> 8)); \
302 }) 287 })
303 #define __swap_32(x) \ 288 #define __swap_32(x) \
304 ({ unsigned long x_ = (unsigned long)x; \ 289 ({ unsigned long x_ = (unsigned long)x; \
305 (unsigned long)( \ 290 (unsigned long)( \
306 ((x_ & 0x000000FFUL) << 24) | \ 291 ((x_ & 0x000000FFUL) << 24) | \
307 ((x_ & 0x0000FF00UL) << 8) | \ 292 ((x_ & 0x0000FF00UL) << 8) | \
308 ((x_ & 0x00FF0000UL) >> 8) | \ 293 ((x_ & 0x00FF0000UL) >> 8) | \
309 ((x_ & 0xFF000000UL) >> 24)); \ 294 ((x_ & 0xFF000000UL) >> 24)); \
310 }) 295 })
311 296
312 #ifdef __LITTLE_ENDIAN 297 #ifdef __LITTLE_ENDIAN
313 # define swap_16(x) (x) 298 # define swap_16(x) (x)
314 # define swap_32(x) (x) 299 # define swap_32(x) (x)
315 #else 300 #else
316 # define swap_16(x) __swap_16(x) 301 # define swap_16(x) __swap_16(x)
317 # define swap_32(x) __swap_32(x) 302 # define swap_32(x) __swap_32(x)
318 #endif 303 #endif
319 304
320 /* 305 /*
321 * Calling this entity a "pipe" is glorifying it. A USB pipe 306 * Calling this entity a "pipe" is glorifying it. A USB pipe
322 * is something embarrassingly simple: it basically consists 307 * is something embarrassingly simple: it basically consists
323 * of the following information: 308 * of the following information:
324 * - device number (7 bits) 309 * - device number (7 bits)
325 * - endpoint number (4 bits) 310 * - endpoint number (4 bits)
326 * - current Data0/1 state (1 bit) 311 * - current Data0/1 state (1 bit)
327 * - direction (1 bit) 312 * - direction (1 bit)
328 * - speed (2 bits) 313 * - speed (2 bits)
329 * - max packet size (2 bits: 8, 16, 32 or 64) 314 * - max packet size (2 bits: 8, 16, 32 or 64)
330 * - pipe type (2 bits: control, interrupt, bulk, isochronous) 315 * - pipe type (2 bits: control, interrupt, bulk, isochronous)
331 * 316 *
332 * That's 18 bits. Really. Nothing more. And the USB people have 317 * That's 18 bits. Really. Nothing more. And the USB people have
333 * documented these eighteen bits as some kind of glorious 318 * documented these eighteen bits as some kind of glorious
334 * virtual data structure. 319 * virtual data structure.
335 * 320 *
336 * Let's not fall in that trap. We'll just encode it as a simple 321 * Let's not fall in that trap. We'll just encode it as a simple
337 * unsigned int. The encoding is: 322 * unsigned int. The encoding is:
338 * 323 *
339 * - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64) 324 * - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64)
340 * - direction: bit 7 (0 = Host-to-Device [Out], 325 * - direction: bit 7 (0 = Host-to-Device [Out],
341 * (1 = Device-to-Host [In]) 326 * (1 = Device-to-Host [In])
342 * - device: bits 8-14 327 * - device: bits 8-14
343 * - endpoint: bits 15-18 328 * - endpoint: bits 15-18
344 * - Data0/1: bit 19 329 * - Data0/1: bit 19
345 * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt, 330 * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,
346 * 10 = control, 11 = bulk) 331 * 10 = control, 11 = bulk)
347 * 332 *
348 * Why? Because it's arbitrary, and whatever encoding we select is really 333 * Why? Because it's arbitrary, and whatever encoding we select is really
349 * up to us. This one happens to share a lot of bit positions with the UHCI 334 * up to us. This one happens to share a lot of bit positions with the UHCI
350 * specification, so that much of the uhci driver can just mask the bits 335 * specification, so that much of the uhci driver can just mask the bits
351 * appropriately. 336 * appropriately.
352 */ 337 */
353 /* Create various pipes... */ 338 /* Create various pipes... */
354 #define create_pipe(dev,endpoint) \ 339 #define create_pipe(dev,endpoint) \
355 (((dev)->devnum << 8) | ((endpoint) << 15) | \ 340 (((dev)->devnum << 8) | ((endpoint) << 15) | \
356 (dev)->maxpacketsize) 341 (dev)->maxpacketsize)
357 #define default_pipe(dev) ((dev)->speed << 26) 342 #define default_pipe(dev) ((dev)->speed << 26)
358 343
359 #define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ 344 #define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \
360 create_pipe(dev, endpoint)) 345 create_pipe(dev, endpoint))
361 #define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ 346 #define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \
362 create_pipe(dev, endpoint) | \ 347 create_pipe(dev, endpoint) | \
363 USB_DIR_IN) 348 USB_DIR_IN)
364 #define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ 349 #define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \
365 create_pipe(dev, endpoint)) 350 create_pipe(dev, endpoint))
366 #define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ 351 #define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \
367 create_pipe(dev, endpoint) | \ 352 create_pipe(dev, endpoint) | \
368 USB_DIR_IN) 353 USB_DIR_IN)
369 #define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ 354 #define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \
370 create_pipe(dev, endpoint)) 355 create_pipe(dev, endpoint))
371 #define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ 356 #define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \
372 create_pipe(dev, endpoint) | \ 357 create_pipe(dev, endpoint) | \
373 USB_DIR_IN) 358 USB_DIR_IN)
374 #define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ 359 #define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \
375 create_pipe(dev, endpoint)) 360 create_pipe(dev, endpoint))
376 #define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ 361 #define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \
377 create_pipe(dev, endpoint) | \ 362 create_pipe(dev, endpoint) | \
378 USB_DIR_IN) 363 USB_DIR_IN)
379 #define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \ 364 #define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \
380 default_pipe(dev)) 365 default_pipe(dev))
381 #define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \ 366 #define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \
382 default_pipe(dev) | \ 367 default_pipe(dev) | \
383 USB_DIR_IN) 368 USB_DIR_IN)
384 369
385 /* The D0/D1 toggle bits */ 370 /* The D0/D1 toggle bits */
386 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1) 371 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1)
387 #define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep)) 372 #define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep))
388 #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \ 373 #define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \
389 ((dev)->toggle[out] & \ 374 ((dev)->toggle[out] & \
390 ~(1 << ep)) | ((bit) << ep)) 375 ~(1 << ep)) | ((bit) << ep))
391 376
392 /* Endpoint halt control/status */ 377 /* Endpoint halt control/status */
393 #define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1) 378 #define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1)
394 #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep))) 379 #define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] |= (1 << (ep)))
395 #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep))) 380 #define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep)))
396 #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep))) 381 #define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep)))
397 382
398 #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \ 383 #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \
399 USB_PID_OUT) 384 USB_PID_OUT)
400 385
401 #define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1) 386 #define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1)
402 #define usb_pipein(pipe) (((pipe) >> 7) & 1) 387 #define usb_pipein(pipe) (((pipe) >> 7) & 1)
403 #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f) 388 #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f)
404 #define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff) 389 #define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff)
405 #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf) 390 #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf)
406 #define usb_pipedata(pipe) (((pipe) >> 19) & 1) 391 #define usb_pipedata(pipe) (((pipe) >> 19) & 1)
407 #define usb_pipetype(pipe) (((pipe) >> 30) & 3) 392 #define usb_pipetype(pipe) (((pipe) >> 30) & 3)
408 #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS) 393 #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
409 #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT) 394 #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT)
410 #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL) 395 #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL)
411 #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK) 396 #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK)
412 397
413 #define usb_pipe_ep_index(pipe) \ 398 #define usb_pipe_ep_index(pipe) \
414 usb_pipecontrol(pipe) ? (usb_pipeendpoint(pipe) * 2) : \ 399 usb_pipecontrol(pipe) ? (usb_pipeendpoint(pipe) * 2) : \
415 ((usb_pipeendpoint(pipe) * 2) - \ 400 ((usb_pipeendpoint(pipe) * 2) - \
416 (usb_pipein(pipe) ? 0 : 1)) 401 (usb_pipein(pipe) ? 0 : 1))
417 402
418 /** 403 /**
419 * struct usb_device_id - identifies USB devices for probing and hotplugging 404 * struct usb_device_id - identifies USB devices for probing and hotplugging
420 * @match_flags: Bit mask controlling which of the other fields are used to 405 * @match_flags: Bit mask controlling which of the other fields are used to
421 * match against new devices. Any field except for driver_info may be 406 * match against new devices. Any field except for driver_info may be
422 * used, although some only make sense in conjunction with other fields. 407 * used, although some only make sense in conjunction with other fields.
423 * This is usually set by a USB_DEVICE_*() macro, which sets all 408 * This is usually set by a USB_DEVICE_*() macro, which sets all
424 * other fields in this structure except for driver_info. 409 * other fields in this structure except for driver_info.
425 * @idVendor: USB vendor ID for a device; numbers are assigned 410 * @idVendor: USB vendor ID for a device; numbers are assigned
426 * by the USB forum to its members. 411 * by the USB forum to its members.
427 * @idProduct: Vendor-assigned product ID. 412 * @idProduct: Vendor-assigned product ID.
428 * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers. 413 * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers.
429 * This is also used to identify individual product versions, for 414 * This is also used to identify individual product versions, for
430 * a range consisting of a single device. 415 * a range consisting of a single device.
431 * @bcdDevice_hi: High end of version number range. The range of product 416 * @bcdDevice_hi: High end of version number range. The range of product
432 * versions is inclusive. 417 * versions is inclusive.
433 * @bDeviceClass: Class of device; numbers are assigned 418 * @bDeviceClass: Class of device; numbers are assigned
434 * by the USB forum. Products may choose to implement classes, 419 * by the USB forum. Products may choose to implement classes,
435 * or be vendor-specific. Device classes specify behavior of all 420 * or be vendor-specific. Device classes specify behavior of all
436 * the interfaces on a device. 421 * the interfaces on a device.
437 * @bDeviceSubClass: Subclass of device; associated with bDeviceClass. 422 * @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
438 * @bDeviceProtocol: Protocol of device; associated with bDeviceClass. 423 * @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
439 * @bInterfaceClass: Class of interface; numbers are assigned 424 * @bInterfaceClass: Class of interface; numbers are assigned
440 * by the USB forum. Products may choose to implement classes, 425 * by the USB forum. Products may choose to implement classes,
441 * or be vendor-specific. Interface classes specify behavior only 426 * or be vendor-specific. Interface classes specify behavior only
442 * of a given interface; other interfaces may support other classes. 427 * of a given interface; other interfaces may support other classes.
443 * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass. 428 * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass.
444 * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass. 429 * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass.
445 * @bInterfaceNumber: Number of interface; composite devices may use 430 * @bInterfaceNumber: Number of interface; composite devices may use
446 * fixed interface numbers to differentiate between vendor-specific 431 * fixed interface numbers to differentiate between vendor-specific
447 * interfaces. 432 * interfaces.
448 * @driver_info: Holds information used by the driver. Usually it holds 433 * @driver_info: Holds information used by the driver. Usually it holds
449 * a pointer to a descriptor understood by the driver, or perhaps 434 * a pointer to a descriptor understood by the driver, or perhaps
450 * device flags. 435 * device flags.
451 * 436 *
452 * In most cases, drivers will create a table of device IDs by using 437 * In most cases, drivers will create a table of device IDs by using
453 * USB_DEVICE(), or similar macros designed for that purpose. 438 * USB_DEVICE(), or similar macros designed for that purpose.
454 * They will then export it to userspace using MODULE_DEVICE_TABLE(), 439 * They will then export it to userspace using MODULE_DEVICE_TABLE(),
455 * and provide it to the USB core through their usb_driver structure. 440 * and provide it to the USB core through their usb_driver structure.
456 * 441 *
457 * See the usb_match_id() function for information about how matches are 442 * See the usb_match_id() function for information about how matches are
458 * performed. Briefly, you will normally use one of several macros to help 443 * performed. Briefly, you will normally use one of several macros to help
459 * construct these entries. Each entry you provide will either identify 444 * construct these entries. Each entry you provide will either identify
460 * one or more specific products, or will identify a class of products 445 * one or more specific products, or will identify a class of products
461 * which have agreed to behave the same. You should put the more specific 446 * which have agreed to behave the same. You should put the more specific
462 * matches towards the beginning of your table, so that driver_info can 447 * matches towards the beginning of your table, so that driver_info can
463 * record quirks of specific products. 448 * record quirks of specific products.
464 */ 449 */
465 struct usb_device_id { 450 struct usb_device_id {
466 /* which fields to match against? */ 451 /* which fields to match against? */
467 u16 match_flags; 452 u16 match_flags;
468 453
469 /* Used for product specific matches; range is inclusive */ 454 /* Used for product specific matches; range is inclusive */
470 u16 idVendor; 455 u16 idVendor;
471 u16 idProduct; 456 u16 idProduct;
472 u16 bcdDevice_lo; 457 u16 bcdDevice_lo;
473 u16 bcdDevice_hi; 458 u16 bcdDevice_hi;
474 459
475 /* Used for device class matches */ 460 /* Used for device class matches */
476 u8 bDeviceClass; 461 u8 bDeviceClass;
477 u8 bDeviceSubClass; 462 u8 bDeviceSubClass;
478 u8 bDeviceProtocol; 463 u8 bDeviceProtocol;
479 464
480 /* Used for interface class matches */ 465 /* Used for interface class matches */
481 u8 bInterfaceClass; 466 u8 bInterfaceClass;
482 u8 bInterfaceSubClass; 467 u8 bInterfaceSubClass;
483 u8 bInterfaceProtocol; 468 u8 bInterfaceProtocol;
484 469
485 /* Used for vendor-specific interface matches */ 470 /* Used for vendor-specific interface matches */
486 u8 bInterfaceNumber; 471 u8 bInterfaceNumber;
487 472
488 /* not matched against */ 473 /* not matched against */
489 ulong driver_info; 474 ulong driver_info;
490 }; 475 };
491 476
492 /* Some useful macros to use to create struct usb_device_id */ 477 /* Some useful macros to use to create struct usb_device_id */
493 #define USB_DEVICE_ID_MATCH_VENDOR 0x0001 478 #define USB_DEVICE_ID_MATCH_VENDOR 0x0001
494 #define USB_DEVICE_ID_MATCH_PRODUCT 0x0002 479 #define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
495 #define USB_DEVICE_ID_MATCH_DEV_LO 0x0004 480 #define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
496 #define USB_DEVICE_ID_MATCH_DEV_HI 0x0008 481 #define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
497 #define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010 482 #define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
498 #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020 483 #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
499 #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040 484 #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
500 #define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080 485 #define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
501 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100 486 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
502 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200 487 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
503 #define USB_DEVICE_ID_MATCH_INT_NUMBER 0x0400 488 #define USB_DEVICE_ID_MATCH_INT_NUMBER 0x0400
504 489
505 /* Match anything, indicates this is a valid entry even if everything is 0 */ 490 /* Match anything, indicates this is a valid entry even if everything is 0 */
506 #define USB_DEVICE_ID_MATCH_NONE 0x0800 491 #define USB_DEVICE_ID_MATCH_NONE 0x0800
507 #define USB_DEVICE_ID_MATCH_ALL 0x07ff 492 #define USB_DEVICE_ID_MATCH_ALL 0x07ff
508 493
509 /** 494 /**
510 * struct usb_driver_entry - Matches a driver to its usb_device_ids 495 * struct usb_driver_entry - Matches a driver to its usb_device_ids
511 * @compatible: Compatible string 496 * @compatible: Compatible string
512 * @data: Data for this compatible string 497 * @data: Data for this compatible string
513 */ 498 */
514 struct usb_driver_entry { 499 struct usb_driver_entry {
515 struct driver *driver; 500 struct driver *driver;
516 const struct usb_device_id *match; 501 const struct usb_device_id *match;
517 }; 502 };
518 503
519 #define USB_DEVICE(__name, __match) \ 504 #define USB_DEVICE(__name, __match) \
520 ll_entry_declare(struct usb_driver_entry, __name, usb_driver_entry) = {\ 505 ll_entry_declare(struct usb_driver_entry, __name, usb_driver_entry) = {\
521 .driver = llsym(struct driver, __name, driver), \ 506 .driver = llsym(struct driver, __name, driver), \
522 .match = __match, \ 507 .match = __match, \
523 } 508 }
524 509
525 /************************************************************************* 510 /*************************************************************************
526 * Hub Stuff 511 * Hub Stuff
527 */ 512 */
528 struct usb_port_status { 513 struct usb_port_status {
529 unsigned short wPortStatus; 514 unsigned short wPortStatus;
530 unsigned short wPortChange; 515 unsigned short wPortChange;
531 } __attribute__ ((packed)); 516 } __attribute__ ((packed));
532 517
533 struct usb_hub_status { 518 struct usb_hub_status {
534 unsigned short wHubStatus; 519 unsigned short wHubStatus;
535 unsigned short wHubChange; 520 unsigned short wHubChange;
536 } __attribute__ ((packed)); 521 } __attribute__ ((packed));
537 522
538 523
539 /* Hub descriptor */ 524 /* Hub descriptor */
540 struct usb_hub_descriptor { 525 struct usb_hub_descriptor {
541 unsigned char bLength; 526 unsigned char bLength;
542 unsigned char bDescriptorType; 527 unsigned char bDescriptorType;
543 unsigned char bNbrPorts; 528 unsigned char bNbrPorts;
544 unsigned short wHubCharacteristics; 529 unsigned short wHubCharacteristics;
545 unsigned char bPwrOn2PwrGood; 530 unsigned char bPwrOn2PwrGood;
546 unsigned char bHubContrCurrent; 531 unsigned char bHubContrCurrent;
547 unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8]; 532 unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8];
548 unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8]; 533 unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8];
549 /* DeviceRemovable and PortPwrCtrlMask want to be variable-length 534 /* DeviceRemovable and PortPwrCtrlMask want to be variable-length
550 bitmaps that hold max 255 entries. (bit0 is ignored) */ 535 bitmaps that hold max 255 entries. (bit0 is ignored) */
551 } __attribute__ ((packed)); 536 } __attribute__ ((packed));
552 537
553 538
554 struct usb_hub_device { 539 struct usb_hub_device {
555 struct usb_device *pusb_dev; 540 struct usb_device *pusb_dev;
556 struct usb_hub_descriptor desc; 541 struct usb_hub_descriptor desc;
557 }; 542 };
558 543
559 #ifdef CONFIG_DM_USB 544 #ifdef CONFIG_DM_USB
560 /** 545 /**
561 * struct usb_platdata - Platform data about a USB controller 546 * struct usb_platdata - Platform data about a USB controller
562 * 547 *
563 * Given a USB controller (UCLASS_USB) dev this is dev_get_platdata(dev) 548 * Given a USB controller (UCLASS_USB) dev this is dev_get_platdata(dev)
564 */ 549 */
565 struct usb_platdata { 550 struct usb_platdata {
566 enum usb_init_type init_type; 551 enum usb_init_type init_type;
567 }; 552 };
568 553
569 /** 554 /**
570 * struct usb_dev_platdata - Platform data about a USB device 555 * struct usb_dev_platdata - Platform data about a USB device
571 * 556 *
572 * Given a USB device dev this structure is dev_get_parent_platdata(dev). 557 * Given a USB device dev this structure is dev_get_parent_platdata(dev).
573 * This is used by sandbox to provide emulation data also. 558 * This is used by sandbox to provide emulation data also.
574 * 559 *
575 * @id: ID used to match this device 560 * @id: ID used to match this device
576 * @devnum: Device address on the USB bus 561 * @devnum: Device address on the USB bus
577 * @udev: usb-uclass internal use only do NOT use 562 * @udev: usb-uclass internal use only do NOT use
578 * @strings: List of descriptor strings (for sandbox emulation purposes) 563 * @strings: List of descriptor strings (for sandbox emulation purposes)
579 * @desc_list: List of descriptors (for sandbox emulation purposes) 564 * @desc_list: List of descriptors (for sandbox emulation purposes)
580 */ 565 */
581 struct usb_dev_platdata { 566 struct usb_dev_platdata {
582 struct usb_device_id id; 567 struct usb_device_id id;
583 int devnum; 568 int devnum;
584 /* 569 /*
585 * This pointer is used to pass the usb_device used in usb_scan_device, 570 * This pointer is used to pass the usb_device used in usb_scan_device,
586 * to get the usb descriptors before the driver is known, to the 571 * to get the usb descriptors before the driver is known, to the
587 * actual udevice once the driver is known and the udevice is created. 572 * actual udevice once the driver is known and the udevice is created.
588 * This will be NULL except during probe, do NOT use. 573 * This will be NULL except during probe, do NOT use.
589 * 574 *
590 * This should eventually go away. 575 * This should eventually go away.
591 */ 576 */
592 struct usb_device *udev; 577 struct usb_device *udev;
593 #ifdef CONFIG_SANDBOX 578 #ifdef CONFIG_SANDBOX
594 struct usb_string *strings; 579 struct usb_string *strings;
595 /* NULL-terminated list of descriptor pointers */ 580 /* NULL-terminated list of descriptor pointers */
596 struct usb_generic_descriptor **desc_list; 581 struct usb_generic_descriptor **desc_list;
597 #endif 582 #endif
598 int configno; 583 int configno;
599 }; 584 };
600 585
601 /** 586 /**
602 * struct usb_bus_priv - information about the USB controller 587 * struct usb_bus_priv - information about the USB controller
603 * 588 *
604 * Given a USB controller (UCLASS_USB) 'dev', this is 589 * Given a USB controller (UCLASS_USB) 'dev', this is
605 * dev_get_uclass_priv(dev). 590 * dev_get_uclass_priv(dev).
606 * 591 *
607 * @next_addr: Next device address to allocate minus 1. Incremented by 1 592 * @next_addr: Next device address to allocate minus 1. Incremented by 1
608 * each time a new device address is set, so this holds the 593 * each time a new device address is set, so this holds the
609 * number of devices on the bus 594 * number of devices on the bus
610 * @desc_before_addr: true if we can read a device descriptor before it 595 * @desc_before_addr: true if we can read a device descriptor before it
611 * has been assigned an address. For XHCI this is not possible 596 * has been assigned an address. For XHCI this is not possible
612 * so this will be false. 597 * so this will be false.
613 * @companion: True if this is a companion controller to another USB 598 * @companion: True if this is a companion controller to another USB
614 * controller 599 * controller
615 */ 600 */
616 struct usb_bus_priv { 601 struct usb_bus_priv {
617 int next_addr; 602 int next_addr;
618 bool desc_before_addr; 603 bool desc_before_addr;
619 bool companion; 604 bool companion;
620 }; 605 };
621 606
622 /** 607 /**
623 * struct dm_usb_ops - USB controller operations 608 * struct dm_usb_ops - USB controller operations
624 * 609 *
625 * This defines the operations supoorted on a USB controller. Common 610 * This defines the operations supoorted on a USB controller. Common
626 * arguments are: 611 * arguments are:
627 * 612 *
628 * @bus: USB bus (i.e. controller), which is in UCLASS_USB. 613 * @bus: USB bus (i.e. controller), which is in UCLASS_USB.
629 * @udev: USB device parent data. Controllers are not expected to need 614 * @udev: USB device parent data. Controllers are not expected to need
630 * this, since the device address on the bus is encoded in @pipe. 615 * this, since the device address on the bus is encoded in @pipe.
631 * It is used for sandbox, and can be handy for debugging and 616 * It is used for sandbox, and can be handy for debugging and
632 * logging. 617 * logging.
633 * @pipe: An assortment of bitfields which provide address and packet 618 * @pipe: An assortment of bitfields which provide address and packet
634 * type information. See create_pipe() above for encoding 619 * type information. See create_pipe() above for encoding
635 * details 620 * details
636 * @buffer: A buffer to use for sending/receiving. This should be 621 * @buffer: A buffer to use for sending/receiving. This should be
637 * DMA-aligned. 622 * DMA-aligned.
638 * @length: Buffer length in bytes 623 * @length: Buffer length in bytes
639 */ 624 */
640 struct dm_usb_ops { 625 struct dm_usb_ops {
641 /** 626 /**
642 * control() - Send a control message 627 * control() - Send a control message
643 * 628 *
644 * Most parameters are as above. 629 * Most parameters are as above.
645 * 630 *
646 * @setup: Additional setup information required by the message 631 * @setup: Additional setup information required by the message
647 */ 632 */
648 int (*control)(struct udevice *bus, struct usb_device *udev, 633 int (*control)(struct udevice *bus, struct usb_device *udev,
649 unsigned long pipe, void *buffer, int length, 634 unsigned long pipe, void *buffer, int length,
650 struct devrequest *setup); 635 struct devrequest *setup);
651 /** 636 /**
652 * bulk() - Send a bulk message 637 * bulk() - Send a bulk message
653 * 638 *
654 * Parameters are as above. 639 * Parameters are as above.
655 */ 640 */
656 int (*bulk)(struct udevice *bus, struct usb_device *udev, 641 int (*bulk)(struct udevice *bus, struct usb_device *udev,
657 unsigned long pipe, void *buffer, int length); 642 unsigned long pipe, void *buffer, int length);
658 /** 643 /**
659 * interrupt() - Send an interrupt message 644 * interrupt() - Send an interrupt message
660 * 645 *
661 * Most parameters are as above. 646 * Most parameters are as above.
662 * 647 *
663 * @interval: Interrupt interval 648 * @interval: Interrupt interval
664 */ 649 */
665 int (*interrupt)(struct udevice *bus, struct usb_device *udev, 650 int (*interrupt)(struct udevice *bus, struct usb_device *udev,
666 unsigned long pipe, void *buffer, int length, 651 unsigned long pipe, void *buffer, int length,
667 int interval); 652 int interval);
668 653
669 /** 654 /**
670 * create_int_queue() - Create and queue interrupt packets 655 * create_int_queue() - Create and queue interrupt packets
671 * 656 *
672 * Create and queue @queuesize number of interrupt usb packets of 657 * Create and queue @queuesize number of interrupt usb packets of
673 * @elementsize bytes each. @buffer must be atleast @queuesize * 658 * @elementsize bytes each. @buffer must be atleast @queuesize *
674 * @elementsize bytes. 659 * @elementsize bytes.
675 * 660 *
676 * Note some controllers only support a queuesize of 1. 661 * Note some controllers only support a queuesize of 1.
677 * 662 *
678 * @interval: Interrupt interval 663 * @interval: Interrupt interval
679 * 664 *
680 * @return A pointer to the created interrupt queue or NULL on error 665 * @return A pointer to the created interrupt queue or NULL on error
681 */ 666 */
682 struct int_queue * (*create_int_queue)(struct udevice *bus, 667 struct int_queue * (*create_int_queue)(struct udevice *bus,
683 struct usb_device *udev, unsigned long pipe, 668 struct usb_device *udev, unsigned long pipe,
684 int queuesize, int elementsize, void *buffer, 669 int queuesize, int elementsize, void *buffer,
685 int interval); 670 int interval);
686 671
687 /** 672 /**
688 * poll_int_queue() - Poll an interrupt queue for completed packets 673 * poll_int_queue() - Poll an interrupt queue for completed packets
689 * 674 *
690 * Poll an interrupt queue for completed packets. The return value 675 * Poll an interrupt queue for completed packets. The return value
691 * points to the part of the buffer passed to create_int_queue() 676 * points to the part of the buffer passed to create_int_queue()
692 * corresponding to the completed packet. 677 * corresponding to the completed packet.
693 * 678 *
694 * @queue: queue to poll 679 * @queue: queue to poll
695 * 680 *
696 * @return Pointer to the data of the first completed packet, or 681 * @return Pointer to the data of the first completed packet, or
697 * NULL if no packets are ready 682 * NULL if no packets are ready
698 */ 683 */
699 void * (*poll_int_queue)(struct udevice *bus, struct usb_device *udev, 684 void * (*poll_int_queue)(struct udevice *bus, struct usb_device *udev,
700 struct int_queue *queue); 685 struct int_queue *queue);
701 686
702 /** 687 /**
703 * destroy_int_queue() - Destroy an interrupt queue 688 * destroy_int_queue() - Destroy an interrupt queue
704 * 689 *
705 * Destroy an interrupt queue created by create_int_queue(). 690 * Destroy an interrupt queue created by create_int_queue().
706 * 691 *
707 * @queue: queue to poll 692 * @queue: queue to poll
708 * 693 *
709 * @return 0 if OK, -ve on error 694 * @return 0 if OK, -ve on error
710 */ 695 */
711 int (*destroy_int_queue)(struct udevice *bus, struct usb_device *udev, 696 int (*destroy_int_queue)(struct udevice *bus, struct usb_device *udev,
712 struct int_queue *queue); 697 struct int_queue *queue);
713 698
714 /** 699 /**
715 * alloc_device() - Allocate a new device context (XHCI) 700 * alloc_device() - Allocate a new device context (XHCI)
716 * 701 *
717 * Before sending packets to a new device on an XHCI bus, a device 702 * Before sending packets to a new device on an XHCI bus, a device
718 * context must be created. If this method is not NULL it will be 703 * context must be created. If this method is not NULL it will be
719 * called before the device is enumerated (even before its descriptor 704 * called before the device is enumerated (even before its descriptor
720 * is read). This should be NULL for EHCI, which does not need this. 705 * is read). This should be NULL for EHCI, which does not need this.
721 */ 706 */
722 int (*alloc_device)(struct udevice *bus, struct usb_device *udev); 707 int (*alloc_device)(struct udevice *bus, struct usb_device *udev);
723 }; 708 };
724 709
725 #define usb_get_ops(dev) ((struct dm_usb_ops *)(dev)->driver->ops) 710 #define usb_get_ops(dev) ((struct dm_usb_ops *)(dev)->driver->ops)
726 #define usb_get_emul_ops(dev) ((struct dm_usb_ops *)(dev)->driver->ops) 711 #define usb_get_emul_ops(dev) ((struct dm_usb_ops *)(dev)->driver->ops)
727 712
728 #ifdef CONFIG_MUSB_HOST 713 #ifdef CONFIG_MUSB_HOST
729 int usb_reset_root_port(void); 714 int usb_reset_root_port(void);
730 #endif 715 #endif
731 716
732 /** 717 /**
733 * usb_get_dev_index() - look up a device index number 718 * usb_get_dev_index() - look up a device index number
734 * 719 *
735 * Look up devices using their index number (starting at 0). This works since 720 * Look up devices using their index number (starting at 0). This works since
736 * in U-Boot device addresses are allocated starting at 1 with no gaps. 721 * in U-Boot device addresses are allocated starting at 1 with no gaps.
737 * 722 *
738 * TODO(sjg@chromium.org): Remove this function when usb_ether.c is modified 723 * TODO(sjg@chromium.org): Remove this function when usb_ether.c is modified
739 * to work better with driver model. 724 * to work better with driver model.
740 * 725 *
741 * @bus: USB bus to check 726 * @bus: USB bus to check
742 * @index: Index number of device to find (0=first). This is just the 727 * @index: Index number of device to find (0=first). This is just the
743 * device address less 1. 728 * device address less 1.
744 */ 729 */
745 struct usb_device *usb_get_dev_index(struct udevice *bus, int index); 730 struct usb_device *usb_get_dev_index(struct udevice *bus, int index);
746 731
747 /** 732 /**
748 * usb_legacy_port_reset() - Legacy function to reset a hub port 733 * usb_legacy_port_reset() - Legacy function to reset a hub port
749 * 734 *
750 * @hub: Hub device 735 * @hub: Hub device
751 * @portnr: Port number (1=first) 736 * @portnr: Port number (1=first)
752 */ 737 */
753 int usb_legacy_port_reset(struct usb_device *hub, int portnr); 738 int usb_legacy_port_reset(struct usb_device *hub, int portnr);
754 739
755 /** 740 /**
756 * usb_setup_device() - set up a device ready for use 741 * usb_setup_device() - set up a device ready for use
757 * 742 *
758 * @dev: USB device pointer. This need not be a real device - it is 743 * @dev: USB device pointer. This need not be a real device - it is
759 * common for it to just be a local variable with its ->dev 744 * common for it to just be a local variable with its ->dev
760 * member (i.e. @dev->dev) set to the parent device 745 * member (i.e. @dev->dev) set to the parent device
761 * @do_read: true to read the device descriptor before an address is set 746 * @do_read: true to read the device descriptor before an address is set
762 * (should be false for XHCI buses, true otherwise) 747 * (should be false for XHCI buses, true otherwise)
763 * @parent: Parent device (either UCLASS_USB or UCLASS_USB_HUB) 748 * @parent: Parent device (either UCLASS_USB or UCLASS_USB_HUB)
764 * @portnr: Port number on hub (1=first) or 0 for none 749 * @portnr: Port number on hub (1=first) or 0 for none
765 * @return 0 if OK, -ve on error */ 750 * @return 0 if OK, -ve on error */
766 int usb_setup_device(struct usb_device *dev, bool do_read, 751 int usb_setup_device(struct usb_device *dev, bool do_read,
767 struct usb_device *parent, int portnr); 752 struct usb_device *parent, int portnr);
768 753
769 /** 754 /**
770 * usb_hub_scan() - Scan a hub and find its devices 755 * usb_hub_scan() - Scan a hub and find its devices
771 * 756 *
772 * @hub: Hub device to scan 757 * @hub: Hub device to scan
773 */ 758 */
774 int usb_hub_scan(struct udevice *hub); 759 int usb_hub_scan(struct udevice *hub);
775 760
776 /** 761 /**
777 * usb_scan_device() - Scan a device on a bus 762 * usb_scan_device() - Scan a device on a bus
778 * 763 *
779 * Scan a device on a bus. It has already been detected and is ready to 764 * Scan a device on a bus. It has already been detected and is ready to
780 * be enumerated. This may be either the root hub (@parent is a bus) or a 765 * be enumerated. This may be either the root hub (@parent is a bus) or a
781 * normal device (@parent is a hub) 766 * normal device (@parent is a hub)
782 * 767 *
783 * @parent: Parent device 768 * @parent: Parent device
784 * @port: Hub port number (numbered from 1) 769 * @port: Hub port number (numbered from 1)
785 * @speed: USB speed to use for this device 770 * @speed: USB speed to use for this device
786 * @devp: Returns pointer to device if all is well 771 * @devp: Returns pointer to device if all is well
787 * @return 0 if OK, -ve on error 772 * @return 0 if OK, -ve on error
788 */ 773 */
789 int usb_scan_device(struct udevice *parent, int port, 774 int usb_scan_device(struct udevice *parent, int port,
790 enum usb_device_speed speed, struct udevice **devp); 775 enum usb_device_speed speed, struct udevice **devp);
791 776
792 /** 777 /**
793 * usb_get_bus() - Find the bus for a device 778 * usb_get_bus() - Find the bus for a device
794 * 779 *
795 * Search up through parents to find the bus this device is connected to. This 780 * Search up through parents to find the bus this device is connected to. This
796 * will be a device with uclass UCLASS_USB. 781 * will be a device with uclass UCLASS_USB.
797 * 782 *
798 * @dev: Device to check 783 * @dev: Device to check
799 * @return The bus, or NULL if not found (this indicates a critical error in 784 * @return The bus, or NULL if not found (this indicates a critical error in
800 * the USB stack 785 * the USB stack
801 */ 786 */
802 struct udevice *usb_get_bus(struct udevice *dev); 787 struct udevice *usb_get_bus(struct udevice *dev);
803 788
804 /** 789 /**
805 * usb_select_config() - Set up a device ready for use 790 * usb_select_config() - Set up a device ready for use
806 * 791 *
807 * This function assumes that the device already has an address and a driver 792 * This function assumes that the device already has an address and a driver
808 * bound, and is ready to be set up. 793 * bound, and is ready to be set up.
809 * 794 *
810 * This re-reads the device and configuration descriptors and sets the 795 * This re-reads the device and configuration descriptors and sets the
811 * configuration 796 * configuration
812 * 797 *
813 * @dev: Device to set up 798 * @dev: Device to set up
814 */ 799 */
815 int usb_select_config(struct usb_device *dev); 800 int usb_select_config(struct usb_device *dev);
816 801
817 /** 802 /**
818 * usb_child_pre_probe() - Pre-probe function for USB devices 803 * usb_child_pre_probe() - Pre-probe function for USB devices
819 * 804 *
820 * This is called on all children of hubs and USB controllers (i.e. UCLASS_USB 805 * This is called on all children of hubs and USB controllers (i.e. UCLASS_USB
821 * and UCLASS_USB_HUB) when a new device is about to be probed. It sets up the 806 * and UCLASS_USB_HUB) when a new device is about to be probed. It sets up the
822 * device from the saved platform data and calls usb_select_config() to 807 * device from the saved platform data and calls usb_select_config() to
823 * finish set up. 808 * finish set up.
824 * 809 *
825 * Once this is done, the device's normal driver can take over, knowing the 810 * Once this is done, the device's normal driver can take over, knowing the
826 * device is accessible on the USB bus. 811 * device is accessible on the USB bus.
827 * 812 *
828 * This function is for use only by the internal USB stack. 813 * This function is for use only by the internal USB stack.
829 * 814 *
830 * @dev: Device to set up 815 * @dev: Device to set up
831 */ 816 */
832 int usb_child_pre_probe(struct udevice *dev); 817 int usb_child_pre_probe(struct udevice *dev);
833 818
834 struct ehci_ctrl; 819 struct ehci_ctrl;
835 820
836 /** 821 /**
837 * usb_setup_ehci_gadget() - Set up a USB device as a gadget 822 * usb_setup_ehci_gadget() - Set up a USB device as a gadget
838 * 823 *
839 * TODO(sjg@chromium.org): Tidy this up when USB gadgets can use driver model 824 * TODO(sjg@chromium.org): Tidy this up when USB gadgets can use driver model
840 * 825 *
841 * This provides a way to tell a controller to start up as a USB device 826 * This provides a way to tell a controller to start up as a USB device
842 * instead of as a host. It is untested. 827 * instead of as a host. It is untested.
843 */ 828 */
844 int usb_setup_ehci_gadget(struct ehci_ctrl **ctlrp); 829 int usb_setup_ehci_gadget(struct ehci_ctrl **ctlrp);
845 830
846 /** 831 /**
847 * usb_stor_reset() - Prepare to scan USB storage devices 832 * usb_stor_reset() - Prepare to scan USB storage devices
848 * 833 *
849 * Empty the list of USB storage devices in preparation for scanning them. 834 * Empty the list of USB storage devices in preparation for scanning them.
850 * This must be called before a USB scan. 835 * This must be called before a USB scan.
851 */ 836 */
852 void usb_stor_reset(void); 837 void usb_stor_reset(void);
853 838
854 #else /* !CONFIG_DM_USB */ 839 #else /* !CONFIG_DM_USB */
855 840
856 struct usb_device *usb_get_dev_index(int index); 841 struct usb_device *usb_get_dev_index(int index);
857 842
858 #endif 843 #endif
859 844
860 bool usb_device_has_child_on_port(struct usb_device *parent, int port); 845 bool usb_device_has_child_on_port(struct usb_device *parent, int port);
861 846
862 int usb_hub_probe(struct usb_device *dev, int ifnum); 847 int usb_hub_probe(struct usb_device *dev, int ifnum);
863 void usb_hub_reset(void); 848 void usb_hub_reset(void);
864 849
865 /** 850 /**
866 * legacy_hub_port_reset() - reset a port given its usb_device pointer 851 * legacy_hub_port_reset() - reset a port given its usb_device pointer
867 * 852 *
868 * Reset a hub port and see if a device is present on that port, providing 853 * Reset a hub port and see if a device is present on that port, providing
869 * sufficient time for it to show itself. The port status is returned. 854 * sufficient time for it to show itself. The port status is returned.
870 * 855 *
871 * With driver model this moves to hub_port_reset() and is passed a struct 856 * With driver model this moves to hub_port_reset() and is passed a struct
872 * udevice. 857 * udevice.
873 * 858 *
874 * @dev: USB device to reset 859 * @dev: USB device to reset
875 * @port: Port number to reset (note ports are numbered from 0 here) 860 * @port: Port number to reset (note ports are numbered from 0 here)
876 * @portstat: Returns port status 861 * @portstat: Returns port status
877 */ 862 */
878 int legacy_hub_port_reset(struct usb_device *dev, int port, 863 int legacy_hub_port_reset(struct usb_device *dev, int port,
879 unsigned short *portstat); 864 unsigned short *portstat);
880 865
881 int hub_port_reset(struct udevice *dev, int port, unsigned short *portstat); 866 int hub_port_reset(struct udevice *dev, int port, unsigned short *portstat);
882 867
883 /** 868 /**
884 * usb_alloc_new_device() - Allocate a new device 869 * usb_alloc_new_device() - Allocate a new device
885 * 870 *
886 * @devp: returns a pointer of a new device structure. With driver model this 871 * @devp: returns a pointer of a new device structure. With driver model this
887 * is a device pointer, but with legacy USB this pointer is 872 * is a device pointer, but with legacy USB this pointer is
888 * driver-specific. 873 * driver-specific.
889 * @return 0 if OK, -ENOSPC if we have found out of room for new devices 874 * @return 0 if OK, -ENOSPC if we have found out of room for new devices
890 */ 875 */
891 int usb_alloc_new_device(struct udevice *controller, struct usb_device **devp); 876 int usb_alloc_new_device(struct udevice *controller, struct usb_device **devp);
892 877
893 /** 878 /**
894 * usb_free_device() - Free a partially-inited device 879 * usb_free_device() - Free a partially-inited device
895 * 880 *
896 * This is an internal function. It is used to reverse the action of 881 * This is an internal function. It is used to reverse the action of
897 * usb_alloc_new_device() when we hit a problem during init. 882 * usb_alloc_new_device() when we hit a problem during init.
898 */ 883 */
899 void usb_free_device(struct udevice *controller); 884 void usb_free_device(struct udevice *controller);
900 885
901 int usb_new_device(struct usb_device *dev); 886 int usb_new_device(struct usb_device *dev);
902 887
903 int usb_alloc_device(struct usb_device *dev); 888 int usb_alloc_device(struct usb_device *dev);
904 889
905 /** 890 /**
906 * usb_emul_setup_device() - Set up a new USB device emulation 891 * usb_emul_setup_device() - Set up a new USB device emulation
907 * 892 *
908 * This is normally called when a new emulation device is bound. It tells 893 * This is normally called when a new emulation device is bound. It tells
909 * the USB emulation uclass about the features of the emulator. 894 * the USB emulation uclass about the features of the emulator.
910 * 895 *
911 * @dev: Emulation device 896 * @dev: Emulation device
912 * @maxpacketsize: Maximum packet size (e.g. PACKET_SIZE_64) 897 * @maxpacketsize: Maximum packet size (e.g. PACKET_SIZE_64)
913 * @strings: List of USB string descriptors, terminated by a NULL 898 * @strings: List of USB string descriptors, terminated by a NULL
914 * entry 899 * entry
915 * @desc_list: List of points or USB descriptors, terminated by NULL. 900 * @desc_list: List of points or USB descriptors, terminated by NULL.
916 * The first entry must be struct usb_device_descriptor, 901 * The first entry must be struct usb_device_descriptor,
917 * and others follow on after that. 902 * and others follow on after that.
918 * @return 0 if OK, -ve on error 903 * @return 0 if OK, -ve on error
919 */ 904 */
920 int usb_emul_setup_device(struct udevice *dev, int maxpacketsize, 905 int usb_emul_setup_device(struct udevice *dev, int maxpacketsize,
921 struct usb_string *strings, void **desc_list); 906 struct usb_string *strings, void **desc_list);
922 907
923 /** 908 /**
924 * usb_emul_control() - Send a control packet to an emulator 909 * usb_emul_control() - Send a control packet to an emulator
925 * 910 *
926 * @emul: Emulator device 911 * @emul: Emulator device
927 * @udev: USB device (which the emulator is causing to appear) 912 * @udev: USB device (which the emulator is causing to appear)
928 * See struct dm_usb_ops for details on other parameters 913 * See struct dm_usb_ops for details on other parameters
929 * @return 0 if OK, -ve on error 914 * @return 0 if OK, -ve on error
930 */ 915 */
931 int usb_emul_control(struct udevice *emul, struct usb_device *udev, 916 int usb_emul_control(struct udevice *emul, struct usb_device *udev,
932 unsigned long pipe, void *buffer, int length, 917 unsigned long pipe, void *buffer, int length,
933 struct devrequest *setup); 918 struct devrequest *setup);
934 919
935 /** 920 /**
936 * usb_emul_bulk() - Send a bulk packet to an emulator 921 * usb_emul_bulk() - Send a bulk packet to an emulator
937 * 922 *
938 * @emul: Emulator device 923 * @emul: Emulator device
939 * @udev: USB device (which the emulator is causing to appear) 924 * @udev: USB device (which the emulator is causing to appear)
940 * See struct dm_usb_ops for details on other parameters 925 * See struct dm_usb_ops for details on other parameters
941 * @return 0 if OK, -ve on error 926 * @return 0 if OK, -ve on error
942 */ 927 */
943 int usb_emul_bulk(struct udevice *emul, struct usb_device *udev, 928 int usb_emul_bulk(struct udevice *emul, struct usb_device *udev,
944 unsigned long pipe, void *buffer, int length); 929 unsigned long pipe, void *buffer, int length);
945 930
946 /** 931 /**
947 * usb_emul_find() - Find an emulator for a particular device 932 * usb_emul_find() - Find an emulator for a particular device
948 * 933 *
949 * Check @pipe to find a device number on bus @bus and return it. 934 * Check @pipe to find a device number on bus @bus and return it.
950 * 935 *
951 * @bus: USB bus (controller) 936 * @bus: USB bus (controller)
952 * @pipe: Describes pipe being used, and includes the device number 937 * @pipe: Describes pipe being used, and includes the device number
953 * @emulp: Returns pointer to emulator, or NULL if not found 938 * @emulp: Returns pointer to emulator, or NULL if not found
954 * @return 0 if found, -ve on error 939 * @return 0 if found, -ve on error
955 */ 940 */
956 int usb_emul_find(struct udevice *bus, ulong pipe, struct udevice **emulp); 941 int usb_emul_find(struct udevice *bus, ulong pipe, struct udevice **emulp);
957 942
958 /** 943 /**
959 * usb_emul_reset() - Reset all emulators ready for use 944 * usb_emul_reset() - Reset all emulators ready for use
960 * 945 *
961 * Clear out any address information in the emulators and make then ready for 946 * Clear out any address information in the emulators and make then ready for
962 * a new USB scan 947 * a new USB scan
963 */ 948 */
964 void usb_emul_reset(struct udevice *dev); 949 void usb_emul_reset(struct udevice *dev);
965 950
966 #endif /*_USB_H_ */ 951 #endif /*_USB_H_ */
967 952