← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/common/usb.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/common/usb.c
 
1
/*
 
2
 * Most of this source has been derived from the Linux USB
 
3
 * project:
 
4
 * (C) Copyright Linus Torvalds 1999
 
5
 * (C) Copyright Johannes Erdfelt 1999-2001
 
6
 * (C) Copyright Andreas Gal 1999
 
7
 * (C) Copyright Gregory P. Smith 1999
 
8
 * (C) Copyright Deti Fliegl 1999 (new USB architecture)
 
9
 * (C) Copyright Randy Dunlap 2000
 
10
 * (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id)
 
11
 * (C) Copyright Yggdrasil Computing, Inc. 2000
 
12
 *     (usb_device_id matching changes by Adam J. Richter)
 
13
 *
 
14
 * Adapted for U-Boot:
 
15
 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland
 
16
 *
 
17
 * SPDX-License-Identifier:     GPL-2.0+
 
18
 */
 
19
 
 
20
/*
 
21
 * How it works:
 
22
 *
 
23
 * Since this is a bootloader, the devices will not be automatic
 
24
 * (re)configured on hotplug, but after a restart of the USB the
 
25
 * device should work.
 
26
 *
 
27
 * For each transfer (except "Interrupt") we wait for completion.
 
28
 */
 
29
#include <common.h>
 
30
#include <command.h>
 
31
#include <asm/processor.h>
 
32
#include <linux/compiler.h>
 
33
#include <linux/ctype.h>
 
34
#include <asm/byteorder.h>
 
35
#include <asm/unaligned.h>
 
36
#include <compiler.h>
 
37
 
 
38
#include <usb.h>
 
39
#ifdef CONFIG_4xx
 
40
#include <asm/4xx_pci.h>
 
41
#endif
 
42
 
 
43
#define USB_BUFSIZ      512
 
44
 
 
45
static struct usb_device usb_dev[USB_MAX_DEVICE];
 
46
static int dev_index;
 
47
static int asynch_allowed;
 
48
 
 
49
char usb_started; /* flag for the started/stopped USB status */
 
50
 
 
51
#ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
 
52
#define CONFIG_USB_MAX_CONTROLLER_COUNT 1
 
53
#endif
 
54
 
 
55
/***************************************************************************
 
56
 * Init USB Device
 
57
 */
 
58
int usb_init(void)
 
59
{
 
60
        void *ctrl;
 
61
        struct usb_device *dev;
 
62
        int i, start_index = 0;
 
63
 
 
64
        dev_index = 0;
 
65
        asynch_allowed = 1;
 
66
        usb_hub_reset();
 
67
 
 
68
        /* first make all devices unknown */
 
69
        for (i = 0; i < USB_MAX_DEVICE; i++) {
 
70
                memset(&usb_dev[i], 0, sizeof(struct usb_device));
 
71
                usb_dev[i].devnum = -1;
 
72
        }
 
73
 
 
74
        /* init low_level USB */
 
75
        for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
 
76
                /* init low_level USB */
 
77
                printf("USB%d:   ", i);
 
78
                if (usb_lowlevel_init(i, USB_INIT_HOST, &ctrl)) {
 
79
                        puts("lowlevel init failed\n");
 
80
                        continue;
 
81
                }
 
82
                /*
 
83
                 * lowlevel init is OK, now scan the bus for devices
 
84
                 * i.e. search HUBs and configure them
 
85
                 */
 
86
                start_index = dev_index;
 
87
                printf("scanning bus %d for devices... ", i);
 
88
                dev = usb_alloc_new_device(ctrl);
 
89
                /*
 
90
                 * device 0 is always present
 
91
                 * (root hub, so let it analyze)
 
92
                 */
 
93
                if (dev)
 
94
                        usb_new_device(dev);
 
95
 
 
96
                if (start_index == dev_index)
 
97
                        puts("No USB Device found\n");
 
98
                else
 
99
                        printf("%d USB Device(s) found\n",
 
100
                                dev_index - start_index);
 
101
 
 
102
                usb_started = 1;
 
103
        }
 
104
 
 
105
        debug("scan end\n");
 
106
        /* if we were not able to find at least one working bus, bail out */
 
107
        if (!usb_started) {
 
108
                puts("USB error: all controllers failed lowlevel init\n");
 
109
                return -1;
 
110
        }
 
111
 
 
112
        return 0;
 
113
}
 
114
 
 
115
/******************************************************************************
 
116
 * Stop USB this stops the LowLevel Part and deregisters USB devices.
 
117
 */
 
118
int usb_stop(void)
 
119
{
 
120
        int i;
 
121
 
 
122
        if (usb_started) {
 
123
                asynch_allowed = 1;
 
124
                usb_started = 0;
 
125
                usb_hub_reset();
 
126
 
 
127
                for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
 
128
                        if (usb_lowlevel_stop(i))
 
129
                                printf("failed to stop USB controller %d\n", i);
 
130
                }
 
131
        }
 
132
 
 
133
        return 0;
 
134
}
 
135
 
 
136
/*
 
137
 * disables the asynch behaviour of the control message. This is used for data
 
138
 * transfers that uses the exclusiv access to the control and bulk messages.
 
139
 * Returns the old value so it can be restored later.
 
140
 */
 
