blob: 4f7c520b344d7676d20a604be5c63d96b672efac [file] [log] [blame]
wdenkaffae2b2002-08-17 09:36:01 +00001/*
wdenkaffae2b2002-08-17 09:36:01 +00002 *
3 * Most of this source has been derived from the Linux USB
Wolfgang Denk460c3222005-08-04 01:14:12 +02004 * project:
5 * (C) Copyright Linus Torvalds 1999
6 * (C) Copyright Johannes Erdfelt 1999-2001
7 * (C) Copyright Andreas Gal 1999
8 * (C) Copyright Gregory P. Smith 1999
9 * (C) Copyright Deti Fliegl 1999 (new USB architecture)
10 * (C) Copyright Randy Dunlap 2000
11 * (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id)
12 * (C) Copyright Yggdrasil Computing, Inc. 2000
13 * (usb_device_id matching changes by Adam J. Richter)
14 *
15 * Adapted for U-Boot:
16 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland
wdenkaffae2b2002-08-17 09:36:01 +000017 *
18 * See file CREDITS for list of people who contributed to this
19 * project.
20 *
21 * This program is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU General Public License as
23 * published by the Free Software Foundation; either version 2 of
24 * the License, or (at your option) any later version.
25 *
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
30 *
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
34 * MA 02111-1307 USA
35 *
36 */
37
wdenkaffae2b2002-08-17 09:36:01 +000038/*
39 * How it works:
40 *
41 * Since this is a bootloader, the devices will not be automatic
42 * (re)configured on hotplug, but after a restart of the USB the
43 * device should work.
44 *
45 * For each transfer (except "Interrupt") we wait for completion.
46 */
47#include <common.h>
48#include <command.h>
49#include <asm/processor.h>
Wolfgang Denk9c998aa2005-07-21 11:57:57 +020050#include <linux/ctype.h>
Christian Eggersc9182612008-05-21 22:12:00 +020051#include <asm/byteorder.h>
wdenkaffae2b2002-08-17 09:36:01 +000052
wdenkaffae2b2002-08-17 09:36:01 +000053#include <usb.h>
54#ifdef CONFIG_4xx
Stefan Roese3048bcb2007-10-03 15:01:02 +020055#include <asm/4xx_pci.h>
wdenkaffae2b2002-08-17 09:36:01 +000056#endif
57
Alexander Hollerce297a82011-01-28 12:42:13 +010058#ifdef DEBUG
59#define USB_DEBUG
60#define USB_HUB_DEBUG
61#endif
wdenkaffae2b2002-08-17 09:36:01 +000062
63#ifdef USB_DEBUG
Michael Trimarchide39f8c2008-11-26 17:41:34 +010064#define USB_PRINTF(fmt, args...) printf(fmt , ##args)
wdenkaffae2b2002-08-17 09:36:01 +000065#else
Remy Bohmer6f5794a2008-09-16 14:55:43 +020066#define USB_PRINTF(fmt, args...)
wdenkaffae2b2002-08-17 09:36:01 +000067#endif
68
wdenkcd0a9de2004-02-23 20:48:38 +000069#define USB_BUFSIZ 512
70
wdenkaffae2b2002-08-17 09:36:01 +000071static struct usb_device usb_dev[USB_MAX_DEVICE];
72static int dev_index;
73static int running;
74static int asynch_allowed;
75static struct devrequest setup_packet;
76
Bartlomiej Siekae51aae32006-08-03 23:20:13 +020077char usb_started; /* flag for the started/stopped USB status */
78
wdenkaffae2b2002-08-17 09:36:01 +000079/**********************************************************************
80 * some forward declerations...
81 */
82void usb_scan_devices(void);
83
84int usb_hub_probe(struct usb_device *dev, int ifnum);
85void usb_hub_reset(void);
Remy Bohmerc9e84362008-09-16 14:55:44 +020086static int hub_port_reset(struct usb_device *dev, int port,
87 unsigned short *portstat);
Wolfgang Denk9c998aa2005-07-21 11:57:57 +020088
wdenkaffae2b2002-08-17 09:36:01 +000089/***********************************************************************
90 * wait_ms
91 */
92
Michael Trimarchide39f8c2008-11-26 17:41:34 +010093inline void wait_ms(unsigned long ms)
wdenkaffae2b2002-08-17 09:36:01 +000094{
Remy Bohmer6f5794a2008-09-16 14:55:43 +020095 while (ms-- > 0)
wdenkaffae2b2002-08-17 09:36:01 +000096 udelay(1000);
97}
Michael Trimarchide39f8c2008-11-26 17:41:34 +010098
wdenkaffae2b2002-08-17 09:36:01 +000099/***************************************************************************
100 * Init USB Device
101 */
102
103int usb_init(void)
104{
105 int result;
106
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200107 running = 0;
108 dev_index = 0;
109 asynch_allowed = 1;
wdenkaffae2b2002-08-17 09:36:01 +0000110 usb_hub_reset();
111 /* init low_level USB */
112 printf("USB: ");
113 result = usb_lowlevel_init();
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200114 /* if lowlevel init is OK, scan the bus for devices
115 * i.e. search HUBs and configure them */
116 if (result == 0) {
wdenkaffae2b2002-08-17 09:36:01 +0000117 printf("scanning bus for devices... ");
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200118 running = 1;
wdenkaffae2b2002-08-17 09:36:01 +0000119 usb_scan_devices();
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200120 usb_started = 1;
wdenkaffae2b2002-08-17 09:36:01 +0000121 return 0;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200122 } else {
wdenkaffae2b2002-08-17 09:36:01 +0000123 printf("Error, couldn't init Lowlevel part\n");
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200124 usb_started = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000125 return -1;
126 }
127}
128
129/******************************************************************************
130 * Stop USB this stops the LowLevel Part and deregisters USB devices.
131 */
132int usb_stop(void)
133{
Remy Bohmereba1f2f2008-08-20 11:22:02 +0200134 int res = 0;
135
136 if (usb_started) {
137 asynch_allowed = 1;
138 usb_started = 0;
139 usb_hub_reset();
140 res = usb_lowlevel_stop();
141 }
142 return res;
wdenkaffae2b2002-08-17 09:36:01 +0000143}
144
145/*
146 * disables the asynch behaviour of the control message. This is used for data
147 * transfers that uses the exclusiv access to the control and bulk messages.
Simon Glass89d48362011-02-16 11:14:33 -0800148 * Returns the old value so it can be restored later.
wdenkaffae2b2002-08-17 09:36:01 +0000149 */
Simon Glass89d48362011-02-16 11:14:33 -0800150int usb_disable_asynch(int disable)
wdenkaffae2b2002-08-17 09:36:01 +0000151{
Simon Glass89d48362011-02-16 11:14:33 -0800152 int old_value = asynch_allowed;
153
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200154 asynch_allowed = !disable;
Simon Glass89d48362011-02-16 11:14:33 -0800155 return old_value;
wdenkaffae2b2002-08-17 09:36:01 +0000156}
157
158
159/*-------------------------------------------------------------------
160 * Message wrappers.
161 *
162 */
163
164/*
165 * submits an Interrupt Message
166 */
167int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200168 void *buffer, int transfer_len, int interval)
wdenkaffae2b2002-08-17 09:36:01 +0000169{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200170 return submit_int_msg(dev, pipe, buffer, transfer_len, interval);
wdenkaffae2b2002-08-17 09:36:01 +0000171}
172
173/*
174 * submits a control message and waits for comletion (at least timeout * 1ms)
175 * If timeout is 0, we don't wait for completion (used as example to set and
176 * clear keyboards LEDs). For data transfers, (storage transfers) we don't
177 * allow control messages with 0 timeout, by previousely resetting the flag
178 * asynch_allowed (usb_disable_asynch(1)).
179 * returns the transfered length if OK or -1 if error. The transfered length
180 * and the current status are stored in the dev->act_len and dev->status.
181 */
182int usb_control_msg(struct usb_device *dev, unsigned int pipe,
183 unsigned char request, unsigned char requesttype,
184 unsigned short value, unsigned short index,
185 void *data, unsigned short size, int timeout)
186{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200187 if ((timeout == 0) && (!asynch_allowed)) {
188 /* request for a asynch control pipe is not allowed */
wdenkaffae2b2002-08-17 09:36:01 +0000189 return -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200190 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200191
wdenkaffae2b2002-08-17 09:36:01 +0000192 /* set setup command */
193 setup_packet.requesttype = requesttype;
194 setup_packet.request = request;
Christian Eggersc9182612008-05-21 22:12:00 +0200195 setup_packet.value = cpu_to_le16(value);
196 setup_packet.index = cpu_to_le16(index);
197 setup_packet.length = cpu_to_le16(size);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200198 USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
199 "value 0x%X index 0x%X length 0x%X\n",
200 request, requesttype, value, index, size);
201 dev->status = USB_ST_NOT_PROC; /*not yet processed */
wdenkaffae2b2002-08-17 09:36:01 +0000202
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200203 submit_control_msg(dev, pipe, data, size, &setup_packet);
204 if (timeout == 0)
wdenkaffae2b2002-08-17 09:36:01 +0000205 return (int)size;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200206
Remy Bohmer84d36b32010-02-01 19:40:47 +0100207 /*
208 * Wait for status to update until timeout expires, USB driver
209 * interrupt handler may set the status when the USB operation has
210 * been completed.
211 */
212 while (timeout--) {
213 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
214 break;
215 wait_ms(1);
Remy Bohmer48867202008-10-10 10:23:21 +0200216 }
Remy Bohmer84d36b32010-02-01 19:40:47 +0100217 if (dev->status)
218 return -1;
Remy Bohmer48867202008-10-10 10:23:21 +0200219
220 return dev->act_len;
Remy Bohmer84d36b32010-02-01 19:40:47 +0100221
wdenkaffae2b2002-08-17 09:36:01 +0000222}
223
224/*-------------------------------------------------------------------
225 * submits bulk message, and waits for completion. returns 0 if Ok or
226 * -1 if Error.
227 * synchronous behavior
228 */
229int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
230 void *data, int len, int *actual_length, int timeout)
231{
232 if (len < 0)
233 return -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200234 dev->status = USB_ST_NOT_PROC; /*not yet processed */
235 submit_bulk_msg(dev, pipe, data, len);
236 while (timeout--) {
237 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
wdenkaffae2b2002-08-17 09:36:01 +0000238 break;
239 wait_ms(1);
240 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200241 *actual_length = dev->act_len;
242 if (dev->status == 0)
wdenkaffae2b2002-08-17 09:36:01 +0000243 return 0;
244 else
245 return -1;
246}
247
248
249/*-------------------------------------------------------------------
250 * Max Packet stuff
251 */
252
253/*
254 * returns the max packet size, depending on the pipe direction and
255 * the configurations values
256 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200257int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
wdenkaffae2b2002-08-17 09:36:01 +0000258{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200259 /* direction is out -> use emaxpacket out */
260 if ((pipe & USB_DIR_IN) == 0)
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100261 return dev->epmaxpacketout[((pipe>>15) & 0xf)];
wdenkaffae2b2002-08-17 09:36:01 +0000262 else
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100263 return dev->epmaxpacketin[((pipe>>15) & 0xf)];
wdenkaffae2b2002-08-17 09:36:01 +0000264}
265
Remy Bohmerbe19d322008-09-16 14:55:42 +0200266/* The routine usb_set_maxpacket_ep() is extracted from the loop of routine
267 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine
268 * when it is inlined in 1 single routine. What happens is that the register r3
269 * is used as loop-count 'i', but gets overwritten later on.
270 * This is clearly a compiler bug, but it is easier to workaround it here than
271 * to update the compiler (Occurs with at least several GCC 4.{1,2},x
272 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM)
273 */
274static void __attribute__((noinline))
275usb_set_maxpacket_ep(struct usb_device *dev, struct usb_endpoint_descriptor *ep)
276{
277 int b;
278
279 b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
280
281 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
282 USB_ENDPOINT_XFER_CONTROL) {
283 /* Control => bidirectional */
284 dev->epmaxpacketout[b] = ep->wMaxPacketSize;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100285 dev->epmaxpacketin[b] = ep->wMaxPacketSize;
Remy Bohmerbe19d322008-09-16 14:55:42 +0200286 USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",
287 b, dev->epmaxpacketin[b]);
288 } else {
289 if ((ep->bEndpointAddress & 0x80) == 0) {
290 /* OUT Endpoint */
291 if (ep->wMaxPacketSize > dev->epmaxpacketout[b]) {
292 dev->epmaxpacketout[b] = ep->wMaxPacketSize;
293 USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",
294 b, dev->epmaxpacketout[b]);
295 }
296 } else {
297 /* IN Endpoint */
298 if (ep->wMaxPacketSize > dev->epmaxpacketin[b]) {
299 dev->epmaxpacketin[b] = ep->wMaxPacketSize;
300 USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",
301 b, dev->epmaxpacketin[b]);
302 }
303 } /* if out */
304 } /* if control */
305}
306
wdenkaffae2b2002-08-17 09:36:01 +0000307/*
308 * set the max packed value of all endpoints in the given configuration
309 */
310int usb_set_maxpacket(struct usb_device *dev)
311{
Remy Bohmerbe19d322008-09-16 14:55:42 +0200312 int i, ii;
wdenkaffae2b2002-08-17 09:36:01 +0000313
Tom Rix8f8bd562009-10-31 12:37:38 -0500314 for (i = 0; i < dev->config.desc.bNumInterfaces; i++)
315 for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++)
Remy Bohmerbe19d322008-09-16 14:55:42 +0200316 usb_set_maxpacket_ep(dev,
317 &dev->config.if_desc[i].ep_desc[ii]);
wdenkaffae2b2002-08-17 09:36:01 +0000318
wdenkaffae2b2002-08-17 09:36:01 +0000319 return 0;
320}
321
322/*******************************************************************************
323 * Parse the config, located in buffer, and fills the dev->config structure.
324 * Note that all little/big endian swapping are done automatically.
325 */
326int usb_parse_config(struct usb_device *dev, unsigned char *buffer, int cfgno)
327{
328 struct usb_descriptor_header *head;
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200329 int index, ifno, epno, curr_if_num;
330 int i;
331 unsigned char *ch;
wdenkaffae2b2002-08-17 09:36:01 +0000332
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200333 ifno = -1;
334 epno = -1;
335 curr_if_num = -1;
336
337 dev->configno = cfgno;
338 head = (struct usb_descriptor_header *) &buffer[0];
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200339 if (head->bDescriptorType != USB_DT_CONFIG) {
340 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
341 head->bDescriptorType);
wdenkaffae2b2002-08-17 09:36:01 +0000342 return -1;
343 }
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200344 memcpy(&dev->config, buffer, buffer[0]);
Tom Rix8f8bd562009-10-31 12:37:38 -0500345 le16_to_cpus(&(dev->config.desc.wTotalLength));
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200346 dev->config.no_of_if = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000347
Tom Rix8f8bd562009-10-31 12:37:38 -0500348 index = dev->config.desc.bLength;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200349 /* Ok the first entry must be a configuration entry,
350 * now process the others */
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200351 head = (struct usb_descriptor_header *) &buffer[index];
Tom Rix8f8bd562009-10-31 12:37:38 -0500352 while (index + 1 < dev->config.desc.wTotalLength) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200353 switch (head->bDescriptorType) {
354 case USB_DT_INTERFACE:
355 if (((struct usb_interface_descriptor *) \
356 &buffer[index])->bInterfaceNumber != curr_if_num) {
357 /* this is a new interface, copy new desc */
358 ifno = dev->config.no_of_if;
359 dev->config.no_of_if++;
360 memcpy(&dev->config.if_desc[ifno],
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200361 &buffer[index], buffer[index]);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200362 dev->config.if_desc[ifno].no_of_ep = 0;
363 dev->config.if_desc[ifno].num_altsetting = 1;
364 curr_if_num =
Tom Rix8f8bd562009-10-31 12:37:38 -0500365 dev->config.if_desc[ifno].desc.bInterfaceNumber;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200366 } else {
367 /* found alternate setting for the interface */
368 dev->config.if_desc[ifno].num_altsetting++;
369 }
370 break;
371 case USB_DT_ENDPOINT:
372 epno = dev->config.if_desc[ifno].no_of_ep;
373 /* found an endpoint */
374 dev->config.if_desc[ifno].no_of_ep++;
375 memcpy(&dev->config.if_desc[ifno].ep_desc[epno],
376 &buffer[index], buffer[index]);
377 le16_to_cpus(&(dev->config.if_desc[ifno].ep_desc[epno].\
378 wMaxPacketSize));
379 USB_PRINTF("if %d, ep %d\n", ifno, epno);
380 break;
381 default:
382 if (head->bLength == 0)
383 return 1;
384
385 USB_PRINTF("unknown Description Type : %x\n",
386 head->bDescriptorType);
387
388 {
389 ch = (unsigned char *)head;
390 for (i = 0; i < head->bLength; i++)
391 USB_PRINTF("%02X ", *ch++);
392 USB_PRINTF("\n\n\n");
393 }
394 break;
wdenkaffae2b2002-08-17 09:36:01 +0000395 }
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200396 index += head->bLength;
397 head = (struct usb_descriptor_header *)&buffer[index];
wdenkaffae2b2002-08-17 09:36:01 +0000398 }
399 return 1;
400}
401
402/***********************************************************************
403 * Clears an endpoint
404 * endp: endpoint number in bits 0-3;
405 * direction flag in bit 7 (1 = IN, 0 = OUT)
406 */
407int usb_clear_halt(struct usb_device *dev, int pipe)
408{
409 int result;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200410 int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
wdenkaffae2b2002-08-17 09:36:01 +0000411
412 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200413 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
414 endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
wdenkaffae2b2002-08-17 09:36:01 +0000415
416 /* don't clear if failed */
417 if (result < 0)
418 return result;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200419
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200420 /*
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200421 * NOTE: we do not get status and verify reset was successful
422 * as some devices are reported to lock up upon this check..
423 */
424
wdenkaffae2b2002-08-17 09:36:01 +0000425 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200426
wdenkaffae2b2002-08-17 09:36:01 +0000427 /* toggle is reset on clear */
428 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
429 return 0;
430}
431
432
433/**********************************************************************
434 * get_descriptor type
435 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200436int usb_get_descriptor(struct usb_device *dev, unsigned char type,
437 unsigned char index, void *buf, int size)
wdenkaffae2b2002-08-17 09:36:01 +0000438{
439 int res;
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200440 res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
wdenkaffae2b2002-08-17 09:36:01 +0000441 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
442 (type << 8) + index, 0,
443 buf, size, USB_CNTL_TIMEOUT);
444 return res;
445}
446
447/**********************************************************************
448 * gets configuration cfgno and store it in the buffer
449 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200450int usb_get_configuration_no(struct usb_device *dev,
451 unsigned char *buffer, int cfgno)
wdenkaffae2b2002-08-17 09:36:01 +0000452{
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200453 int result;
wdenkaffae2b2002-08-17 09:36:01 +0000454 unsigned int tmp;
Tom Rix8f8bd562009-10-31 12:37:38 -0500455 struct usb_configuration_descriptor *config;
wdenkaffae2b2002-08-17 09:36:01 +0000456
Tom Rix8f8bd562009-10-31 12:37:38 -0500457 config = (struct usb_configuration_descriptor *)&buffer[0];
Remy Bohmer48867202008-10-10 10:23:21 +0200458 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9);
459 if (result < 9) {
wdenkaffae2b2002-08-17 09:36:01 +0000460 if (result < 0)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200461 printf("unable to get descriptor, error %lX\n",
462 dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000463 else
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200464 printf("config descriptor too short " \
Remy Bohmer48867202008-10-10 10:23:21 +0200465 "(expected %i, got %i)\n", 9, result);
wdenkaffae2b2002-08-17 09:36:01 +0000466 return -1;
467 }
Christian Eggersc9182612008-05-21 22:12:00 +0200468 tmp = le16_to_cpu(config->wTotalLength);
wdenkaffae2b2002-08-17 09:36:01 +0000469
wdenkcd0a9de2004-02-23 20:48:38 +0000470 if (tmp > USB_BUFSIZ) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200471 USB_PRINTF("usb_get_configuration_no: failed to get " \
472 "descriptor - too long: %d\n", tmp);
wdenkcd0a9de2004-02-23 20:48:38 +0000473 return -1;
474 }
475
wdenkaffae2b2002-08-17 09:36:01 +0000476 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, tmp);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200477 USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",
478 cfgno, result, tmp);
wdenkaffae2b2002-08-17 09:36:01 +0000479 return result;
480}
481
482/********************************************************************
483 * set address of a device to the value in dev->devnum.
484 * This can only be done by addressing the device via the default address (0)
485 */
486int usb_set_address(struct usb_device *dev)
487{
488 int res;
489
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200490 USB_PRINTF("set address %d\n", dev->devnum);
491 res = usb_control_msg(dev, usb_snddefctrl(dev),
492 USB_REQ_SET_ADDRESS, 0,
493 (dev->devnum), 0,
494 NULL, 0, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +0000495 return res;
496}
497
498/********************************************************************
499 * set interface number to interface
500 */
501int usb_set_interface(struct usb_device *dev, int interface, int alternate)
502{
Tom Rix8f8bd562009-10-31 12:37:38 -0500503 struct usb_interface *if_face = NULL;
wdenkaffae2b2002-08-17 09:36:01 +0000504 int ret, i;
505
Tom Rix8f8bd562009-10-31 12:37:38 -0500506 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) {
507 if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) {
wdenkaffae2b2002-08-17 09:36:01 +0000508 if_face = &dev->config.if_desc[i];
509 break;
510 }
511 }
512 if (!if_face) {
513 printf("selecting invalid interface %d", interface);
514 return -1;
515 }
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200516 /*
517 * We should return now for devices with only one alternate setting.
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200518 * According to 9.4.10 of the Universal Serial Bus Specification
519 * Revision 2.0 such devices can return with a STALL. This results in
520 * some USB sticks timeouting during initialization and then being
521 * unusable in U-Boot.
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200522 */
523 if (if_face->num_altsetting == 1)
524 return 0;
wdenkaffae2b2002-08-17 09:36:01 +0000525
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200526 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
527 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
528 alternate, interface, NULL, 0,
529 USB_CNTL_TIMEOUT * 5);
530 if (ret < 0)
wdenkaffae2b2002-08-17 09:36:01 +0000531 return ret;
532
wdenkaffae2b2002-08-17 09:36:01 +0000533 return 0;
534}
535
536/********************************************************************
537 * set configuration number to configuration
538 */
539int usb_set_configuration(struct usb_device *dev, int configuration)
540{
541 int res;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200542 USB_PRINTF("set configuration %d\n", configuration);
wdenkaffae2b2002-08-17 09:36:01 +0000543 /* set setup command */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200544 res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
545 USB_REQ_SET_CONFIGURATION, 0,
546 configuration, 0,
547 NULL, 0, USB_CNTL_TIMEOUT);
548 if (res == 0) {
wdenkaffae2b2002-08-17 09:36:01 +0000549 dev->toggle[0] = 0;
550 dev->toggle[1] = 0;
551 return 0;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200552 } else
wdenkaffae2b2002-08-17 09:36:01 +0000553 return -1;
554}
555
556/********************************************************************
557 * set protocol to protocol
558 */
559int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
560{
561 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
562 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
563 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
564}
565
566/********************************************************************
567 * set idle
568 */
569int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
570{
571 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
572 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
573 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
574}
575
576/********************************************************************
577 * get report
578 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200579int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
580 unsigned char id, void *buf, int size)
wdenkaffae2b2002-08-17 09:36:01 +0000581{
582 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200583 USB_REQ_GET_REPORT,
584 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
585 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +0000586}
587
588/********************************************************************
589 * get class descriptor
590 */
591int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
592 unsigned char type, unsigned char id, void *buf, int size)
593{
594 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
595 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
596 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
597}
598
599/********************************************************************
600 * get string index in buffer
601 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200602int usb_get_string(struct usb_device *dev, unsigned short langid,
603 unsigned char index, void *buf, int size)
wdenkaffae2b2002-08-17 09:36:01 +0000604{
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200605 int i;
606 int result;
607
608 for (i = 0; i < 3; ++i) {
609 /* some devices are flaky */
610 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
611 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200612 (USB_DT_STRING << 8) + index, langid, buf, size,
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200613 USB_CNTL_TIMEOUT);
614
615 if (result > 0)
616 break;
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200617 }
618
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200619 return result;
wdenkaffae2b2002-08-17 09:36:01 +0000620}
621
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200622
623static void usb_try_string_workarounds(unsigned char *buf, int *length)
624{
625 int newlength, oldlength = *length;
626
627 for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
628 if (!isprint(buf[newlength]) || buf[newlength + 1])
629 break;
630
631 if (newlength > 2) {
632 buf[0] = newlength;
633 *length = newlength;
634 }
635}
636
637
638static int usb_string_sub(struct usb_device *dev, unsigned int langid,
639 unsigned int index, unsigned char *buf)
640{
641 int rc;
642
643 /* Try to read the string descriptor by asking for the maximum
644 * possible number of bytes */
645 rc = usb_get_string(dev, langid, index, buf, 255);
646
647 /* If that failed try to read the descriptor length, then
648 * ask for just that many bytes */
649 if (rc < 2) {
650 rc = usb_get_string(dev, langid, index, buf, 2);
651 if (rc == 2)
652 rc = usb_get_string(dev, langid, index, buf, buf[0]);
653 }
654
655 if (rc >= 2) {
656 if (!buf[0] && !buf[1])
657 usb_try_string_workarounds(buf, &rc);
658
659 /* There might be extra junk at the end of the descriptor */
660 if (buf[0] < rc)
661 rc = buf[0];
662
663 rc = rc - (rc & 1); /* force a multiple of two */
664 }
665
666 if (rc < 2)
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200667 rc = -1;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200668
669 return rc;
670}
671
672
wdenkaffae2b2002-08-17 09:36:01 +0000673/********************************************************************
674 * usb_string:
675 * Get string index and translate it to ascii.
676 * returns string length (> 0) or error (< 0)
677 */
678int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
679{
wdenkcd0a9de2004-02-23 20:48:38 +0000680 unsigned char mybuf[USB_BUFSIZ];
wdenkaffae2b2002-08-17 09:36:01 +0000681 unsigned char *tbuf;
682 int err;
683 unsigned int u, idx;
684
685 if (size <= 0 || !buf || !index)
686 return -1;
687 buf[0] = 0;
Wolfgang Denkd0ff51b2008-07-14 15:19:07 +0200688 tbuf = &mybuf[0];
wdenkaffae2b2002-08-17 09:36:01 +0000689
690 /* get langid for strings if it's not yet known */
691 if (!dev->have_langid) {
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200692 err = usb_string_sub(dev, 0, 0, tbuf);
wdenkaffae2b2002-08-17 09:36:01 +0000693 if (err < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200694 USB_PRINTF("error getting string descriptor 0 " \
Stefan Roesef1c1f542009-01-22 10:11:21 +0100695 "(error=%lx)\n", dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000696 return -1;
697 } else if (tbuf[0] < 4) {
698 USB_PRINTF("string descriptor 0 too short\n");
699 return -1;
700 } else {
701 dev->have_langid = -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200702 dev->string_langid = tbuf[2] | (tbuf[3] << 8);
wdenkaffae2b2002-08-17 09:36:01 +0000703 /* always use the first langid listed */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200704 USB_PRINTF("USB device number %d default " \
705 "language ID 0x%x\n",
706 dev->devnum, dev->string_langid);
wdenkaffae2b2002-08-17 09:36:01 +0000707 }
708 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200709
710 err = usb_string_sub(dev, dev->string_langid, index, tbuf);
wdenkaffae2b2002-08-17 09:36:01 +0000711 if (err < 0)
712 return err;
wdenkcd0a9de2004-02-23 20:48:38 +0000713
wdenkaffae2b2002-08-17 09:36:01 +0000714 size--; /* leave room for trailing NULL char in output buffer */
715 for (idx = 0, u = 2; u < err; u += 2) {
716 if (idx >= size)
717 break;
718 if (tbuf[u+1]) /* high byte */
719 buf[idx++] = '?'; /* non-ASCII character */
720 else
721 buf[idx++] = tbuf[u];
722 }
723 buf[idx] = 0;
724 err = idx;
725 return err;
726}
727
728
729/********************************************************************
730 * USB device handling:
731 * the USB device are static allocated [USB_MAX_DEVICE].
732 */
733
734
735/* returns a pointer to the device with the index [index].
736 * if the device is not assigned (dev->devnum==-1) returns NULL
737 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200738struct usb_device *usb_get_dev_index(int index)
wdenkaffae2b2002-08-17 09:36:01 +0000739{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200740 if (usb_dev[index].devnum == -1)
wdenkaffae2b2002-08-17 09:36:01 +0000741 return NULL;
742 else
743 return &usb_dev[index];
744}
745
746
747/* returns a pointer of a new device structure or NULL, if
748 * no device struct is available
749 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200750struct usb_device *usb_alloc_new_device(void)
wdenkaffae2b2002-08-17 09:36:01 +0000751{
752 int i;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200753 USB_PRINTF("New Device %d\n", dev_index);
754 if (dev_index == USB_MAX_DEVICE) {
755 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE);
wdenkaffae2b2002-08-17 09:36:01 +0000756 return NULL;
757 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200758 /* default Address is 0, real addresses start with 1 */
759 usb_dev[dev_index].devnum = dev_index + 1;
760 usb_dev[dev_index].maxchild = 0;
761 for (i = 0; i < USB_MAXCHILDREN; i++)
762 usb_dev[dev_index].children[i] = NULL;
763 usb_dev[dev_index].parent = NULL;
wdenkaffae2b2002-08-17 09:36:01 +0000764 dev_index++;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200765 return &usb_dev[dev_index - 1];
wdenkaffae2b2002-08-17 09:36:01 +0000766}
767
768
769/*
770 * By the time we get here, the device has gotten a new device ID
771 * and is in the default state. We need to identify the thing and
772 * get the ball rolling..
773 *
774 * Returns 0 for success, != 0 for error.
775 */
776int usb_new_device(struct usb_device *dev)
777{
778 int addr, err;
779 int tmp;
wdenkcd0a9de2004-02-23 20:48:38 +0000780 unsigned char tmpbuf[USB_BUFSIZ];
wdenkaffae2b2002-08-17 09:36:01 +0000781
wdenkaffae2b2002-08-17 09:36:01 +0000782 /* We still haven't set the Address yet */
783 addr = dev->devnum;
784 dev->devnum = 0;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200785
Remy Bohmerc9e84362008-09-16 14:55:44 +0200786#ifdef CONFIG_LEGACY_USB_INIT_SEQ
787 /* this is the old and known way of initializing devices, it is
788 * different than what Windows and Linux are doing. Windows and Linux
789 * both retrieve 64 bytes while reading the device descriptor
790 * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an
791 * invalid header while reading 8 bytes as device descriptor. */
792 dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */
Remy Bohmer48867202008-10-10 10:23:21 +0200793 dev->maxpacketsize = PACKET_SIZE_8;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100794 dev->epmaxpacketin[0] = 8;
Remy Bohmerc9e84362008-09-16 14:55:44 +0200795 dev->epmaxpacketout[0] = 8;
796
797 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
798 if (err < 8) {
799 printf("\n USB device not responding, " \
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100800 "giving up (status=%lX)\n", dev->status);
Remy Bohmerc9e84362008-09-16 14:55:44 +0200801 return 1;
802 }
803#else
Remy Bohmer48867202008-10-10 10:23:21 +0200804 /* This is a Windows scheme of initialization sequence, with double
805 * reset of the device (Linux uses the same sequence)
Remy Bohmerc9e84362008-09-16 14:55:44 +0200806 * Some equipment is said to work only with such init sequence; this
807 * patch is based on the work by Alan Stern:
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100808 * http://sourceforge.net/mailarchive/forum.php?
809 * thread_id=5729457&forum_id=5398
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200810 */
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200811 struct usb_device_descriptor *desc;
812 int port = -1;
813 struct usb_device *parent = dev->parent;
814 unsigned short portstatus;
815
816 /* send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is
817 * only 18 bytes long, this will terminate with a short packet. But if
818 * the maxpacket size is 8 or 16 the device may be waiting to transmit
Remy Bohmerc9e84362008-09-16 14:55:44 +0200819 * some more, or keeps on retransmitting the 8 byte header. */
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200820
821 desc = (struct usb_device_descriptor *)tmpbuf;
Remy Bohmerc9e84362008-09-16 14:55:44 +0200822 dev->descriptor.bMaxPacketSize0 = 64; /* Start off at 64 bytes */
Remy Bohmer48867202008-10-10 10:23:21 +0200823 /* Default to 64 byte max packet size */
824 dev->maxpacketsize = PACKET_SIZE_64;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100825 dev->epmaxpacketin[0] = 64;
Remy Bohmerc9e84362008-09-16 14:55:44 +0200826 dev->epmaxpacketout[0] = 64;
Remy Bohmer48867202008-10-10 10:23:21 +0200827
828 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
829 if (err < 0) {
830 USB_PRINTF("usb_new_device: usb_get_descriptor() failed\n");
831 return 1;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200832 }
Remy Bohmer48867202008-10-10 10:23:21 +0200833
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200834 dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0;
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200835
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200836 /* find the port number we're at */
837 if (parent) {
Remy Bohmer48867202008-10-10 10:23:21 +0200838 int j;
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200839
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200840 for (j = 0; j < parent->maxchild; j++) {
841 if (parent->children[j] == dev) {
842 port = j;
843 break;
844 }
845 }
846 if (port < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200847 printf("usb_new_device:cannot locate device's port.\n");
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200848 return 1;
849 }
850
851 /* reset the port for the second time */
852 err = hub_port_reset(dev->parent, port, &portstatus);
853 if (err < 0) {
854 printf("\n Couldn't reset port %i\n", port);
855 return 1;
856 }
857 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200858#endif
859
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100860 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
wdenkaffae2b2002-08-17 09:36:01 +0000861 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
862 switch (dev->descriptor.bMaxPacketSize0) {
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100863 case 8:
864 dev->maxpacketsize = PACKET_SIZE_8;
865 break;
866 case 16:
867 dev->maxpacketsize = PACKET_SIZE_16;
868 break;
869 case 32:
870 dev->maxpacketsize = PACKET_SIZE_32;
871 break;
872 case 64:
873 dev->maxpacketsize = PACKET_SIZE_64;
874 break;
wdenkaffae2b2002-08-17 09:36:01 +0000875 }
876 dev->devnum = addr;
877
878 err = usb_set_address(dev); /* set address */
879
880 if (err < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200881 printf("\n USB device not accepting new address " \
882 "(error=%lX)\n", dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000883 return 1;
884 }
885
886 wait_ms(10); /* Let the SET_ADDRESS settle */
887
888 tmp = sizeof(dev->descriptor);
889
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200890 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
891 &dev->descriptor, sizeof(dev->descriptor));
wdenkaffae2b2002-08-17 09:36:01 +0000892 if (err < tmp) {
893 if (err < 0)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200894 printf("unable to get device descriptor (error=%d)\n",
895 err);
wdenkaffae2b2002-08-17 09:36:01 +0000896 else
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200897 printf("USB device descriptor short read " \
898 "(expected %i, got %i)\n", tmp, err);
wdenkaffae2b2002-08-17 09:36:01 +0000899 return 1;
900 }
901 /* correct le values */
Christian Eggersc9182612008-05-21 22:12:00 +0200902 le16_to_cpus(&dev->descriptor.bcdUSB);
903 le16_to_cpus(&dev->descriptor.idVendor);
904 le16_to_cpus(&dev->descriptor.idProduct);
905 le16_to_cpus(&dev->descriptor.bcdDevice);
wdenkaffae2b2002-08-17 09:36:01 +0000906 /* only support for one config for now */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200907 usb_get_configuration_no(dev, &tmpbuf[0], 0);
908 usb_parse_config(dev, &tmpbuf[0], 0);
wdenkaffae2b2002-08-17 09:36:01 +0000909 usb_set_maxpacket(dev);
910 /* we set the default configuration here */
Tom Rix8f8bd562009-10-31 12:37:38 -0500911 if (usb_set_configuration(dev, dev->config.desc.bConfigurationValue)) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200912 printf("failed to set default configuration " \
913 "len %d, status %lX\n", dev->act_len, dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000914 return -1;
915 }
916 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200917 dev->descriptor.iManufacturer, dev->descriptor.iProduct,
918 dev->descriptor.iSerialNumber);
wdenkaffae2b2002-08-17 09:36:01 +0000919 memset(dev->mf, 0, sizeof(dev->mf));
920 memset(dev->prod, 0, sizeof(dev->prod));
921 memset(dev->serial, 0, sizeof(dev->serial));
922 if (dev->descriptor.iManufacturer)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200923 usb_string(dev, dev->descriptor.iManufacturer,
924 dev->mf, sizeof(dev->mf));
wdenkaffae2b2002-08-17 09:36:01 +0000925 if (dev->descriptor.iProduct)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200926 usb_string(dev, dev->descriptor.iProduct,
927 dev->prod, sizeof(dev->prod));
wdenkaffae2b2002-08-17 09:36:01 +0000928 if (dev->descriptor.iSerialNumber)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200929 usb_string(dev, dev->descriptor.iSerialNumber,
930 dev->serial, sizeof(dev->serial));
wdenkaffae2b2002-08-17 09:36:01 +0000931 USB_PRINTF("Manufacturer %s\n", dev->mf);
932 USB_PRINTF("Product %s\n", dev->prod);
933 USB_PRINTF("SerialNumber %s\n", dev->serial);
934 /* now prode if the device is a hub */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200935 usb_hub_probe(dev, 0);
wdenkaffae2b2002-08-17 09:36:01 +0000936 return 0;
937}
938
939/* build device Tree */
940void usb_scan_devices(void)
941{
942 int i;
943 struct usb_device *dev;
944
945 /* first make all devices unknown */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200946 for (i = 0; i < USB_MAX_DEVICE; i++) {
947 memset(&usb_dev[i], 0, sizeof(struct usb_device));
Wolfgang Denkd0ff51b2008-07-14 15:19:07 +0200948 usb_dev[i].devnum = -1;
wdenkaffae2b2002-08-17 09:36:01 +0000949 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200950 dev_index = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000951 /* device 0 is always present (root hub, so let it analyze) */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200952 dev = usb_alloc_new_device();
Bryan Wu1a448db2009-01-18 23:04:27 -0500953 if (usb_new_device(dev))
954 printf("No USB Device found\n");
955 else
956 printf("%d USB Device(s) found\n", dev_index);
wdenkaffae2b2002-08-17 09:36:01 +0000957 /* insert "driver" if possible */
958#ifdef CONFIG_USB_KEYBOARD
959 drv_usb_kbd_init();
960 USB_PRINTF("scan end\n");
961#endif
962}
963
964
965/****************************************************************************
966 * HUB "Driver"
967 * Probes device for being a hub and configurate it
968 */
969
wdenkaffae2b2002-08-17 09:36:01 +0000970#ifdef USB_HUB_DEBUG
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100971#define USB_HUB_PRINTF(fmt, args...) printf(fmt , ##args)
wdenkaffae2b2002-08-17 09:36:01 +0000972#else
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200973#define USB_HUB_PRINTF(fmt, args...)
wdenkaffae2b2002-08-17 09:36:01 +0000974#endif
975
976
977static struct usb_hub_device hub_dev[USB_MAX_HUB];
978static int usb_hub_index;
979
980
981int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
982{
983 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
984 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
985 USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
986}
987
988int usb_clear_hub_feature(struct usb_device *dev, int feature)
989{
990 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200991 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature,
992 0, NULL, 0, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +0000993}
994
995int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
996{
997 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200998 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature,
999 port, NULL, 0, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +00001000}
1001
1002int usb_set_port_feature(struct usb_device *dev, int port, int feature)
1003{
1004 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001005 USB_REQ_SET_FEATURE, USB_RT_PORT, feature,
1006 port, NULL, 0, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +00001007}
1008
1009int usb_get_hub_status(struct usb_device *dev, void *data)
1010{
1011 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1012 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
1013 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
1014}
1015
1016int usb_get_port_status(struct usb_device *dev, int port, void *data)
1017{
1018 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1019 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
1020 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
1021}
1022
1023
1024static void usb_hub_power_on(struct usb_hub_device *hub)
1025{
1026 int i;
1027 struct usb_device *dev;
1028
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001029 dev = hub->pusb_dev;
wdenkaffae2b2002-08-17 09:36:01 +00001030 /* Enable power to the ports */
1031 USB_HUB_PRINTF("enabling power on all ports\n");
1032 for (i = 0; i < dev->maxchild; i++) {
1033 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001034 USB_HUB_PRINTF("port %d returns %lX\n", i + 1, dev->status);
wdenkaffae2b2002-08-17 09:36:01 +00001035 wait_ms(hub->desc.bPwrOn2PwrGood * 2);
1036 }
1037}
1038
1039void usb_hub_reset(void)
1040{
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001041 usb_hub_index = 0;
wdenkaffae2b2002-08-17 09:36:01 +00001042}
1043
1044struct usb_hub_device *usb_hub_allocate(void)
1045{
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001046 if (usb_hub_index < USB_MAX_HUB)
wdenkaffae2b2002-08-17 09:36:01 +00001047 return &hub_dev[usb_hub_index++];
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001048
1049 printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB);
wdenkaffae2b2002-08-17 09:36:01 +00001050 return NULL;
1051}
1052
1053#define MAX_TRIES 5
1054
Stefan Roesef1c1f542009-01-22 10:11:21 +01001055static inline char *portspeed(int portstatus)
1056{
1057 if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
1058 return "480 Mb/s";
1059 else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
1060 return "1.5 Mb/s";
1061 else
1062 return "12 Mb/s";
1063}
1064
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001065static int hub_port_reset(struct usb_device *dev, int port,
1066 unsigned short *portstat)
1067{
1068 int tries;
1069 struct usb_port_status portsts;
1070 unsigned short portstatus, portchange;
1071
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001072 USB_HUB_PRINTF("hub_port_reset: resetting port %d...\n", port);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001073 for (tries = 0; tries < MAX_TRIES; tries++) {
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001074
1075 usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
1076 wait_ms(200);
1077
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001078 if (usb_get_port_status(dev, port + 1, &portsts) < 0) {
1079 USB_HUB_PRINTF("get_port_status failed status %lX\n",
1080 dev->status);
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001081 return -1;
1082 }
Christian Eggersc9182612008-05-21 22:12:00 +02001083 portstatus = le16_to_cpu(portsts.wPortStatus);
1084 portchange = le16_to_cpu(portsts.wPortChange);
Michael Trimarchi366523c2008-12-18 10:05:37 +01001085
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001086 USB_HUB_PRINTF("portstatus %x, change %x, %s\n",
1087 portstatus, portchange,
Stefan Roesef1c1f542009-01-22 10:11:21 +01001088 portspeed(portstatus));
Michael Trimarchi366523c2008-12-18 10:05:37 +01001089
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001090 USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
1091 " USB_PORT_STAT_ENABLE %d\n",
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001092 (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
1093 (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
1094 (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001095
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001096 if ((portchange & USB_PORT_STAT_C_CONNECTION) ||
1097 !(portstatus & USB_PORT_STAT_CONNECTION))
1098 return -1;
1099
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001100 if (portstatus & USB_PORT_STAT_ENABLE)
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001101 break;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001102
1103 wait_ms(200);
1104 }
1105
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001106 if (tries == MAX_TRIES) {
1107 USB_HUB_PRINTF("Cannot enable port %i after %i retries, " \
1108 "disabling port.\n", port + 1, MAX_TRIES);
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001109 USB_HUB_PRINTF("Maybe the USB cable is bad?\n");
1110 return -1;
1111 }
1112
1113 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
1114 *portstat = portstatus;
1115 return 0;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001116}
1117
1118
wdenkaffae2b2002-08-17 09:36:01 +00001119void usb_hub_port_connect_change(struct usb_device *dev, int port)
1120{
1121 struct usb_device *usb;
1122 struct usb_port_status portsts;
1123 unsigned short portstatus, portchange;
wdenkaffae2b2002-08-17 09:36:01 +00001124
1125 /* Check status */
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001126 if (usb_get_port_status(dev, port + 1, &portsts) < 0) {
wdenkaffae2b2002-08-17 09:36:01 +00001127 USB_HUB_PRINTF("get_port_status failed\n");
1128 return;
1129 }
1130
Christian Eggersc9182612008-05-21 22:12:00 +02001131 portstatus = le16_to_cpu(portsts.wPortStatus);
1132 portchange = le16_to_cpu(portsts.wPortChange);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001133 USB_HUB_PRINTF("portstatus %x, change %x, %s\n",
Stefan Roesef1c1f542009-01-22 10:11:21 +01001134 portstatus, portchange, portspeed(portstatus));
wdenkaffae2b2002-08-17 09:36:01 +00001135
1136 /* Clear the connection change status */
1137 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);
1138
1139 /* Disconnect any existing devices under this port */
1140 if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001141 (!(portstatus & USB_PORT_STAT_ENABLE))) || (dev->children[port])) {
wdenkaffae2b2002-08-17 09:36:01 +00001142 USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n");
1143 /* Return now if nothing is connected */
1144 if (!(portstatus & USB_PORT_STAT_CONNECTION))
1145 return;
1146 }
1147 wait_ms(200);
1148
1149 /* Reset the port */
Wolfgang Denk9c998aa2005-07-21 11:57:57 +02001150 if (hub_port_reset(dev, port, &portstatus) < 0) {
1151 printf("cannot reset port %i!?\n", port + 1);
wdenkaffae2b2002-08-17 09:36:01 +00001152 return;
1153 }
1154
wdenkaffae2b2002-08-17 09:36:01 +00001155 wait_ms(200);
1156
1157 /* Allocate a new device struct for it */
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001158 usb = usb_alloc_new_device();
Michael Trimarchi366523c2008-12-18 10:05:37 +01001159
1160 if (portstatus & USB_PORT_STAT_HIGH_SPEED)
1161 usb->speed = USB_SPEED_HIGH;
1162 else if (portstatus & USB_PORT_STAT_LOW_SPEED)
1163 usb->speed = USB_SPEED_LOW;
1164 else
1165 usb->speed = USB_SPEED_FULL;
wdenkaffae2b2002-08-17 09:36:01 +00001166
1167 dev->children[port] = usb;
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001168 usb->parent = dev;
wdenkaffae2b2002-08-17 09:36:01 +00001169 /* Run it through the hoops (find a driver, etc) */
1170 if (usb_new_device(usb)) {
1171 /* Woops, disable the port */
1172 USB_HUB_PRINTF("hub: disabling port %d\n", port + 1);
1173 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
1174 }
1175}
1176
1177
1178int usb_hub_configure(struct usb_device *dev)
1179{
wdenkcd0a9de2004-02-23 20:48:38 +00001180 unsigned char buffer[USB_BUFSIZ], *bitmap;
wdenkaffae2b2002-08-17 09:36:01 +00001181 struct usb_hub_descriptor *descriptor;
1182 struct usb_hub_status *hubsts;
1183 int i;
1184 struct usb_hub_device *hub;
1185
1186 /* "allocate" Hub device */
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001187 hub = usb_hub_allocate();
1188 if (hub == NULL)
wdenkaffae2b2002-08-17 09:36:01 +00001189 return -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001190 hub->pusb_dev = dev;
wdenkaffae2b2002-08-17 09:36:01 +00001191 /* Get the the hub descriptor */
1192 if (usb_get_hub_descriptor(dev, buffer, 4) < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001193 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1194 "descriptor, giving up %lX\n", dev->status);
wdenkaffae2b2002-08-17 09:36:01 +00001195 return -1;
1196 }
1197 descriptor = (struct usb_hub_descriptor *)buffer;
wdenkcd0a9de2004-02-23 20:48:38 +00001198
wdenke86e5a02004-10-17 21:12:06 +00001199 /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
1200 i = descriptor->bLength;
1201 if (i > USB_BUFSIZ) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001202 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1203 "descriptor - too long: %d\n",
1204 descriptor->bLength);
wdenkcd0a9de2004-02-23 20:48:38 +00001205 return -1;
1206 }
1207
wdenkaffae2b2002-08-17 09:36:01 +00001208 if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001209 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1210 "descriptor 2nd giving up %lX\n", dev->status);
wdenkaffae2b2002-08-17 09:36:01 +00001211 return -1;
1212 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001213 memcpy((unsigned char *)&hub->desc, buffer, descriptor->bLength);
wdenkaffae2b2002-08-17 09:36:01 +00001214 /* adjust 16bit values */
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001215 hub->desc.wHubCharacteristics =
1216 le16_to_cpu(descriptor->wHubCharacteristics);
wdenkaffae2b2002-08-17 09:36:01 +00001217 /* set the bitmap */
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001218 bitmap = (unsigned char *)&hub->desc.DeviceRemovable[0];
1219 /* devices not removable by default */
1220 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8);
1221 bitmap = (unsigned char *)&hub->desc.PortPowerCtrlMask[0];
1222 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */
1223
1224 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
1225 hub->desc.DeviceRemovable[i] = descriptor->DeviceRemovable[i];
1226
1227 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
Alexander Hollercb440912011-01-27 22:50:07 +01001228 hub->desc.PortPowerCtrlMask[i] = descriptor->PortPowerCtrlMask[i];
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001229
wdenkaffae2b2002-08-17 09:36:01 +00001230 dev->maxchild = descriptor->bNbrPorts;
1231 USB_HUB_PRINTF("%d ports detected\n", dev->maxchild);
1232
1233 switch (hub->desc.wHubCharacteristics & HUB_CHAR_LPSM) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001234 case 0x00:
1235 USB_HUB_PRINTF("ganged power switching\n");
1236 break;
1237 case 0x01:
1238 USB_HUB_PRINTF("individual port power switching\n");
1239 break;
1240 case 0x02:
1241 case 0x03:
1242 USB_HUB_PRINTF("unknown reserved power switching mode\n");
1243 break;
wdenkaffae2b2002-08-17 09:36:01 +00001244 }
1245
1246 if (hub->desc.wHubCharacteristics & HUB_CHAR_COMPOUND)
1247 USB_HUB_PRINTF("part of a compound device\n");
1248 else
1249 USB_HUB_PRINTF("standalone hub\n");
1250
1251 switch (hub->desc.wHubCharacteristics & HUB_CHAR_OCPM) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001252 case 0x00:
1253 USB_HUB_PRINTF("global over-current protection\n");
1254 break;
1255 case 0x08:
1256 USB_HUB_PRINTF("individual port over-current protection\n");
1257 break;
1258 case 0x10:
1259 case 0x18:
1260 USB_HUB_PRINTF("no over-current protection\n");
1261 break;
wdenkaffae2b2002-08-17 09:36:01 +00001262 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001263
1264 USB_HUB_PRINTF("power on to power good time: %dms\n",
1265 descriptor->bPwrOn2PwrGood * 2);
1266 USB_HUB_PRINTF("hub controller current requirement: %dmA\n",
1267 descriptor->bHubContrCurrent);
1268
wdenkaffae2b2002-08-17 09:36:01 +00001269 for (i = 0; i < dev->maxchild; i++)
1270 USB_HUB_PRINTF("port %d is%s removable\n", i + 1,
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001271 hub->desc.DeviceRemovable[(i + 1) / 8] & \
1272 (1 << ((i + 1) % 8)) ? " not" : "");
1273
wdenkcd0a9de2004-02-23 20:48:38 +00001274 if (sizeof(struct usb_hub_status) > USB_BUFSIZ) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001275 USB_HUB_PRINTF("usb_hub_configure: failed to get Status - " \
1276 "too long: %d\n", descriptor->bLength);
wdenkcd0a9de2004-02-23 20:48:38 +00001277 return -1;
1278 }
1279
wdenkaffae2b2002-08-17 09:36:01 +00001280 if (usb_get_hub_status(dev, buffer) < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001281 USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",
1282 dev->status);
wdenkaffae2b2002-08-17 09:36:01 +00001283 return -1;
1284 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001285
wdenkaffae2b2002-08-17 09:36:01 +00001286 hubsts = (struct usb_hub_status *)buffer;
1287 USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n",
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001288 le16_to_cpu(hubsts->wHubStatus),
1289 le16_to_cpu(hubsts->wHubChange));
wdenkaffae2b2002-08-17 09:36:01 +00001290 USB_HUB_PRINTF("local power source is %s\n",
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001291 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \
1292 "lost (inactive)" : "good");
wdenkaffae2b2002-08-17 09:36:01 +00001293 USB_HUB_PRINTF("%sover-current condition exists\n",
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001294 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \
1295 "" : "no ");
wdenkaffae2b2002-08-17 09:36:01 +00001296 usb_hub_power_on(hub);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001297
wdenkaffae2b2002-08-17 09:36:01 +00001298 for (i = 0; i < dev->maxchild; i++) {
1299 struct usb_port_status portsts;
1300 unsigned short portstatus, portchange;
1301
1302 if (usb_get_port_status(dev, i + 1, &portsts) < 0) {
1303 USB_HUB_PRINTF("get_port_status failed\n");
1304 continue;
1305 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001306
Christian Eggersc9182612008-05-21 22:12:00 +02001307 portstatus = le16_to_cpu(portsts.wPortStatus);
1308 portchange = le16_to_cpu(portsts.wPortChange);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001309 USB_HUB_PRINTF("Port %d Status %X Change %X\n",
1310 i + 1, portstatus, portchange);
1311
wdenkaffae2b2002-08-17 09:36:01 +00001312 if (portchange & USB_PORT_STAT_C_CONNECTION) {
1313 USB_HUB_PRINTF("port %d connection change\n", i + 1);
1314 usb_hub_port_connect_change(dev, i);
1315 }
1316 if (portchange & USB_PORT_STAT_C_ENABLE) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001317 USB_HUB_PRINTF("port %d enable change, status %x\n",
1318 i + 1, portstatus);
1319 usb_clear_port_feature(dev, i + 1,
1320 USB_PORT_FEAT_C_ENABLE);
wdenkaffae2b2002-08-17 09:36:01 +00001321
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001322 /* EM interference sometimes causes bad shielded USB
1323 * devices to be shutdown by the hub, this hack enables
1324 * them again. Works at least with mouse driver */
wdenkaffae2b2002-08-17 09:36:01 +00001325 if (!(portstatus & USB_PORT_STAT_ENABLE) &&
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001326 (portstatus & USB_PORT_STAT_CONNECTION) &&
1327 ((dev->children[i]))) {
1328 USB_HUB_PRINTF("already running port %i " \
1329 "disabled by hub (EMI?), " \
1330 "re-enabling...\n", i + 1);
wdenkaffae2b2002-08-17 09:36:01 +00001331 usb_hub_port_connect_change(dev, i);
1332 }
1333 }
1334 if (portstatus & USB_PORT_STAT_SUSPEND) {
1335 USB_HUB_PRINTF("port %d suspend change\n", i + 1);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001336 usb_clear_port_feature(dev, i + 1,
1337 USB_PORT_FEAT_SUSPEND);
wdenkaffae2b2002-08-17 09:36:01 +00001338 }
1339
1340 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
1341 USB_HUB_PRINTF("port %d over-current change\n", i + 1);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001342 usb_clear_port_feature(dev, i + 1,
1343 USB_PORT_FEAT_C_OVER_CURRENT);
wdenkaffae2b2002-08-17 09:36:01 +00001344 usb_hub_power_on(hub);
1345 }
1346
1347 if (portchange & USB_PORT_STAT_C_RESET) {
1348 USB_HUB_PRINTF("port %d reset change\n", i + 1);
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001349 usb_clear_port_feature(dev, i + 1,
1350 USB_PORT_FEAT_C_RESET);
wdenkaffae2b2002-08-17 09:36:01 +00001351 }
1352 } /* end for i all ports */
1353
1354 return 0;
1355}
1356
1357int usb_hub_probe(struct usb_device *dev, int ifnum)
1358{
Tom Rix8f8bd562009-10-31 12:37:38 -05001359 struct usb_interface *iface;
wdenkaffae2b2002-08-17 09:36:01 +00001360 struct usb_endpoint_descriptor *ep;
1361 int ret;
1362
1363 iface = &dev->config.if_desc[ifnum];
1364 /* Is it a hub? */
Tom Rix8f8bd562009-10-31 12:37:38 -05001365 if (iface->desc.bInterfaceClass != USB_CLASS_HUB)
wdenkaffae2b2002-08-17 09:36:01 +00001366 return 0;
1367 /* Some hubs have a subclass of 1, which AFAICT according to the */
1368 /* specs is not defined, but it works */
Tom Rix8f8bd562009-10-31 12:37:38 -05001369 if ((iface->desc.bInterfaceSubClass != 0) &&
1370 (iface->desc.bInterfaceSubClass != 1))
wdenkaffae2b2002-08-17 09:36:01 +00001371 return 0;
1372 /* Multiple endpoints? What kind of mutant ninja-hub is this? */
Tom Rix8f8bd562009-10-31 12:37:38 -05001373 if (iface->desc.bNumEndpoints != 1)
wdenkaffae2b2002-08-17 09:36:01 +00001374 return 0;
1375 ep = &iface->ep_desc[0];
1376 /* Output endpoint? Curiousier and curiousier.. */
1377 if (!(ep->bEndpointAddress & USB_DIR_IN))
1378 return 0;
1379 /* If it's not an interrupt endpoint, we'd better punt! */
1380 if ((ep->bmAttributes & 3) != 3)
1381 return 0;
1382 /* We found a hub */
1383 USB_HUB_PRINTF("USB hub found\n");
Remy Bohmer6f5794a2008-09-16 14:55:43 +02001384 ret = usb_hub_configure(dev);
wdenkaffae2b2002-08-17 09:36:01 +00001385 return ret;
1386}
1387
wdenkaffae2b2002-08-17 09:36:01 +00001388/* EOF */