source: SVN/rincon/u-boot/common/usb.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 36.1 KB
Line 
1/*
2 *
3 * Most of this source has been derived from the Linux USB
4 * 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
17 *
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
38/*
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>
50#include <linux/ctype.h>
51#include <asm/byteorder.h>
52
53#include <usb.h>
54#ifdef CONFIG_4xx
55#include <asm/4xx_pci.h>
56#endif
57
58#undef USB_DEBUG
59
60#ifdef  USB_DEBUG
61#define USB_PRINTF(fmt,args...) printf (fmt ,##args)
62#else
63#define USB_PRINTF(fmt,args...)
64#endif
65
66#define USB_BUFSIZ      512
67
68static struct usb_device usb_dev[USB_MAX_DEVICE];
69static int dev_index;
70static int running;
71static int asynch_allowed;
72static struct devrequest setup_packet;
73
74char usb_started; /* flag for the started/stopped USB status */
75
76/**********************************************************************
77 * some forward declerations...
78 */
79void usb_scan_devices(void);
80
81int usb_hub_probe(struct usb_device *dev, int ifnum);
82void usb_hub_reset(void);
83
84
85/***********************************************************************
86 * wait_ms
87 */
88
89void __inline__ wait_ms(unsigned long ms)
90{
91        while(ms-->0)
92                udelay(1000);
93}
94/***************************************************************************
95 * Init USB Device
96 */
97
98int usb_init(void)
99{
100        int result;
101
102        running=0;
103        dev_index=0;
104        asynch_allowed=1;
105        usb_hub_reset();
106        /* init low_level USB */
107        printf("USB:   ");
108        result = usb_lowlevel_init();
109        /* if lowlevel init is OK, scan the bus for devices i.e. search HUBs and configure them */
110        if(result==0) {
111                printf("scanning bus for devices... ");
112                running=1;
113                usb_scan_devices();
114                usb_started = 1;
115                return 0;
116        }
117        else {
118                printf("Error, couldn't init Lowlevel part\n");
119                usb_started = 0;
120                return -1;
121        }
122}
123
124/******************************************************************************
125 * Stop USB this stops the LowLevel Part and deregisters USB devices.
126 */
127int usb_stop(void)
128{
129        int res = 0;
130
131        if (usb_started) {
132                asynch_allowed = 1;
133                usb_started = 0;
134                usb_hub_reset();
135                res = usb_lowlevel_stop();
136        }
137        return res;
138}
139
140/*
141 * disables the asynch behaviour of the control message. This is used for data
142 * transfers that uses the exclusiv access to the control and bulk messages.
143 */
144void usb_disable_asynch(int disable)
145{
146        asynch_allowed=!disable;
147}
148
149
150/*-------------------------------------------------------------------
151 * Message wrappers.
152 *
153 */
154
155/*
156 * submits an Interrupt Message
157 */
158int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
159                        void *buffer,int transfer_len, int interval)
160{
161        return submit_int_msg(dev,pipe,buffer,transfer_len,interval);
162}
163
164/*
165 * submits a control message and waits for comletion (at least timeout * 1ms)
166 * If timeout is 0, we don't wait for completion (used as example to set and
167 * clear keyboards LEDs). For data transfers, (storage transfers) we don't
168 * allow control messages with 0 timeout, by previousely resetting the flag
169 * asynch_allowed (usb_disable_asynch(1)).
170 * returns the transfered length if OK or -1 if error. The transfered length
171 * and the current status are stored in the dev->act_len and dev->status.
172 */
173int usb_control_msg(struct usb_device *dev, unsigned int pipe,
174                        unsigned char request, unsigned char requesttype,
175                        unsigned short value, unsigned short index,
176                        void *data, unsigned short size, int timeout)
177{
178        if((timeout==0)&&(!asynch_allowed)) /* request for a asynch control pipe is not allowed */
179                return -1;
180
181        /* set setup command */
182        setup_packet.requesttype = requesttype;
183        setup_packet.request = request;
184        setup_packet.value = cpu_to_le16(value);
185        setup_packet.index = cpu_to_le16(index);
186        setup_packet.length = cpu_to_le16(size);
187        USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X, value 0x%X index 0x%X length 0x%X\n",
188                request,requesttype,value,index,size);
189        dev->status=USB_ST_NOT_PROC; /*not yet processed */
190
191        submit_control_msg(dev,pipe,data,size,&setup_packet);
192        if(timeout==0) {
193                return (int)size;
194        }
195        while(timeout--) {
196                if(!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
197                        break;
198                wait_ms(1);
199        }
200        if(dev->status==0)
201                return dev->act_len;
202        else {
203                return -1;
204        }
205}
206
207/*-------------------------------------------------------------------
208 * submits bulk message, and waits for completion. returns 0 if Ok or
209 * -1 if Error.
210 * synchronous behavior
211 */
212int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
213                        void *data, int len, int *actual_length, int timeout)
214{
215        if (len < 0)
216                return -1;
217        dev->status=USB_ST_NOT_PROC; /*not yet processed */
218        submit_bulk_msg(dev,pipe,data,len);
219        while(timeout--) {
220                if(!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
221                        break;
222                wait_ms(1);
223        }
224        *actual_length=dev->act_len;
225        if(dev->status==0)
226                return 0;
227        else
228                return -1;
229}
230
231
232/*-------------------------------------------------------------------
233 * Max Packet stuff
234 */
235
236/*
237 * returns the max packet size, depending on the pipe direction and
238 * the configurations values
239 */
240int usb_maxpacket(struct usb_device *dev,unsigned long pipe)
241{
242        if((pipe & USB_DIR_IN)==0) /* direction is out -> use emaxpacket out */
243                return(dev->epmaxpacketout[((pipe>>15) & 0xf)]);
244        else
245                return(dev->epmaxpacketin[((pipe>>15) & 0xf)]);
246}
247
248/*
249 * set the max packed value of all endpoints in the given configuration
250 */
251int usb_set_maxpacket(struct usb_device *dev)
252{
253        int i,ii,b;
254        struct usb_endpoint_descriptor *ep;
255
256        for(i=0; i<dev->config.bNumInterfaces;i++) {
257                for(ii=0; ii<dev->config.if_desc[i].bNumEndpoints; ii++) {
258                        ep = &dev->config.if_desc[i].ep_desc[ii];
259                        b=ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
260
261                        if((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)==USB_ENDPOINT_XFER_CONTROL) {        /* Control => bidirectional */
262                                dev->epmaxpacketout[b] = ep->wMaxPacketSize;
263                                dev->epmaxpacketin [b] = ep->wMaxPacketSize;
264                                USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",b,dev->epmaxpacketin[b]);
265                        }
266                        else {
267                                if ((ep->bEndpointAddress & 0x80)==0) { /* OUT Endpoint */
268                                        if(ep->wMaxPacketSize > dev->epmaxpacketout[b]) {
269                                                dev->epmaxpacketout[b] = ep->wMaxPacketSize;
270                                                USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",b,dev->epmaxpacketout[b]);
271                                        }
272                                }
273                                else  { /* IN Endpoint */
274                                        if(ep->wMaxPacketSize > dev->epmaxpacketin[b]) {
275                                                dev->epmaxpacketin[b] = ep->wMaxPacketSize;
276                                                USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",b,dev->epmaxpacketin[b]);
277                                        }
278                                } /* if out */
279                        } /* if control */
280                } /* for each endpoint */
281        }
282        return 0;
283}
284
285/*******************************************************************************
286 * Parse the config, located in buffer, and fills the dev->config structure.
287 * Note that all little/big endian swapping are done automatically.
288 */
289int usb_parse_config(struct usb_device *dev, unsigned char *buffer, int cfgno)
290{
291        struct usb_descriptor_header *head;
292        int index, ifno, epno, curr_if_num;
293        int i;
294        unsigned char *ch;
295
296        ifno = -1;
297        epno = -1;
298        curr_if_num = -1;
299
300        dev->configno = cfgno;
301        head = (struct usb_descriptor_header *) &buffer[0];
302        if(head->bDescriptorType != USB_DT_CONFIG) {
303                printf(" ERROR: NOT USB_CONFIG_DESC %x\n", head->bDescriptorType);
304                return -1;
305        }
306        memcpy(&dev->config, buffer, buffer[0]);
307        le16_to_cpus(&(dev->config.wTotalLength));
308        dev->config.no_of_if = 0;
309
310        index = dev->config.bLength;
311        /* Ok the first entry must be a configuration entry, now process the others */
312        head = (struct usb_descriptor_header *) &buffer[index];
313        while(index + 1 < dev->config.wTotalLength) {
314                switch(head->bDescriptorType) {
315                        case USB_DT_INTERFACE:
316                                if(((struct usb_interface_descriptor *) &buffer[index])->
317                                        bInterfaceNumber != curr_if_num) {
318                                        /* this is a new interface, copy new desc */
319                                        ifno = dev->config.no_of_if;
320                                        dev->config.no_of_if++;
321                                        memcpy(&dev->config.if_desc[ifno],
322                                                &buffer[index], buffer[index]);
323                                        dev->config.if_desc[ifno].no_of_ep = 0;
324                                        dev->config.if_desc[ifno].num_altsetting = 1;
325                                        curr_if_num = dev->config.if_desc[ifno].bInterfaceNumber;
326                                } else {
327                                        /* found alternate setting for the interface */
328                                        dev->config.if_desc[ifno].num_altsetting++;
329                                }
330                                break;
331                        case USB_DT_ENDPOINT:
332                                epno = dev->config.if_desc[ifno].no_of_ep;
333                                dev->config.if_desc[ifno].no_of_ep++; /* found an endpoint */
334                                memcpy(&dev->config.if_desc[ifno].ep_desc[epno],
335                                        &buffer[index], buffer[index]);
336                                le16_to_cpus(&(dev->config.if_desc[ifno].ep_desc[epno].wMaxPacketSize));
337                                USB_PRINTF("if %d, ep %d\n", ifno, epno);
338                                break;
339                        default:
340                                if(head->bLength == 0)
341                                        return 1;
342                                USB_PRINTF("unknown Description Type : %x\n", head->bDescriptorType);
343                                {
344                                        ch = (unsigned char *)head;
345                                        for(i = 0; i < head->bLength; i++)
346                                                USB_PRINTF("%02X ", *ch++);
347                                        USB_PRINTF("\n\n\n");
348                                }
349                                break;
350                }
351                index += head->bLength;
352                head = (struct usb_descriptor_header *)&buffer[index];
353        }
354        return 1;
355}
356
357/***********************************************************************
358 * Clears an endpoint
359 * endp: endpoint number in bits 0-3;
360 * direction flag in bit 7 (1 = IN, 0 = OUT)
361 */
362int usb_clear_halt(struct usb_device *dev, int pipe)
363{
364        int result;
365        int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
366
367        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
368                USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
369
370        /* don't clear if failed */
371        if (result < 0)
372                return result;
373
374        /*
375         * NOTE: we do not get status and verify reset was successful
376         * as some devices are reported to lock up upon this check..
377         */
378
379        usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
380
381        /* toggle is reset on clear */
382        usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
383        return 0;
384}
385
386
387/**********************************************************************
388 * get_descriptor type
389 */
390int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size)
391{
392        int res;
393        res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
394                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
395                        (type << 8) + index, 0,
396                        buf, size, USB_CNTL_TIMEOUT);
397        return res;
398}
399
400/**********************************************************************
401 * gets configuration cfgno and store it in the buffer
402 */
403int usb_get_configuration_no(struct usb_device *dev,unsigned char *buffer,int cfgno)
404{
405        int result;
406        unsigned int tmp;
407        struct usb_config_descriptor *config;
408
409
410        config=(struct usb_config_descriptor *)&buffer[0];
411        result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8);
412        if (result < 8) {
413                if (result < 0)
414                        printf("unable to get descriptor, error %lX\n",dev->status);
415                else
416                        printf("config descriptor too short (expected %i, got %i)\n",8,result);
417                return -1;
418        }
419        tmp = le16_to_cpu(config->wTotalLength);
420
421        if (tmp > USB_BUFSIZ) {
422                USB_PRINTF("usb_get_configuration_no: failed to get descriptor - too long: %d\n",
423                        tmp);
424                return -1;
425        }
426
427        result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, tmp);
428        USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",cfgno,result,tmp);
429        return result;
430}
431
432/********************************************************************
433 * set address of a device to the value in dev->devnum.
434 * This can only be done by addressing the device via the default address (0)
435 */
436int usb_set_address(struct usb_device *dev)
437{
438        int res;
439
440        USB_PRINTF("set address %d\n",dev->devnum);
441        res=usb_control_msg(dev, usb_snddefctrl(dev),
442                USB_REQ_SET_ADDRESS, 0,
443                (dev->devnum),0,
444                NULL,0, USB_CNTL_TIMEOUT);
445        return res;
446}
447
448/********************************************************************
449 * set interface number to interface
450 */
451int usb_set_interface(struct usb_device *dev, int interface, int alternate)
452{
453        struct usb_interface_descriptor *if_face = NULL;
454        int ret, i;
455
456        for (i = 0; i < dev->config.bNumInterfaces; i++) {
457                if (dev->config.if_desc[i].bInterfaceNumber == interface) {
458                        if_face = &dev->config.if_desc[i];
459                        break;
460                }
461        }
462        if (!if_face) {
463                printf("selecting invalid interface %d", interface);
464                return -1;
465        }
466        /*
467         * We should return now for devices with only one alternate setting.
468         * According to 9.4.10 of the Universal Serial Bus Specification Revision 2.0
469         * such devices can return with a STALL. This results in some USB sticks
470         * timeouting during initialization and then being unusable in U-Boot.
471         */
472        if (if_face->num_altsetting == 1)
473                return 0;
474
475        if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
476            USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, alternate,
477            interface, NULL, 0, USB_CNTL_TIMEOUT * 5)) < 0)
478                return ret;
479
480        return 0;
481}
482
483/********************************************************************
484 * set configuration number to configuration
485 */
486int usb_set_configuration(struct usb_device *dev, int configuration)
487{
488        int res;
489        USB_PRINTF("set configuration %d\n",configuration);
490        /* set setup command */
491        res=usb_control_msg(dev, usb_sndctrlpipe(dev,0),
492                USB_REQ_SET_CONFIGURATION, 0,
493                configuration,0,
494                NULL,0, USB_CNTL_TIMEOUT);
495        if(res==0) {
496                dev->toggle[0] = 0;
497                dev->toggle[1] = 0;
498                return 0;
499        }
500        else
501                return -1;
502}
503
504/********************************************************************
505 * set protocol to protocol
506 */
507int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
508{
509        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
510                USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
511                protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
512}
513
514/********************************************************************
515 * set idle
516 */
517int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
518{
519        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
520                USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
521                (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
522}
523
524/********************************************************************
525 * get report
526 */
527int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size)
528{
529        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
530                USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
531                (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
532}
533
534/********************************************************************
535 * get class descriptor
536 */
537int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
538                unsigned char type, unsigned char id, void *buf, int size)
539{
540        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
541                USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
542                (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
543}
544
545/********************************************************************
546 * get string index in buffer
547 */
548int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size)
549{
550        int i;
551        int result;
552
553        for (i = 0; i < 3; ++i) {
554                /* some devices are flaky */
555                result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
556                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
557                        (USB_DT_STRING << 8) + index, langid, buf, size,
558                        USB_CNTL_TIMEOUT);
559
560                if (result > 0)
561                        break;
562        }
563
564        return result;
565}
566
567
568static void usb_try_string_workarounds(unsigned char *buf, int *length)
569{
570        int newlength, oldlength = *length;
571
572        for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
573                if (!isprint(buf[newlength]) || buf[newlength + 1])
574                        break;
575
576        if (newlength > 2) {
577                buf[0] = newlength;
578                *length = newlength;
579        }
580}
581
582
583static int usb_string_sub(struct usb_device *dev, unsigned int langid,
584                unsigned int index, unsigned char *buf)
585{
586        int rc;
587
588        /* Try to read the string descriptor by asking for the maximum
589         * possible number of bytes */
590        rc = usb_get_string(dev, langid, index, buf, 255);
591
592        /* If that failed try to read the descriptor length, then
593         * ask for just that many bytes */
594        if (rc < 2) {
595                rc = usb_get_string(dev, langid, index, buf, 2);
596                if (rc == 2)
597                        rc = usb_get_string(dev, langid, index, buf, buf[0]);
598        }
599
600        if (rc >= 2) {
601                if (!buf[0] && !buf[1])
602                        usb_try_string_workarounds(buf, &rc);
603
604                /* There might be extra junk at the end of the descriptor */
605                if (buf[0] < rc)
606                        rc = buf[0];
607
608                rc = rc - (rc & 1); /* force a multiple of two */
609        }
610
611        if (rc < 2)
612                rc = -1;
613
614        return rc;
615}
616
617
618/********************************************************************
619 * usb_string:
620 * Get string index and translate it to ascii.
621 * returns string length (> 0) or error (< 0)
622 */
623int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
624{
625        unsigned char mybuf[USB_BUFSIZ];
626        unsigned char *tbuf;
627        int err;
628        unsigned int u, idx;
629
630        if (size <= 0 || !buf || !index)
631                return -1;
632        buf[0] = 0;
633        tbuf = &mybuf[0];
634
635        /* get langid for strings if it's not yet known */
636        if (!dev->have_langid) {
637                err = usb_string_sub(dev, 0, 0, tbuf);
638                if (err < 0) {
639                        USB_PRINTF("error getting string descriptor 0 (error=%x)\n",dev->status);
640                        return -1;
641                } else if (tbuf[0] < 4) {
642                        USB_PRINTF("string descriptor 0 too short\n");
643                        return -1;
644                } else {
645                        dev->have_langid = -1;
646                        dev->string_langid = tbuf[2] | (tbuf[3]<< 8);
647                                /* always use the first langid listed */
648                        USB_PRINTF("USB device number %d default language ID 0x%x\n",
649                                dev->devnum, dev->string_langid);
650                }
651        }
652
653        err = usb_string_sub(dev, dev->string_langid, index, tbuf);
654        if (err < 0)
655                return err;
656
657        size--;         /* leave room for trailing NULL char in output buffer */
658        for (idx = 0, u = 2; u < err; u += 2) {
659                if (idx >= size)
660                        break;
661                if (tbuf[u+1])                  /* high byte */
662                        buf[idx++] = '?';  /* non-ASCII character */
663                else
664                        buf[idx++] = tbuf[u];
665        }
666        buf[idx] = 0;
667        err = idx;
668        return err;
669}
670
671
672/********************************************************************
673 * USB device handling:
674 * the USB device are static allocated [USB_MAX_DEVICE].
675 */
676
677
678/* returns a pointer to the device with the index [index].
679 * if the device is not assigned (dev->devnum==-1) returns NULL
680 */
681struct usb_device * usb_get_dev_index(int index)
682{
683        if(usb_dev[index].devnum==-1)
684                return NULL;
685        else
686                return &usb_dev[index];
687}
688
689
690/* returns a pointer of a new device structure or NULL, if
691 * no device struct is available
692 */
693struct usb_device * usb_alloc_new_device(void)
694{
695        int i;
696        USB_PRINTF("New Device %d\n",dev_index);
697        if(dev_index==USB_MAX_DEVICE) {
698                printf("ERROR, too many USB Devices, max=%d\n",USB_MAX_DEVICE);
699                return NULL;
700        }
701        usb_dev[dev_index].devnum=dev_index+1; /* default Address is 0, real addresses start with 1 */
702        usb_dev[dev_index].maxchild=0;
703        for(i=0;i<USB_MAXCHILDREN;i++)
704                usb_dev[dev_index].children[i]=NULL;
705        usb_dev[dev_index].parent=NULL;
706        dev_index++;
707        return &usb_dev[dev_index-1];
708}
709
710
711/*
712 * By the time we get here, the device has gotten a new device ID
713 * and is in the default state. We need to identify the thing and
714 * get the ball rolling..
715 *
716 * Returns 0 for success, != 0 for error.
717 */
718int usb_new_device(struct usb_device *dev)
719{
720        int addr, err;
721        int tmp;
722        unsigned char tmpbuf[USB_BUFSIZ];
723
724        dev->descriptor.bMaxPacketSize0 = 8;  /* Start off at 8 bytes  */
725        dev->maxpacketsize = 0;         /* Default to 8 byte max packet size */
726        dev->epmaxpacketin [0] = 8;
727        dev->epmaxpacketout[0] = 8;
728
729        /* We still haven't set the Address yet */
730        addr = dev->devnum;
731        dev->devnum = 0;
732
733#undef NEW_INIT_SEQ
734#ifdef NEW_INIT_SEQ
735        /* this is a Windows scheme of initialization sequence, with double
736         * reset of the device. Some equipment is said to work only with such
737         * init sequence; this patch is based on the work by Alan Stern:
738         * http://sourceforge.net/mailarchive/forum.php?thread_id=5729457&forum_id=5398
739         */
740        int j;
741        struct usb_device_descriptor *desc;
742        int port = -1;
743        struct usb_device *parent = dev->parent;
744        unsigned short portstatus;
745
746        /* send 64-byte GET-DEVICE-DESCRIPTOR request.  Since the descriptor is
747         * only 18 bytes long, this will terminate with a short packet.  But if
748         * the maxpacket size is 8 or 16 the device may be waiting to transmit
749         * some more. */
750
751        desc = (struct usb_device_descriptor *)tmpbuf;
752        desc->bMaxPacketSize0 = 0;
753        for (j = 0; j < 3; ++j) {
754                err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
755                if (err < 0) {
756                        USB_PRINTF("usb_new_device: 64 byte descr\n");
757                        break;
758                }
759        }
760        dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0;
761
762        /* find the port number we're at */
763        if (parent) {
764
765                for (j = 0; j < parent->maxchild; j++) {
766                        if (parent->children[j] == dev) {
767                                port = j;
768                                break;
769                        }
770                }
771                if (port < 0) {
772                        printf("usb_new_device: cannot locate device's port..\n");
773                        return 1;
774                }
775
776                /* reset the port for the second time */
777                err = hub_port_reset(dev->parent, port, &portstatus);
778                if (err < 0) {
779                        printf("\n     Couldn't reset port %i\n", port);
780                        return 1;
781                }
782        }
783#else
784        /* and this is the old and known way of initializing devices */
785        err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
786        if (err < 8) {
787                printf("\n      USB device not responding, giving up (status=%lX)\n",dev->status);
788                return 1;
789        }
790#endif
791
792        dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0;
793        dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
794        switch (dev->descriptor.bMaxPacketSize0) {
795                case 8: dev->maxpacketsize = 0; break;
796                case 16: dev->maxpacketsize = 1; break;
797                case 32: dev->maxpacketsize = 2; break;
798                case 64: dev->maxpacketsize = 3; break;
799        }
800        dev->devnum = addr;
801
802        err = usb_set_address(dev); /* set address */
803
804        if (err < 0) {
805                printf("\n      USB device not accepting new address (error=%lX)\n", dev->status);
806                return 1;
807        }
808
809        wait_ms(10);    /* Let the SET_ADDRESS settle */
810
811        tmp = sizeof(dev->descriptor);
812
813        err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor));
814        if (err < tmp) {
815                if (err < 0)
816                        printf("unable to get device descriptor (error=%d)\n",err);
817                else
818                        printf("USB device descriptor short read (expected %i, got %i)\n",tmp,err);
819                return 1;
820        }
821        /* correct le values */
822        le16_to_cpus(&dev->descriptor.bcdUSB);
823        le16_to_cpus(&dev->descriptor.idVendor);
824        le16_to_cpus(&dev->descriptor.idProduct);
825        le16_to_cpus(&dev->descriptor.bcdDevice);
826        /* only support for one config for now */
827        usb_get_configuration_no(dev,&tmpbuf[0],0);
828        usb_parse_config(dev,&tmpbuf[0],0);
829        usb_set_maxpacket(dev);
830        /* we set the default configuration here */
831        if (usb_set_configuration(dev, dev->config.bConfigurationValue)) {
832                printf("failed to set default configuration len %d, status %lX\n",dev->act_len,dev->status);
833                return -1;
834        }
835        USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
836                dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber);
837        memset(dev->mf, 0, sizeof(dev->mf));
838        memset(dev->prod, 0, sizeof(dev->prod));
839        memset(dev->serial, 0, sizeof(dev->serial));
840        if (dev->descriptor.iManufacturer)
841                usb_string(dev, dev->descriptor.iManufacturer, dev->mf, sizeof(dev->mf));
842        if (dev->descriptor.iProduct)
843                usb_string(dev, dev->descriptor.iProduct, dev->prod, sizeof(dev->prod));
844        if (dev->descriptor.iSerialNumber)
845                usb_string(dev, dev->descriptor.iSerialNumber, dev->serial, sizeof(dev->serial));
846        USB_PRINTF("Manufacturer %s\n", dev->mf);
847        USB_PRINTF("Product      %s\n", dev->prod);
848        USB_PRINTF("SerialNumber %s\n", dev->serial);
849        /* now prode if the device is a hub */
850        usb_hub_probe(dev,0);
851        return 0;
852}
853
854/* build device Tree  */
855void usb_scan_devices(void)
856{
857        int i;
858        struct usb_device *dev;
859
860        /* first make all devices unknown */
861        for(i=0;i<USB_MAX_DEVICE;i++) {
862                memset(&usb_dev[i],0,sizeof(struct usb_device));
863                usb_dev[i].devnum = -1;
864        }
865        dev_index=0;
866        /* device 0 is always present (root hub, so let it analyze) */
867        dev=usb_alloc_new_device();
868        usb_new_device(dev);
869        printf("%d USB Device(s) found\n",dev_index);
870        /* insert "driver" if possible */
871#ifdef CONFIG_USB_KEYBOARD
872        drv_usb_kbd_init();
873        USB_PRINTF("scan end\n");
874#endif
875}
876
877
878/****************************************************************************
879 * HUB "Driver"
880 * Probes device for being a hub and configurate it
881 */
882
883#undef  USB_HUB_DEBUG
884
885#ifdef  USB_HUB_DEBUG
886#define USB_HUB_PRINTF(fmt,args...)     printf (fmt ,##args)
887#else
888#define USB_HUB_PRINTF(fmt,args...)
889#endif
890
891
892static struct usb_hub_device hub_dev[USB_MAX_HUB];
893static int usb_hub_index;
894
895
896int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
897{
898        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
899                USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
900                USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
901}
902
903int usb_clear_hub_feature(struct usb_device *dev, int feature)
904{
905        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
906                USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, USB_CNTL_TIMEOUT);
907}
908
909int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
910{
911        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
912                USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT);
913}
914
915int usb_set_port_feature(struct usb_device *dev, int port, int feature)
916{
917        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
918                USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT);
919}
920
921int usb_get_hub_status(struct usb_device *dev, void *data)
922{
923        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
924                        USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
925                        data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
926}
927
928int usb_get_port_status(struct usb_device *dev, int port, void *data)
929{
930        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
931                        USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
932                        data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
933}
934
935
936static void usb_hub_power_on(struct usb_hub_device *hub)
937{
938        int i;
939        struct usb_device *dev;
940
941        dev=hub->pusb_dev;
942        /* Enable power to the ports */
943        USB_HUB_PRINTF("enabling power on all ports\n");
944        for (i = 0; i < dev->maxchild; i++) {
945                usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
946                USB_HUB_PRINTF("port %d returns %lX\n",i+1,dev->status);
947                wait_ms(hub->desc.bPwrOn2PwrGood * 2);
948        }
949}
950
951void usb_hub_reset(void)
952{
953        usb_hub_index=0;
954}
955
956struct usb_hub_device *usb_hub_allocate(void)
957{
958        if(usb_hub_index<USB_MAX_HUB) {
959                return &hub_dev[usb_hub_index++];
960        }
961        printf("ERROR: USB_MAX_HUB (%d) reached\n",USB_MAX_HUB);
962        return NULL;
963}
964
965#define MAX_TRIES 5
966
967static int hub_port_reset(struct usb_device *dev, int port,
968                        unsigned short *portstat)
969{
970        int tries;
971        struct usb_port_status portsts;
972        unsigned short portstatus, portchange;
973
974
975        USB_HUB_PRINTF("hub_port_reset: resetting port %d...\n", port);
976        for(tries=0;tries<MAX_TRIES;tries++) {
977
978                usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
979                wait_ms(200);
980
981                if (usb_get_port_status(dev, port + 1, &portsts)<0) {
982                        USB_HUB_PRINTF("get_port_status failed status %lX\n",dev->status);
983                        return -1;
984                }
985                portstatus = le16_to_cpu(portsts.wPortStatus);
986                portchange = le16_to_cpu(portsts.wPortChange);
987                USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus ,portchange,
988                        portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed");
989                USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d  USB_PORT_STAT_ENABLE %d\n",
990                        (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
991                        (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
992                        (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);
993                if ((portchange & USB_PORT_STAT_C_CONNECTION) ||
994                    !(portstatus & USB_PORT_STAT_CONNECTION))
995                        return -1;
996
997                if (portstatus & USB_PORT_STAT_ENABLE) {
998
999                        break;
1000                }
1001
1002                wait_ms(200);
1003        }
1004
1005        if (tries==MAX_TRIES) {
1006                USB_HUB_PRINTF("Cannot enable port %i after %i retries, disabling port.\n", port+1, MAX_TRIES);
1007                USB_HUB_PRINTF("Maybe the USB cable is bad?\n");
1008                return -1;
1009        }
1010
1011        usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
1012        *portstat = portstatus;
1013        return 0;
1014
1015}
1016
1017
1018void usb_hub_port_connect_change(struct usb_device *dev, int port)
1019{
1020        struct usb_device *usb;
1021        struct usb_port_status portsts;
1022        unsigned short portstatus, portchange;
1023
1024        /* Check status */
1025        if (usb_get_port_status(dev, port + 1, &portsts)<0) {
1026                USB_HUB_PRINTF("get_port_status failed\n");
1027                return;
1028        }
1029
1030        portstatus = le16_to_cpu(portsts.wPortStatus);
1031        portchange = le16_to_cpu(portsts.wPortChange);
1032        USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus, portchange,
1033                portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed");
1034
1035        /* Clear the connection change status */
1036        usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);
1037
1038        /* Disconnect any existing devices under this port */
1039        if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
1040             (!(portstatus & USB_PORT_STAT_ENABLE)))|| (dev->children[port])) {
1041                USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n");
1042                /* Return now if nothing is connected */
1043                if (!(portstatus & USB_PORT_STAT_CONNECTION))
1044                        return;
1045        }
1046        wait_ms(200);
1047
1048        /* Reset the port */
1049        if (hub_port_reset(dev, port, &portstatus) < 0) {
1050                printf("cannot reset port %i!?\n", port + 1);
1051                return;
1052        }
1053
1054        wait_ms(200);
1055
1056        /* Allocate a new device struct for it */
1057        usb=usb_alloc_new_device();
1058        usb->slow = (portstatus & USB_PORT_STAT_LOW_SPEED) ? 1 : 0;
1059
1060        dev->children[port] = usb;
1061        usb->parent=dev;
1062        /* Run it through the hoops (find a driver, etc) */
1063        if (usb_new_device(usb)) {
1064                /* Woops, disable the port */
1065                USB_HUB_PRINTF("hub: disabling port %d\n", port + 1);
1066                usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
1067        }
1068}
1069
1070
1071int usb_hub_configure(struct usb_device *dev)
1072{
1073        unsigned char buffer[USB_BUFSIZ], *bitmap;
1074        struct usb_hub_descriptor *descriptor;
1075        struct usb_hub_status *hubsts;
1076        int i;
1077        struct usb_hub_device *hub;
1078
1079        /* "allocate" Hub device */
1080        hub=usb_hub_allocate();
1081        if(hub==NULL)
1082                return -1;
1083        hub->pusb_dev=dev;
1084        /* Get the the hub descriptor */
1085        if (usb_get_hub_descriptor(dev, buffer, 4) < 0) {
1086                USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor, giving up %lX\n",dev->status);
1087                return -1;
1088        }
1089        descriptor = (struct usb_hub_descriptor *)buffer;
1090
1091        /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
1092        i = descriptor->bLength;
1093        if (i > USB_BUFSIZ) {
1094                USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor - too long: %d\n",
1095                        descriptor->bLength);
1096                return -1;
1097        }
1098
1099        if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 0) {
1100                USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor 2nd giving up %lX\n",dev->status);
1101                return -1;
1102        }
1103        memcpy((unsigned char *)&hub->desc,buffer,descriptor->bLength);
1104        /* adjust 16bit values */
1105        hub->desc.wHubCharacteristics = le16_to_cpu(descriptor->wHubCharacteristics);
1106        /* set the bitmap */
1107        bitmap=(unsigned char *)&hub->desc.DeviceRemovable[0];
1108        memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* devices not removable by default */
1109        bitmap=(unsigned char *)&hub->desc.PortPowerCtrlMask[0];
1110        memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */
1111        for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) {
1112                hub->desc.DeviceRemovable[i]=descriptor->DeviceRemovable[i];
1113        }
1114        for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) {
1115                hub->desc.DeviceRemovable[i]=descriptor->PortPowerCtrlMask[i];
1116        }
1117        dev->maxchild = descriptor->bNbrPorts;
1118        USB_HUB_PRINTF("%d ports detected\n", dev->maxchild);
1119
1120        switch (hub->desc.wHubCharacteristics & HUB_CHAR_LPSM) {
1121                case 0x00:
1122                        USB_HUB_PRINTF("ganged power switching\n");
1123                        break;
1124                case 0x01:
1125                        USB_HUB_PRINTF("individual port power switching\n");
1126                        break;
1127                case 0x02:
1128                case 0x03:
1129                        USB_HUB_PRINTF("unknown reserved power switching mode\n");
1130                        break;
1131        }
1132
1133        if (hub->desc.wHubCharacteristics & HUB_CHAR_COMPOUND)
1134                USB_HUB_PRINTF("part of a compound device\n");
1135        else
1136                USB_HUB_PRINTF("standalone hub\n");
1137
1138        switch (hub->desc.wHubCharacteristics & HUB_CHAR_OCPM) {
1139                case 0x00:
1140                        USB_HUB_PRINTF("global over-current protection\n");
1141                        break;
1142                case 0x08:
1143                        USB_HUB_PRINTF("individual port over-current protection\n");
1144                        break;
1145                case 0x10:
1146                case 0x18:
1147                        USB_HUB_PRINTF("no over-current protection\n");
1148      break;
1149        }
1150        USB_HUB_PRINTF("power on to power good time: %dms\n", descriptor->bPwrOn2PwrGood * 2);
1151        USB_HUB_PRINTF("hub controller current requirement: %dmA\n", descriptor->bHubContrCurrent);
1152        for (i = 0; i < dev->maxchild; i++)
1153                USB_HUB_PRINTF("port %d is%s removable\n", i + 1,
1154                        hub->desc.DeviceRemovable[(i + 1)/8] & (1 << ((i + 1)%8)) ? " not" : "");
1155        if (sizeof(struct usb_hub_status) > USB_BUFSIZ) {
1156                USB_HUB_PRINTF("usb_hub_configure: failed to get Status - too long: %d\n",
1157                        descriptor->bLength);
1158                return -1;
1159        }
1160
1161        if (usb_get_hub_status(dev, buffer) < 0) {
1162                USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",dev->status);
1163                return -1;
1164        }
1165        hubsts = (struct usb_hub_status *)buffer;
1166        USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n",
1167                le16_to_cpu(hubsts->wHubStatus),le16_to_cpu(hubsts->wHubChange));
1168        USB_HUB_PRINTF("local power source is %s\n",
1169                (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good");
1170        USB_HUB_PRINTF("%sover-current condition exists\n",
1171                (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1172        usb_hub_power_on(hub);
1173        for (i = 0; i < dev->maxchild; i++) {
1174                struct usb_port_status portsts;
1175                unsigned short portstatus, portchange;
1176
1177                if (usb_get_port_status(dev, i + 1, &portsts) < 0) {
1178                        USB_HUB_PRINTF("get_port_status failed\n");
1179                        continue;
1180                }
1181                portstatus = le16_to_cpu(portsts.wPortStatus);
1182                portchange = le16_to_cpu(portsts.wPortChange);
1183                USB_HUB_PRINTF("Port %d Status %X Change %X\n",i+1,portstatus,portchange);
1184                if (portchange & USB_PORT_STAT_C_CONNECTION) {
1185                        USB_HUB_PRINTF("port %d connection change\n", i + 1);
1186                        usb_hub_port_connect_change(dev, i);
1187                }
1188                if (portchange & USB_PORT_STAT_C_ENABLE) {
1189                        USB_HUB_PRINTF("port %d enable change, status %x\n", i + 1, portstatus);
1190                        usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
1191
1192                        /* EM interference sometimes causes bad shielded USB devices to
1193                         * be shutdown by the hub, this hack enables them again.
1194                         * Works at least with mouse driver */
1195                        if (!(portstatus & USB_PORT_STAT_ENABLE) &&
1196                                (portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) {
1197                                USB_HUB_PRINTF("already running port %i disabled by hub (EMI?), re-enabling...\n",
1198                                        i + 1);
1199                                        usb_hub_port_connect_change(dev, i);
1200                        }
1201                }
1202                if (portstatus & USB_PORT_STAT_SUSPEND) {
1203                        USB_HUB_PRINTF("port %d suspend change\n", i + 1);
1204                        usb_clear_port_feature(dev, i + 1,  USB_PORT_FEAT_SUSPEND);
1205                }
1206
1207                if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
1208                        USB_HUB_PRINTF("port %d over-current change\n", i + 1);
1209                        usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT);
1210                        usb_hub_power_on(hub);
1211                }
1212
1213                if (portchange & USB_PORT_STAT_C_RESET) {
1214                        USB_HUB_PRINTF("port %d reset change\n", i + 1);
1215                        usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
1216                }
1217        } /* end for i all ports */
1218
1219        return 0;
1220}
1221
1222int usb_hub_probe(struct usb_device *dev, int ifnum)
1223{
1224        struct usb_interface_descriptor *iface;
1225        struct usb_endpoint_descriptor *ep;
1226        int ret;
1227
1228        iface = &dev->config.if_desc[ifnum];
1229        /* Is it a hub? */
1230        if (iface->bInterfaceClass != USB_CLASS_HUB)
1231                return 0;
1232        /* Some hubs have a subclass of 1, which AFAICT according to the */
1233        /*  specs is not defined, but it works */
1234        if ((iface->bInterfaceSubClass != 0) &&
1235            (iface->bInterfaceSubClass != 1))
1236                return 0;
1237        /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1238        if (iface->bNumEndpoints != 1)
1239                return 0;
1240        ep = &iface->ep_desc[0];
1241        /* Output endpoint? Curiousier and curiousier.. */
1242        if (!(ep->bEndpointAddress & USB_DIR_IN))
1243                return 0;
1244        /* If it's not an interrupt endpoint, we'd better punt! */
1245        if ((ep->bmAttributes & 3) != 3)
1246                return 0;
1247        /* We found a hub */
1248        USB_HUB_PRINTF("USB hub found\n");
1249        ret=usb_hub_configure(dev);
1250        return ret;
1251}
1252
1253/* EOF */
Note: See TracBrowser for help on using the repository browser.