141
int usb_disable_asynch(int disable)
 
142
{
 
143
        int old_value = asynch_allowed;
 
144
 
 
145
        asynch_allowed = !disable;
 
146
        return old_value;
 
147
}
 
148
 
 
149
 
 
150
/*-------------------------------------------------------------------
 
151
 * Message wrappers.
 
152
 *
 
153
 */
 
154
 
 
155
/*
 
156
 * submits an Interrupt Message
 
157
 */
 
158
int 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
 */
 
173
int 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
        ALLOC_CACHE_ALIGN_BUFFER(struct devrequest, setup_packet, 1);
 
179
 
 
180
        if ((timeout == 0) && (!asynch_allowed)) {
 
181
                /* request for a asynch control pipe is not allowed */
 
182
                return -1;
 
183
        }
 
184
 
 
185
        /* set setup command */
 
186
        setup_packet->requesttype = requesttype;
 
187
        setup_packet->request = request;
 
188
        setup_packet->value = cpu_to_le16(value);
 
189
        setup_packet->index = cpu_to_le16(index);
 
190
        setup_packet->length = cpu_to_le16(size);
 
191
        debug("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
 
192
              "value 0x%X index 0x%X length 0x%X\n",
 
193
              request, requesttype, value, index, size);
 
194
        dev->status = USB_ST_NOT_PROC; /*not yet processed */
 
195
 
 
196
        if (submit_control_msg(dev, pipe, data, size, setup_packet) < 0)
 
197
                return -1;
 
198
        if (timeout == 0)
 
199
                return (int)size;
 
200
 
 
201
        /*
 
202
         * Wait for status to update until timeout expires, USB driver
 
203
         * interrupt handler may set the status when the USB operation has
 
204
         * been completed.
 
205
         */
 
206
        while (timeout--) {
 
207
                if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
 
208
                        break;
 
209
                mdelay(1);
 
210
        }
 
211
        if (dev->status)
 
212
                return -1;
 
213
 
 
214
        return dev->act_len;
 
215
 
 
216
}
 
217
 
 
218
/*-------------------------------------------------------------------
 
219
 * submits bulk message, and waits for completion. returns 0 if Ok or
 
220
 * -1 if Error.
 
221
 * synchronous behavior
 
222
 */
 
223
int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
 
224
                        void *data, int len, int *actual_length, int timeout)
 
225
{
 
226
        if (len < 0)
 
227
                return -1;
 
228
        dev->status = USB_ST_NOT_PROC; /*not yet processed */
 
229
        if (submit_bulk_msg(dev, pipe, data, len) < 0)
 
230
                return -1;
 
231
        while (timeout--) {
 
232
                if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
 
233
                        break;
 
234
                mdelay(1);
 
235
        }
 
236
        *actual_length = dev->act_len;
 
237
        if (dev->status == 0)
 
238
                return 0;
 
239
        else
 
240
                return -1;
 
241
}
 
242
 
 
243
 
 
244
/*-------------------------------------------------------------------
 
245
 * Max Packet stuff
 
246
 */
 
247
 
 
248
/*
 
249
 * returns the max packet size, depending on the pipe direction and
 
250
 * the configurations values
 
251
 */
 
252
int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
 
253
{
 
254
        /* direction is out -> use emaxpacket out */
 
255
        if ((pipe & USB_DIR_IN) == 0)
 
256
                return dev->epmaxpacketout[((pipe>>15) & 0xf)];
 
257
        else
 
258
                return dev->epmaxpacketin[((pipe>>15) & 0xf)];
 
259
}
 
260
 
 
261
/*
 
262
 * The routine usb_set_maxpacket_ep() is extracted from the loop of routine
 
263
 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine
 
264
 * when it is inlined in 1 single routine. What happens is that the register r3
 
265
 * is used as loop-count 'i', but gets overwritten later on.
 
266
 * This is clearly a compiler bug, but it is easier to workaround it here than
 
267
 * to update the compiler (Occurs with at least several GCC 4.{1,2},x
 
268
 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM)
 
269
 *
 
270
 * NOTE: Similar behaviour was observed with GCC4.6 on ARMv5.
 
271
 */
 
272
static void noinline
 
273
usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx)
 
274
{
 
275
        int b;
 
276
        struct usb_endpoint_descriptor *ep;
 
277
        u16 ep_wMaxPacketSize;
 
278
 
 
279
        ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx];
 
280
 
 
281
        b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 
282
        ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize);
 
283
 
 
284
        if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 
285
                                                USB_ENDPOINT_XFER_CONTROL) {
 
286
                /* Control => bidirectional */
 
287
                dev->epmaxpacketout[b] = ep_wMaxPacketSize;
 
288
                dev->epmaxpacketin[b] = ep_wMaxPacketSize;
 
289
                debug("##Control EP epmaxpacketout/in[%d] = %d\n",
 
290
                      b, dev->epmaxpacketin[b]);
 
291
        } else {
 
292
                if ((ep->bEndpointAddress & 0x80) == 0) {
 
293
                        /* OUT Endpoint */
 
294
                        if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) {
 
295
                                dev->epmaxpacketout[b] = ep_wMaxPacketSize;
 
296
                                debug("##EP epmaxpacketout[%d] = %d\n",
 
297
                                      b, dev->epmaxpacketout[b]);
 
298
                        }
 
299
                } else {
 
300
                        /* IN Endpoint */
 
301
                        if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) {
 
302
                                dev->epmaxpacketin[b] = ep_wMaxPacketSize;
 
303
                                debug("##EP epmaxpacketin[%d] = %d\n",
 
304
                                      b, dev->epmaxpacketin[b]);
 
305
                        }
 
306
                } /* if out */
 
307
        } /* if control */
 
308
}
 
309
 
 
310
/*
 
311
 * set the max packed value of all endpoints in the given configuration
 
312
 */
 
313
static int usb_set_maxpacket(struct usb_device *dev)
 
314
{
 
315
        int i, ii;
 
316
 
 
317
        for (i = 0; i < dev->config.desc.bNumInterfaces; i++)
 
318
                for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++)
 
319
                        usb_set_maxpacket_ep(dev, i, ii);
 
320
 
 
321
        return 0;
 
322
}
 
323
 
 
324
/*******************************************************************************
 
325
 * Parse the config, located in buffer, and fills the dev->config structure.
 
326
 * Note that all little/big endian swapping are done automatically.
 
327
 * (wTotalLength has already been swapped and sanitized when it was read.)
 
328
 */
 
329
static int usb_parse_config(struct usb_device *dev,
 
330
                        unsigned char *buffer, int cfgno)
 
331
{
 
332
        struct usb_descriptor_header *head;
 
333
        int index, ifno, epno, curr_if_num;
 
334
        u16 ep_wMaxPacketSize;
 
335
        struct usb_interface *if_desc = NULL;
 
336
 
 
337
        ifno = -1;
 
338
        epno = -1;
 
339
        curr_if_num = -1;
 
340
 
 
341
        dev->configno = cfgno;
 
342
        head = (struct usb_descriptor_header *) &buffer[0];
 
343
        if (head->bDescriptorType != USB_DT_CONFIG) {
 
344
                printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
 
345
                        head->bDescriptorType);
 
346
                return -1;
 
347
        }
 
348
        if (head->bLength != USB_DT_CONFIG_SIZE) {
 
349
                printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength);
 
350
                return -1;
 
351
        }
 
352
        memcpy(&dev->config, head, USB_DT_CONFIG_SIZE);
 
353
        dev->config.no_of_if = 0;
 
354
 
 
355
        index = dev->config.desc.bLength;
 
356
        /* Ok the first entry must be a configuration entry,
 
357
         * now process the others */
 
358
        head = (struct usb_descriptor_header *) &buffer[index];
 
359
        while (index + 1 < dev->config.desc.wTotalLength && head->bLength) {
 
360
                switch (head->bDescriptorType) {
 
361
                case USB_DT_INTERFACE:
 
362
                        if (head->bLength != USB_DT_INTERFACE_SIZE) {
 
363
                                printf("ERROR: Invalid USB IF length (%d)\n",
 
364
                                        head->bLength);
 
365
                                break;
 
366
                        }
 
367
                        if (index + USB_DT_INTERFACE_SIZE >
 
368
                            dev->config.desc.wTotalLength) {
 
369
                                puts("USB IF descriptor overflowed buffer!\n");
 
370
                                break;
 
371
                        }
 
372
                        if (((struct usb_interface_descriptor *) \
 
373
                             head)->bInterfaceNumber != curr_if_num) {
 
374
                                /* this is a new interface, copy new desc */
 
375
                                ifno = dev->config.no_of_if;
 
376
                                if (ifno >= USB_MAXINTERFACES) {
 
377
                                        puts("Too many USB interfaces!\n");
 
378
                                        /* try to go on with what we have */
 
379
                                        return 1;
 
380
                                }
 
381
                                if_desc = &dev->config.if_desc[ifno];
 
382
                                dev->config.no_of_if++;
 
383
                                memcpy(if_desc, head,
 
384
                                        USB_DT_INTERFACE_SIZE);
 
385
                                if_desc->no_of_ep = 0;
 
386
                                if_desc->num_altsetting = 1;
 
387
                                curr_if_num =
 
388
                                     if_desc->desc.bInterfaceNumber;
 
389
                        } else {
 
390
                                /* found alternate setting for the interface */
 
391
                                if (ifno >= 0) {
 
392
                                        if_desc = &dev->config.if_desc[ifno];
 
393
                                        if_desc->num_altsetting++;
 
394
                                }
 
395
                        }
 
396
                        break;
 
397
                case USB_DT_ENDPOINT:
 
398
                        if (head->bLength != USB_DT_ENDPOINT_SIZE) {
 
399
                                printf("ERROR: Invalid USB EP length (%d)\n",
 
400
                                        head->bLength);
 
401
                                break;
 
402
                        }
 
403
                        if (index + USB_DT_ENDPOINT_SIZE >
 
404
                            dev->config.desc.wTotalLength) {
 
405
                                puts("USB EP descriptor overflowed buffer!\n");
 
406
                                break;
 
407
                        }
 
408
                        if (ifno < 0) {
 
409
                                puts("Endpoint descriptor out of order!\n");
 
410
                                break;
 
411
                        }
 
412
                        epno = dev->config.if_desc[ifno].no_of_ep;
 
413
                        if_desc = &dev->config.if_desc[ifno];
 
414
                        if (epno > USB_MAXENDPOINTS) {
 
415
                                printf("Interface %d has too many endpoints!\n",
 
416
                                        if_desc->desc.bInterfaceNumber);
 
417
                                return 1;
 
418
                        }
 
419
                        /* found an endpoint */
 
420
                        if_desc->no_of_ep++;
 
421
                        memcpy(&if_desc->ep_desc[epno], head,
 
422
                                USB_DT_ENDPOINT_SIZE);
 
423
                        ep_wMaxPacketSize = get_unaligned(&dev->config.\
 
424
                                                        if_desc[ifno].\
 
425
                                                        ep_desc[epno].\
 
426
                                                        wMaxPacketSize);
 
427
                        put_unaligned(le16_to_cpu(ep_wMaxPacketSize),
 
428
                                        &dev->config.\
 
429
                                        if_desc[ifno].\
 
430
                                        ep_desc[epno].\
 
431
                                        wMaxPacketSize);
 
432
                        debug("if %d, ep %d\n", ifno, epno);
 
433
                        break;
 
434
                case USB_DT_SS_ENDPOINT_COMP:
 
435
                        if (head->bLength != USB_DT_SS_EP_COMP_SIZE) {
 
436
                                printf("ERROR: Invalid USB EPC length (%d)\n",
 
437
                                        head->bLength);
 
438
                                break;
 
439
                        }
 
440
                        if (index + USB_DT_SS_EP_COMP_SIZE >
 
441
                            dev->config.desc.wTotalLength) {
 
442
                                puts("USB EPC descriptor overflowed buffer!\n");
 
443
                                break;
 
444
                        }
 
445
                        if (ifno < 0 || epno < 0) {
 
446
                                puts("EPC descriptor out of order!\n");
 
447
                                break;
 
448
                        }
 
449
                        if_desc = &dev->config.if_desc[ifno];
 
450
                        memcpy(&if_desc->ss_ep_comp_desc[epno], head,
 
451
                                USB_DT_SS_EP_COMP_SIZE);
 
452
                        break;
 
453
                default:
 
454
                        if (head->bLength == 0)
 
455
                                return 1;
 
456
 
 
457
                        debug("unknown Description Type : %x\n",
 
458
                              head->bDescriptorType);
 
459
 
 
460
#ifdef DEBUG
 
461
                        {
 
462
                                unsigned char *ch = (unsigned char *)head;
 
463
                                int i;
 
464
 
 
465
                                for (i = 0; i < head->bLength; i++)
 
466
                                        debug("%02X ", *ch++);
 
467
                                debug("\n\n\n");
 
468
                        }
 
469
#endif
 
470
                        break;
 
471
                }
 
472
                index += head->bLength;
 
473
                head = (struct usb_descriptor_header *)&buffer[index];
 
474
        }
 
475
        return 1;
 
476
}
 
477
 
 
478
/***********************************************************************
 
479
 * Clears an endpoint
 
480
 * endp: endpoint number in bits 0-3;
 
481
 * direction flag in bit 7 (1 = IN, 0 = OUT)
 
482
 */
 
483
int usb_clear_halt(struct usb_device *dev, int pipe)
 
484
{
 
485
        int result;
 
486
        int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
 
487
 
 
488
        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 
489
                                 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
 
490
                                 endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
 
491
 
 
492
        /* don't clear if failed */
 
493
        if (result < 0)
 
494
                return result;
 
495
 
 
496
        /*
 
497
         * NOTE: we do not get status and verify reset was successful
 
498
         * as some devices are reported to lock up upon this check..
 
499
         */
 
500
 
 
501
        usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
 
502
 
 
503
        /* toggle is reset on clear */
 
504
        usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
 
505
        return 0;
 
506
}
 
507
 
 
508
 
 
509
/**********************************************************************
 
510
 * get_descriptor type
 
511
 */
 
512
static int usb_get_descriptor(struct usb_device *dev, unsigned char type,
 
513
                        unsigned char index, void *buf, int size)
 
514
{
 
515
        int res;
 
516
        res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 
517
                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
 
518
                        (type << 8) + index, 0,
 
519
                        buf, size, USB_CNTL_TIMEOUT);
 
520
        return res;
 
521
}
 
522
 
 
523
/**********************************************************************
 
524
 * gets configuration cfgno and store it in the buffer
 
525
 */
 
526
int usb_get_configuration_no(struct usb_device *dev,
 
527
                             unsigned char *buffer, int cfgno)
 
528
{
 
529
        int result;
 
530
        unsigned int length;
 
531
        struct usb_config_descriptor *config;
 
532
 
 
533
        config = (struct usb_config_descriptor *)&buffer[0];
 
534
        result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9);
 
535
        if (result < 9) {
 
536
                if (result < 0)
 
537
                        printf("unable to get descriptor, error %lX\n",
 
538
                                dev->status);
 
539
                else
 
540
                        printf("config descriptor too short " \
 
541
                                "(expected %i, got %i)\n", 9, result);
 
542
                return -1;
 
543
        }
 
544
        length = le16_to_cpu(config->wTotalLength);
 
545
 
 
546
        if (length > USB_BUFSIZ) {
 
547
                printf("%s: failed to get descriptor - too long: %d\n",
 
548
                        __func__, length);
 
549
                return -1;
 
550
        }
 
551
 
 
552
        result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length);
 
553
        debug("get_conf_no %d Result %d, wLength %d\n", cfgno, result, length);
 
554
        config->wTotalLength = length; /* validated, with CPU byte order */
 
555
 
 
556
        return result;
 
557
}
 
558
 
 
559
/********************************************************************
 
560
 * set address of a device to the value in dev->devnum.
 
561
 * This can only be done by addressing the device via the default address (0)
 
562
 */
 
563
static int usb_set_address(struct usb_device *dev)
 
564
{
 
565
        int res;
 
566
 
 
567
        debug("set address %d\n", dev->devnum);
 
568
        res = usb_control_msg(dev, usb_snddefctrl(dev),
 
569
                                USB_REQ_SET_ADDRESS, 0,
 
570
                                (dev->devnum), 0,
 
571
                                NULL, 0, USB_CNTL_TIMEOUT);
 
572
        return res;
 
573
}
 
574
 
 
575
/********************************************************************
 
576
 * set interface number to interface
 
577
 */
 
578
int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 
579
{
 
580
        struct usb_interface *if_face = NULL;
 
581
        int ret, i;
 
582
 
 
583
        for (i = 0; i < dev->config.desc.bNumInterfaces; i++) {
 
584
                if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) {
 
585
                        if_face = &dev->config.if_desc[i];
 
586
                        break;
 
587
                }
 
588
        }
 
589
        if (!if_face) {
 
590
                printf("selecting invalid interface %d", interface);
 
591
                return -1;
 
592
        }
 
593
        /*
 
594
         * We should return now for devices with only one alternate setting.
 
595
         * According to 9.4.10 of the Universal Serial Bus Specification
 
596
         * Revision 2.0 such devices can return with a STALL. This results in
 
597
         * some USB sticks timeouting during initialization and then being
 
598
         * unusable in U-Boot.
 
599
         */
 
600
        if (if_face->num_altsetting == 1)
 
601
                return 0;
 
602
 
 
603
        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 
604
                                USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
 
605
                                alternate, interface, NULL, 0,
 
606
                                USB_CNTL_TIMEOUT * 5);
 
607
        if (ret < 0)
 
608
                return ret;
 
609
 
 
610
        return 0;
 
611
}
 
612
 
 
613
/********************************************************************
 
614
 * set configuration number to configuration
 
615
 */
 
616
static int usb_set_configuration(struct usb_device *dev, int configuration)
 
617
{
 
618
        int res;
 
619
        debug("set configuration %d\n", configuration);
 
620
        /* set setup command */
 
621
        res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 
622
                                USB_REQ_SET_CONFIGURATION, 0,
 
623
                                configuration, 0,
 
624
                                NULL, 0, USB_CNTL_TIMEOUT);
 
625
        if (res == 0) {
 
626
                dev->toggle[0] = 0;
 
627
                dev->toggle[1] = 0;
 
628
                return 0;
 
629
        } else
 
630
                return -1;
 
631
}
 
632
 
 
633
/********************************************************************
 
634
 * set protocol to protocol
 
635
 */
 
636
int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
 
637
{
 
638
        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 
639
                USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
640
                protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
 
641
}
 
642
 
 
643
/********************************************************************
 
644
 * set idle
 
645
 */
 
646
int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
 
647
{
 
648
        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 
649
                USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
650
                (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
 
651
}
 
652
 
 
653
/********************************************************************
 
654
 * get report
 
655
 */
 
656
int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
 
657
                   unsigned char id, void *buf, int size)
 
658
{
 
659
        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 
660
                        USB_REQ_GET_REPORT,
 
661
                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
662
                        (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
 
663
}
 
664
 
 
665
/********************************************************************
 
666
 * get class descriptor
 
667
 */
 
668
int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
 
669
                unsigned char type, unsigned char id, void *buf, int size)
 
670
{
 
671
        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 
672
                USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
 
673
                (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
 
674
}
 
675
 
 
676
/********************************************************************
 
677
 * get string index in buffer
 
678
 */
 
679
static int usb_get_string(struct usb_device *dev, unsigned short langid,
 
680
                   unsigned char index, void *buf, int size)
 
681
{
 
682
        int i;
 
683
        int result;
 
684
 
 
685
        for (i = 0; i < 3; ++i) {
 
686
                /* some devices are flaky */
 
687
                result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 
688
                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
 
689
                        (USB_DT_STRING << 8) + index, langid, buf, size,
 
690
                        USB_CNTL_TIMEOUT);
 
691
 
 
692
                if (result > 0)
 
693
                        break;
 
694
        }
 
695
 
 
696
        return result;
 
697
}
 
698
 
 
699
 
 
700
static void usb_try_string_workarounds(unsigned char *buf, int *length)
 
701
{
 
702
        int newlength, oldlength = *length;
 
703
 
 
704
        for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
 
705
                if (!isprint(buf[newlength]) || buf[newlength + 1])
 
706
                        break;
 
707
 
 
708
        if (newlength > 2) {
 
709
                buf[0] = newlength;
 
710
                *length = newlength;
 
711
        }
 
712
}
 
713
 
 
714
 
 
715
static int usb_string_sub(struct usb_device *dev, unsigned int langid,
 
716
                unsigned int index, unsigned char *buf)
 
717
{
 
718
        int rc;
 
719
 
 
720
        /* Try to read the string descriptor by asking for the maximum
 
721
         * possible number of bytes */
 
722
        rc = usb_get_string(dev, langid, index, buf, 255);
 
723
 
 
724
        /* If that failed try to read the descriptor length, then
 
725
         * ask for just that many bytes */
 
726
        if (rc < 2) {
 
727
                rc = usb_get_string(dev, langid, index, buf, 2);
 
728
                if (rc == 2)
 
729
                        rc = usb_get_string(dev, langid, index, buf, buf[0]);
 
730
        }
 
731
 
 
732
        if (rc >= 2) {
 
733
                if (!buf[0] && !buf[1])
 
734
                        usb_try_string_workarounds(buf, &rc);
 
735
 
 
736
                /* There might be extra junk at the end of the descriptor */
 
737
                if (buf[0] < rc)
 
738
                        rc = buf[0];
 
739
 
 
740
                rc = rc - (rc & 1); /* force a multiple of two */
 
741
        }
 
742
 
 
743
        if (rc < 2)
 
744
                rc = -1;
 
745
 
 
746
        return rc;
 
747
}
 
748
 
 
749
 
 
750
/********************************************************************
 
751
 * usb_string:
 
752
 * Get string index and translate it to ascii.
 
753
 * returns string length (> 0) or error (< 0)
 
754
 */
 
755
int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
 
756
{
 
757
        ALLOC_CACHE_ALIGN_BUFFER(unsigned char, mybuf, USB_BUFSIZ);
 
758
        unsigned char *tbuf;
 
759
        int err;
 
760
        unsigned int u, idx;
 
761
 
 
762
        if (size <= 0 || !buf || !index)
 
763
                return -1;
 
764
        buf[0] = 0;
 
765
        tbuf = &mybuf[0];
 
766
 
 
767
        /* get langid for strings if it's not yet known */
 
768
        if (!dev->have_langid) {
 
769
                err = usb_string_sub(dev, 0, 0, tbuf);
 
770
                if (err < 0) {
 
771
                        debug("error getting string descriptor 0 " \
 
772
                              "(error=%lx)\n", dev->status);
 
773
                        return -1;
 
774
                } else if (tbuf[0] < 4) {
 
775
                        debug("string descriptor 0 too short\n");
 
776
                        return -1;
 
777
                } else {
 
778
                        dev->have_langid = -1;
 
779
                        dev->string_langid = tbuf[2] | (tbuf[3] << 8);
 
780
                                /* always use the first langid listed */
 
781
                        debug("USB device number %d default " \
 
782
                              "language ID 0x%x\n",
 
783
                              dev->devnum, dev->string_langid);
 
784
                }
 
785
        }
 
786
 
 
787
        err = usb_string_sub(dev, dev->string_langid, index, tbuf);
 
788
        if (err < 0)
 
789
                return err;
 
790
 
 
791
        size--;         /* leave room for trailing NULL char in output buffer */
 
792
        for (idx = 0, u = 2; u < err; u += 2) {
 
793
                if (idx >= size)
 
794
                        break;
 
795
                if (tbuf[u+1])                  /* high byte */
 
796
                        buf[idx++] = '?';  /* non-ASCII character */
 
797
                else
 
798
                        buf[idx++] = tbuf[u];
 
799
        }
 
800
        buf[idx] = 0;
 
801
        err = idx;
 
802
        return err;
 
803
}
 
804
 
 
805
 
 
806
/********************************************************************
 
807
 * USB device handling:
 
808
 * the USB device are static allocated [USB_MAX_DEVICE].
 
809
 */
 
810
 
 
811
 
 
812
/* returns a pointer to the device with the index [index].
 
813
 * if the device is not assigned (dev->devnum==-1) returns NULL
 
814
 */
 
815
struct usb_device *usb_get_dev_index(int index)
 
816
{
 
817
        if (usb_dev[index].devnum == -1)
 
818
                return NULL;
 
819
        else
 
820
                return &usb_dev[index];
 
821
}
 
822
 
 
823
/* returns a pointer of a new device structure or NULL, if
 
824
 * no device struct is available
 
825
 */
 
826
struct usb_device *usb_alloc_new_device(void *controller)
 
827
{
 
828
        int i;
 
829
        debug("New Device %d\n", dev_index);
 
830
        if (dev_index == USB_MAX_DEVICE) {
 
831
                printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE);
 
832
                return NULL;
 
833
        }
 
834
        /* default Address is 0, real addresses start with 1 */
 
835
        usb_dev[dev_index].devnum = dev_index + 1;
 
836
        usb_dev[dev_index].maxchild = 0;
 
837
        for (i = 0; i < USB_MAXCHILDREN; i++)
 
838
                usb_dev[dev_index].children[i] = NULL;
 
839
        usb_dev[dev_index].parent = NULL;
 
840
        usb_dev[dev_index].controller = controller;
 
841
        dev_index++;
 
842
        return &usb_dev[dev_index - 1];
 
843
}
 
844
 
 
845
/*
 
846
 * Free the newly created device node.
 
847
 * Called in error cases where configuring a newly attached
 
848
 * device fails for some reason.
 
849
 */
 
850
void usb_free_device(void)
 
851
{
 
852
        dev_index--;
 
853
        debug("Freeing device node: %d\n", dev_index);
 
854
        memset(&usb_dev[dev_index], 0, sizeof(struct usb_device));
 
855
        usb_dev[dev_index].devnum = -1;
 
856
}
 
857
 
 
858
/*
 
859
 * XHCI issues Enable Slot command and thereafter
 
860
 * allocates device contexts. Provide a weak alias
 
861
 * function for the purpose, so that XHCI overrides it
 
862
 * and EHCI/OHCI just work out of the box.
 
863
 */
 
864
__weak int usb_alloc_device(struct usb_device *udev)
 
865
{
 
866
        return 0;
 
867
}
 
868
/*
 
869
 * By the time we get here, the device has gotten a new device ID
 
870
 * and is in the default state. We need to identify the thing and
 
871
 * get the ball rolling..
 
872
 *
 
873
 * Returns 0 for success, != 0 for error.
 
874
 */
 
875
int usb_new_device(struct usb_device *dev)
 
876
{
 
877
        int addr, err;
 
878
        int tmp;
 
879
        ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ);
 
880
 
 
881
        /*
 
882
         * Allocate usb 3.0 device context.
 
883
         * USB 3.0 (xHCI) protocol tries to allocate device slot
 
884
         * and related data structures first. This call does that.
 
885
         * Refer to sec 4.3.2 in xHCI spec rev1.0
 
886
         */
 
887
        if (usb_alloc_device(dev)) {
 
888
                printf("Cannot allocate device context to get SLOT_ID\n");
 
889
                return -1;
 
890
        }
 
891
 
 
892
        /* We still haven't set the Address yet */
 
893
        addr = dev->devnum;
 
894
        dev->devnum = 0;
 
895
 
 
896
#ifdef CONFIG_LEGACY_USB_INIT_SEQ
 
897
        /* this is the old and known way of initializing devices, it is
 
898
         * different than what Windows and Linux are doing. Windows and Linux
 
899
         * both retrieve 64 bytes while reading the device descriptor
 
900
         * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an
 
901
         * invalid header while reading 8 bytes as device descriptor. */
 
902
        dev->descriptor.bMaxPacketSize0 = 8;        /* Start off at 8 bytes  */
 
903
        dev->maxpacketsize = PACKET_SIZE_8;
 
904
        dev->epmaxpacketin[0] = 8;
 
905
        dev->epmaxpacketout[0] = 8;
 
906
 
 
907
        err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, tmpbuf, 8);
 
908
        if (err < 8) {
 
909
                printf("\n      USB device not responding, " \
 
910
                       "giving up (status=%lX)\n", dev->status);
 
911
                return 1;
 
912
        }
 
913
        memcpy(&dev->descriptor, tmpbuf, 8);
 
914
#else
 
915
        /* This is a Windows scheme of initialization sequence, with double
 
916
         * reset of the device (Linux uses the same sequence)
 
917
         * Some equipment is said to work only with such init sequence; this
 
918
         * patch is based on the work by Alan Stern:
 
919
         * http://sourceforge.net/mailarchive/forum.php?
 
920
         * thread_id=5729457&forum_id=5398
 
921
         */
 
922
        __maybe_unused struct usb_device_descriptor *desc;
 
923
        int port = -1;
 
924
        struct usb_device *parent = dev->parent;
 
925
        unsigned short portstatus;
 
926
 
 
927
        /* send 64-byte GET-DEVICE-DESCRIPTOR request.  Since the descriptor is
 
928
         * only 18 bytes long, this will terminate with a short packet.  But if
 
929
         * the maxpacket size is 8 or 16 the device may be waiting to transmit
 
930
         * some more, or keeps on retransmitting the 8 byte header. */
 
931
 
 
932
        desc = (struct usb_device_descriptor *)tmpbuf;
 
933
        dev->descriptor.bMaxPacketSize0 = 64;       /* Start off at 64 bytes  */
 
934
        /* Default to 64 byte max packet size */
 
935
        dev->maxpacketsize = PACKET_SIZE_64;
 
936
        dev->epmaxpacketin[0] = 64;
 
937
        dev->epmaxpacketout[0] = 64;
 
938
 
 
939
        /*
 
940
         * XHCI needs to issue a Address device command to setup
 
941
         * proper device context structures, before it can interact
 
942
         * with the device. So a get_descriptor will fail before any
 
943
         * of that is done for XHCI unlike EHCI.
 
944
         */
 
945
#ifndef CONFIG_USB_XHCI
 
946
        err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
 
947
        if (err < 0) {
 
948
                debug("usb_new_device: usb_get_descriptor() failed\n");
 
949
                return 1;
 
950
        }
 
951
 
 
952
        dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0;
 
953
        /*
 
954
         * Fetch the device class, driver can use this info
 
955
         * to differentiate between HUB and DEVICE.
 
956
         */
 
957
        dev->descriptor.bDeviceClass = desc->bDeviceClass;
 
958
#endif
 
959
 
 
960
        if (parent) {
 
961
                int j;
 
962
 
 
963
                /* find the port number we're at */
 
964
                for (j = 0; j < parent->maxchild; j++) {
 
965
                        if (parent->children[j] == dev) {
 
966
                                port = j;
 
967
                                break;
 
968
                        }
 
969
                }
 
970
                if (port < 0) {
 
971
                        printf("usb_new_device:cannot locate device's port.\n");
 
972
                        return 1;
 
973
                }
 
974
 
 
975
                /* reset the port for the second time */
 
976
                err = hub_port_reset(dev->parent, port, &portstatus);
 
977
                if (err < 0) {
 
978
                        printf("\n     Couldn't reset port %i\n", port);
 
979
                        return 1;
 
980
                }
 
981
        }
 
982
#endif
 
983
 
 
984
        dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
 
985
        dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
 
986
        switch (dev->descriptor.bMaxPacketSize0) {
 
987
        case 8:
 
988
                dev->maxpacketsize  = PACKET_SIZE_8;
 
989
                break;
 
990
        case 16:
 
991
                dev->maxpacketsize = PACKET_SIZE_16;
 
992
                break;
 
993
        case 32:
 
994
                dev->maxpacketsize = PACKET_SIZE_32;
 
995
                break;
 
996
        case 64:
 
997
                dev->maxpacketsize = PACKET_SIZE_64;
 
998
                break;
 
999
        }
 
1000
        dev->devnum = addr;
 
1001
 
 
1002
        err = usb_set_address(dev); /* set address */
 
1003
 
 
1004
        if (err < 0) {
 
1005
                printf("\n      USB device not accepting new address " \
 
1006
                        "(error=%lX)\n", dev->status);
 
1007
                return 1;
 
1008
        }
 
1009
 
 
1010
        mdelay(10);     /* Let the SET_ADDRESS settle */
 
1011
 
 
1012
        tmp = sizeof(dev->descriptor);
 
1013
 
 
1014
        err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
 
1015
                                 tmpbuf, sizeof(dev->descriptor));
 
1016
        if (err < tmp) {
 
1017
                if (err < 0)
 
1018
                        printf("unable to get device descriptor (error=%d)\n",
 
1019
                               err);
 
1020
                else
 
1021
                        printf("USB device descriptor short read " \
 
1022
                                "(expected %i, got %i)\n", tmp, err);
 
1023
                return 1;
 
1024
        }
 
1025
        memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor));
 
1026
        /* correct le values */
 
1027
        le16_to_cpus(&dev->descriptor.bcdUSB);
 
1028
        le16_to_cpus(&dev->descriptor.idVendor);
 
1029
        le16_to_cpus(&dev->descriptor.idProduct);
 
1030
        le16_to_cpus(&dev->descriptor.bcdDevice);
 
1031
        /* only support for one config for now */
 
1032
        err = usb_get_configuration_no(dev, tmpbuf, 0);
 
1033
        if (err < 0) {
 
1034
                printf("usb_new_device: Cannot read configuration, " \
 
1035
                       "skipping device %04x:%04x\n",
 
1036
                       dev->descriptor.idVendor, dev->descriptor.idProduct);
 
1037
                return -1;
 
1038
        }
 
1039
        usb_parse_config(dev, tmpbuf, 0);
 
1040
        usb_set_maxpacket(dev);
 
1041
        /* we set the default configuration here */
 
1042
        if (usb_set_configuration(dev, dev->config.desc.bConfigurationValue)) {
 
1043
                printf("failed to set default configuration " \
 
1044
                        "len %d, status %lX\n", dev->act_len, dev->status);
 
1045
                return -1;
 
1046
        }
 
1047
        debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
 
1048
              dev->descriptor.iManufacturer, dev->descriptor.iProduct,
 
1049
              dev->descriptor.iSerialNumber);
 
1050
        memset(dev->mf, 0, sizeof(dev->mf));
 
1051
        memset(dev->prod, 0, sizeof(dev->prod));
 
1052
        memset(dev->serial, 0, sizeof(dev->serial));
 
1053
        if (dev->descriptor.iManufacturer)
 
1054
                usb_string(dev, dev->descriptor.iManufacturer,
 
1055
                           dev->mf, sizeof(dev->mf));
 
1056
        if (dev->descriptor.iProduct)
 
1057
                usb_string(dev, dev->descriptor.iProduct,
 
1058
                           dev->prod, sizeof(dev->prod));
 
1059
        if (dev->descriptor.iSerialNumber)
 
1060
                usb_string(dev, dev->descriptor.iSerialNumber,
 
1061
                           dev->serial, sizeof(dev->serial));
 
1062
        debug("Manufacturer %s\n", dev->mf);
 
1063
        debug("Product      %s\n", dev->prod);
 
1064
        debug("SerialNumber %s\n", dev->serial);
 
1065
        /* now prode if the device is a hub */
 
1066
        usb_hub_probe(dev, 0);
 
1067
        return 0;
 
1068
}
 
1069
 
 
1070
__weak
 
1071
int board_usb_init(int index, enum usb_init_type init)
 
1072
{
 
1073
        return 0;
 
1074
}
 
1075
/* EOF */