2
* ISP116x HCD (Host Controller Driver) for u-boot.
4
* Copyright (C) 2006-2007 Rodolfo Giometti <giometti@linux.it>
5
* Copyright (C) 2006-2007 Eurotech S.p.A. <info@eurotech.it>
7
* This program is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU General Public License as
9
* published by the Free Software Foundation; either version 2 of
10
* the License, or (at your option) any later version.
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23
* Derived in part from the SL811 HCD driver "u-boot/drivers/usb/sl811_usb.c"
24
* (original copyright message follows):
27
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
29
* This code is based on linux driver for sl811hs chip, source at
30
* drivers/usb/host/sl811.c:
32
* SL811 Host Controller Interface driver for USB.
34
* Copyright (c) 2003/06, Courage Co., Ltd.
37
* 1.uhci.c by Linus Torvalds, Johannes Erdfelt, Randy Dunlap,
38
* Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber,
39
* Adam Richter, Gregory P. Smith;
40
* 2.Original SL811 driver (hc_sl811.o) by Pei Liu <pbl@cypress.com>
41
* 3.Rewrited as sl811.o by Yin Aihua <yinah:couragetech.com.cn>
43
* [[GNU/GPL disclaimer]]
45
* and in part from AU1x00 OHCI HCD driver "u-boot/cpu/mips/au1x00_usb_ohci.c"
46
* (original copyright message follows):
48
* URB OHCI HCD (Host Controller Driver) for USB on the AU1x00.
51
* Gary Jennejohn, DENX Software Engineering <garyj@denx.de>
53
* [[GNU/GPL disclaimer]]
55
* Note: Part of this code has been derived from linux
62
#include <linux/list.h>
65
* ISP116x chips require certain delays between accesses to its
66
* registers. The following timing options exist.
68
* 1. Configure your memory controller (the best)
69
* 2. Use ndelay (easiest, poorest). For that, enable the following macro.
71
* Value is in microseconds.
73
#ifdef ISP116X_HCD_USE_UDELAY
78
* On some (slowly?) machines an extra delay after data packing into
79
* controller's FIFOs is required, * otherwise you may get the following
84
* USB: scanning bus for devices... isp116x: isp116x_submit_job: CTL:TIMEOUT
85
* isp116x: isp116x_submit_job: ****** FIFO not ready! ******
87
* USB device not responding, giving up (status=4)
88
* isp116x: isp116x_submit_job: ****** FIFO not empty! ******
89
* isp116x: isp116x_submit_job: ****** FIFO not empty! ******
90
* isp116x: isp116x_submit_job: ****** FIFO not empty! ******
91
* 3 USB Device(s) found
92
* scanning bus for storage devices... 0 Storage Device(s) found
94
* Value is in milliseconds.
96
#ifdef ISP116X_HCD_USE_EXTRA_DELAY
101
* Enable the following defines if you wish enable debugging messages.
103
#undef DEBUG /* enable debugging messages */
104
#undef TRACE /* enable tracing code */
105
#undef VERBOSE /* verbose debugging messages */
109
#define DRIVER_VERSION "08 Jan 2007"
110
static const char hcd_name[] = "isp116x-hcd";
112
struct isp116x isp116x_dev;
113
struct isp116x_platform_data isp116x_board;
114
static int got_rhsc; /* root hub status change */
115
struct usb_device *devgone; /* device which was disconnected */
116
static int rh_devnum; /* address of Root Hub endpoint */
118
/* ------------------------------------------------------------------------- */
120
#define ALIGN(x,a) (((x)+(a)-1UL)&~((a)-1UL))
121
#define min_t(type,x,y) \
122
({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
124
/* ------------------------------------------------------------------------- */
126
static int isp116x_reset(struct isp116x *isp116x);
128
/* --- Debugging functions ------------------------------------------------- */
130
#define isp116x_show_reg(d, r) { \
132
DBG("%-12s[%02x]: %08x", #r, \
133
r, isp116x_read_reg32(d, r)); \
135
DBG("%-12s[%02x]: %04x", #r, \
136
r, isp116x_read_reg16(d, r)); \
140
#define isp116x_show_regs(d) { \
141
isp116x_show_reg(d, HCREVISION); \
142
isp116x_show_reg(d, HCCONTROL); \
143
isp116x_show_reg(d, HCCMDSTAT); \
144
isp116x_show_reg(d, HCINTSTAT); \
145
isp116x_show_reg(d, HCINTENB); \
146
isp116x_show_reg(d, HCFMINTVL); \
147
isp116x_show_reg(d, HCFMREM); \
148
isp116x_show_reg(d, HCFMNUM); \
149
isp116x_show_reg(d, HCLSTHRESH); \
150
isp116x_show_reg(d, HCRHDESCA); \
151
isp116x_show_reg(d, HCRHDESCB); \
152
isp116x_show_reg(d, HCRHSTATUS); \
153
isp116x_show_reg(d, HCRHPORT1); \
154
isp116x_show_reg(d, HCRHPORT2); \
155
isp116x_show_reg(d, HCHWCFG); \
156
isp116x_show_reg(d, HCDMACFG); \
157
isp116x_show_reg(d, HCXFERCTR); \
158
isp116x_show_reg(d, HCuPINT); \
159
isp116x_show_reg(d, HCuPINTENB); \
160
isp116x_show_reg(d, HCCHIPID); \
161
isp116x_show_reg(d, HCSCRATCH); \
162
isp116x_show_reg(d, HCITLBUFLEN); \
163
isp116x_show_reg(d, HCATLBUFLEN); \
164
isp116x_show_reg(d, HCBUFSTAT); \
165
isp116x_show_reg(d, HCRDITL0LEN); \
166
isp116x_show_reg(d, HCRDITL1LEN); \
171
static int isp116x_get_current_frame_number(struct usb_device *usb_dev)
173
struct isp116x *isp116x = &isp116x_dev;
175
return isp116x_read_reg32(isp116x, HCFMNUM);
178
static void dump_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
185
DBG("%s URB:[%4x] dev:%2d,ep:%2d-%c,type:%s,len:%d stat:%#lx",
187
isp116x_get_current_frame_number(dev),
188
usb_pipedevice(pipe),
189
usb_pipeendpoint(pipe),
190
usb_pipeout(pipe) ? 'O' : 'I',
191
usb_pipetype(pipe) < 2 ?
194
(usb_pipecontrol(pipe) ? "CTRL" : "BULK"), len, dev->status);
196
if (len > 0 && buffer) {
197
printf(__FILE__ ": data(%d):", len);
198
for (i = 0; i < 16 && i < len; i++)
199
printf(" %02x", ((__u8 *) buffer)[i]);
200
printf("%s\n", i < len ? "..." : "");
205
#define PTD_DIR_STR(ptd) ({char __c; \
206
switch(PTD_GET_DIR(ptd)){ \
207
case 0: __c = 's'; break; \
208
case 1: __c = 'o'; break; \
209
default: __c = 'i'; break; \
213
Dump PTD info. The code documents the format
216
static inline void dump_ptd(struct ptd *ptd)
222
DBG("PTD(ext) : cc:%x %d%c%d %d,%d,%d t:%x %x%x%x",
224
PTD_GET_FA(ptd), PTD_DIR_STR(ptd), PTD_GET_EP(ptd),
225
PTD_GET_COUNT(ptd), PTD_GET_LEN(ptd), PTD_GET_MPS(ptd),
227
PTD_GET_ACTIVE(ptd), PTD_GET_SPD(ptd), PTD_GET_LAST(ptd));
229
printf("isp116x: %s: PTD(byte): ", __FUNCTION__);
230
for (k = 0; k < sizeof(struct ptd); ++k)
231
printf("%02x ", ((u8 *) ptd)[k]);
236
static inline void dump_ptd_data(struct ptd *ptd, u8 * buf, int type)
241
if (type == 0 /* 0ut data */ ) {
242
printf("isp116x: %s: out data: ", __FUNCTION__);
243
for (k = 0; k < PTD_GET_LEN(ptd); ++k)
244
printf("%02x ", ((u8 *) buf)[k]);
247
if (type == 1 /* 1n data */ ) {
248
printf("isp116x: %s: in data: ", __FUNCTION__);
249
for (k = 0; k < PTD_GET_COUNT(ptd); ++k)
250
printf("%02x ", ((u8 *) buf)[k]);
254
if (PTD_GET_LAST(ptd))
255
DBG("--- last PTD ---");
261
#define dump_msg(dev, pipe, buffer, len, str) do { } while (0)
262
#define dump_pkt(dev, pipe, buffer, len, setup, str, small) do {} while (0)
264
#define dump_ptd(ptd) do {} while (0)
265
#define dump_ptd_data(ptd, buf, type) do {} while (0)
269
/* --- Virtual Root Hub ---------------------------------------------------- */
271
/* Device descriptor */
272
static __u8 root_hub_dev_des[] = {
273
0x12, /* __u8 bLength; */
274
0x01, /* __u8 bDescriptorType; Device */
275
0x10, /* __u16 bcdUSB; v1.1 */
277
0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
278
0x00, /* __u8 bDeviceSubClass; */
279
0x00, /* __u8 bDeviceProtocol; */
280
0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
281
0x00, /* __u16 idVendor; */
283
0x00, /* __u16 idProduct; */
285
0x00, /* __u16 bcdDevice; */
287
0x00, /* __u8 iManufacturer; */
288
0x01, /* __u8 iProduct; */
289
0x00, /* __u8 iSerialNumber; */
290
0x01 /* __u8 bNumConfigurations; */
293
/* Configuration descriptor */
294
static __u8 root_hub_config_des[] = {
295
0x09, /* __u8 bLength; */
296
0x02, /* __u8 bDescriptorType; Configuration */
297
0x19, /* __u16 wTotalLength; */
299
0x01, /* __u8 bNumInterfaces; */
300
0x01, /* __u8 bConfigurationValue; */
301
0x00, /* __u8 iConfiguration; */
302
0x40, /* __u8 bmAttributes;
303
Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
304
0x00, /* __u8 MaxPower; */
307
0x09, /* __u8 if_bLength; */
308
0x04, /* __u8 if_bDescriptorType; Interface */
309
0x00, /* __u8 if_bInterfaceNumber; */
310
0x00, /* __u8 if_bAlternateSetting; */
311
0x01, /* __u8 if_bNumEndpoints; */
312
0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
313
0x00, /* __u8 if_bInterfaceSubClass; */
314
0x00, /* __u8 if_bInterfaceProtocol; */
315
0x00, /* __u8 if_iInterface; */
318
0x07, /* __u8 ep_bLength; */
319
0x05, /* __u8 ep_bDescriptorType; Endpoint */
320
0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
321
0x03, /* __u8 ep_bmAttributes; Interrupt */
322
0x00, /* __u16 ep_wMaxPacketSize; ((MAX_ROOT_PORTS + 1) / 8 */
324
0xff /* __u8 ep_bInterval; 255 ms */
327
static unsigned char root_hub_str_index0[] = {
328
0x04, /* __u8 bLength; */
329
0x03, /* __u8 bDescriptorType; String-descriptor */
330
0x09, /* __u8 lang ID */
331
0x04, /* __u8 lang ID */
334
static unsigned char root_hub_str_index1[] = {
335
0x22, /* __u8 bLength; */
336
0x03, /* __u8 bDescriptorType; String-descriptor */
337
'I', /* __u8 Unicode */
338
0, /* __u8 Unicode */
339
'S', /* __u8 Unicode */
340
0, /* __u8 Unicode */
341
'P', /* __u8 Unicode */
342
0, /* __u8 Unicode */
343
'1', /* __u8 Unicode */
344
0, /* __u8 Unicode */
345
'1', /* __u8 Unicode */
346
0, /* __u8 Unicode */
347
'6', /* __u8 Unicode */
348
0, /* __u8 Unicode */
349
'x', /* __u8 Unicode */
350
0, /* __u8 Unicode */
351
' ', /* __u8 Unicode */
352
0, /* __u8 Unicode */
353
'R', /* __u8 Unicode */
354
0, /* __u8 Unicode */
355
'o', /* __u8 Unicode */
356
0, /* __u8 Unicode */
357
'o', /* __u8 Unicode */
358
0, /* __u8 Unicode */
359
't', /* __u8 Unicode */
360
0, /* __u8 Unicode */
361
' ', /* __u8 Unicode */
362
0, /* __u8 Unicode */
363
'H', /* __u8 Unicode */
364
0, /* __u8 Unicode */
365
'u', /* __u8 Unicode */
366
0, /* __u8 Unicode */
367
'b', /* __u8 Unicode */
368
0, /* __u8 Unicode */
372
* Hub class-specific descriptor is constructed dynamically
375
/* --- Virtual root hub management functions ------------------------------- */
377
static int rh_check_port_status(struct isp116x *isp116x)
383
temp = isp116x_read_reg32(isp116x, HCRHSTATUS);
384
ndp = (temp & RH_A_NDP);
385
for (i = 0; i < ndp; i++) {
386
temp = isp116x_read_reg32(isp116x, HCRHPORT1 + i);
387
/* check for a device disconnect */
388
if (((temp & (RH_PS_PESC | RH_PS_CSC)) ==
389
(RH_PS_PESC | RH_PS_CSC)) && ((temp & RH_PS_CCS) == 0)) {
397
/* --- HC management functions --------------------------------------------- */
399
/* Write len bytes to fifo, pad till 32-bit boundary
401
static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
404
u16 *dp2 = (u16 *) buf;
408
if ((unsigned long)dp2 & 1) {
410
for (; len > 1; len -= 2) {
413
isp116x_raw_write_data16(isp116x, w);
416
isp116x_write_data16(isp116x, (u16) * dp);
419
for (; len > 1; len -= 2)
420
isp116x_raw_write_data16(isp116x, *dp2++);
422
isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
424
if (quot == 1 || quot == 2)
425
isp116x_raw_write_data16(isp116x, 0);
428
/* Read len bytes from fifo and then read till 32-bit boundary
430
static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
433
u16 *dp2 = (u16 *) buf;
437
if ((unsigned long)dp2 & 1) {
439
for (; len > 1; len -= 2) {
440
w = isp116x_raw_read_data16(isp116x);
442
*dp++ = (w >> 8) & 0xff;
445
*dp = 0xff & isp116x_read_data16(isp116x);
448
for (; len > 1; len -= 2)
449
*dp2++ = isp116x_raw_read_data16(isp116x);
451
*(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
453
if (quot == 1 || quot == 2)
454
isp116x_raw_read_data16(isp116x);
457
/* Write PTD's and data for scheduled transfers into the fifo ram.
458
* Fifo must be empty and ready */
459
static void pack_fifo(struct isp116x *isp116x, struct usb_device *dev,
460
unsigned long pipe, struct ptd *ptd, int n, void *data,
463
int buflen = n * sizeof(struct ptd) + len;
466
DBG("--- pack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
468
isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
469
isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
470
isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
473
for (i = 0; i < n; i++) {
474
DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
477
isp116x_write_data16(isp116x, ptd[i].count);
478
isp116x_write_data16(isp116x, ptd[i].mps);
479
isp116x_write_data16(isp116x, ptd[i].len);
480
isp116x_write_data16(isp116x, ptd[i].faddr);
482
dump_ptd_data(&ptd[i], (__u8 *) data + done, 0);
483
write_ptddata_to_fifo(isp116x,
484
(__u8 *) data + done,
485
PTD_GET_LEN(&ptd[i]));
487
done += PTD_GET_LEN(&ptd[i]);
491
/* Read the processed PTD's and data from fifo ram back to URBs' buffers.
492
* Fifo must be full and done */
493
static int unpack_fifo(struct isp116x *isp116x, struct usb_device *dev,
494
unsigned long pipe, struct ptd *ptd, int n, void *data,
497
int buflen = n * sizeof(struct ptd) + len;
498
int i, done, cc, ret;
500
isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
501
isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
502
isp116x_write_addr(isp116x, HCATLPORT);
506
for (i = 0; i < n; i++) {
507
DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
509
ptd[i].count = isp116x_read_data16(isp116x);
510
ptd[i].mps = isp116x_read_data16(isp116x);
511
ptd[i].len = isp116x_read_data16(isp116x);
512
ptd[i].faddr = isp116x_read_data16(isp116x);
515
read_ptddata_from_fifo(isp116x,
516
(__u8 *) data + done,
517
PTD_GET_LEN(&ptd[i]));
518
dump_ptd_data(&ptd[i], (__u8 *) data + done, 1);
520
done += PTD_GET_LEN(&ptd[i]);
522
cc = PTD_GET_CC(&ptd[i]);
524
/* Data underrun means basically that we had more buffer space than
525
* the function had data. It is perfectly normal but upper levels have
526
* to know how much we actually transferred.
528
if (cc == TD_NOTACCESSED ||
529
(cc != TD_CC_NOERROR && (ret == TD_CC_NOERROR || ret == TD_DATAUNDERRUN)))
533
DBG("--- unpack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
538
/* Interrupt handling
540
static int isp116x_interrupt(struct isp116x *isp116x)
546
isp116x_write_reg16(isp116x, HCuPINTENB, 0);
547
irqstat = isp116x_read_reg16(isp116x, HCuPINT);
548
isp116x_write_reg16(isp116x, HCuPINT, irqstat);
549
DBG(">>>>>> irqstat %x <<<<<<", irqstat);
551
if (irqstat & HCuPINT_ATL) {
552
DBG(">>>>>> HCuPINT_ATL <<<<<<");
557
if (irqstat & HCuPINT_OPR) {
558
intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
559
isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
560
DBG(">>>>>> HCuPINT_OPR %x <<<<<<", intstat);
562
if (intstat & HCINT_UE) {
563
ERR("unrecoverable error, controller disabled");
565
/* FIXME: be optimistic, hope that bug won't repeat
566
* often. Make some non-interrupt context restart the
567
* controller. Count and limit the retries though;
568
* either hardware or software errors can go forever...
570
isp116x_reset(isp116x);
575
if (intstat & HCINT_RHSC) {
578
/* When root hub or any of its ports is going
579
to come out of suspend, it may take more
580
than 10ms for status bits to stabilize. */
584
if (intstat & HCINT_SO) {
585
ERR("schedule overrun");
589
irqstat &= ~HCuPINT_OPR;
595
/* With one PTD we can transfer almost 1K in one go;
596
* HC does the splitting into endpoint digestible transactions
600
static inline int max_transfer_len(struct usb_device *dev, unsigned long pipe)
602
unsigned mpck = usb_maxpacket(dev, pipe);
604
/* One PTD can transfer 1023 bytes but try to always
605
* transfer multiples of endpoint buffer size
607
return 1023 / mpck * mpck;
610
/* Do an USB transfer
612
static int isp116x_submit_job(struct usb_device *dev, unsigned long pipe,
613
int dir, void *buffer, int len)
615
struct isp116x *isp116x = &isp116x_dev;
616
int type = usb_pipetype(pipe);
617
int epnum = usb_pipeendpoint(pipe);
618
int max = usb_maxpacket(dev, pipe);
619
int dir_out = usb_pipeout(pipe);
620
int speed_low = usb_pipeslow(pipe);
621
int i, done = 0, stat, timeout, cc;
623
/* 500 frames or 0.5s timeout when function is busy and NAKs transactions for a while */
626
DBG("------------------------------------------------");
627
dump_msg(dev, pipe, buffer, len, "SUBMIT");
628
DBG("------------------------------------------------");
632
dev->status = USB_ST_CRC_ERR;
636
if (isp116x->disabled) {
638
dev->status = USB_ST_CRC_ERR;
642
/* device pulled? Shortcut the action. */
643
if (devgone == dev) {
645
dev->status = USB_ST_CRC_ERR;
646
return USB_ST_CRC_ERR;
650
ERR("pipesize for pipe %lx is zero", pipe);
651
dev->status = USB_ST_CRC_ERR;
655
if (type == PIPE_ISOCHRONOUS) {
656
ERR("isochronous transfers not supported");
657
dev->status = USB_ST_CRC_ERR;
661
/* FIFO not empty? */
662
if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL) {
663
ERR("****** FIFO not empty! ******");
664
dev->status = USB_ST_BUF_ERR;
669
isp116x_write_reg32(isp116x, HCINTSTAT, 0xff);
671
/* Prepare the PTD data */
672
ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK |
673
PTD_TOGGLE(usb_gettoggle(dev, epnum, dir_out));
674
ptd->mps = PTD_MPS(max) | PTD_SPD(speed_low) | PTD_EP(epnum) | PTD_LAST_MSK;
675
ptd->len = PTD_LEN(len) | PTD_DIR(dir);
676
ptd->faddr = PTD_FA(usb_pipedevice(pipe));
679
/* Pack data into FIFO ram */
680
pack_fifo(isp116x, dev, pipe, ptd, 1, buffer, len);
682
wait_ms(EXTRA_DELAY);
685
/* Start the data transfer */
687
/* Allow more time for a BULK device to react - some are slow */
688
if (usb_pipebulk(pipe))
693
/* Wait for it to complete */
695
/* Check whether the controller is done */
696
stat = isp116x_interrupt(isp116x);
699
dev->status = USB_ST_CRC_ERR;
705
/* Check the timeout */
710
stat = USB_ST_CRC_ERR;
715
/* We got an Root Hub Status Change interrupt */
717
isp116x_show_regs(isp116x);
722
timeout = rh_check_port_status(isp116x);
725
* FIXME! NOTE! AAAARGH!
726
* This is potentially dangerous because it assumes
727
* that only one device is ever plugged in!
733
/* Ok, now we can read transfer status */
735
/* FIFO not ready? */
736
if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE)) {
737
ERR("****** FIFO not ready! ******");
738
dev->status = USB_ST_BUF_ERR;
742
/* Unpack data from FIFO ram */
743
cc = unpack_fifo(isp116x, dev, pipe, ptd, 1, buffer, len);
745
i = PTD_GET_COUNT(ptd);
750
/* There was some kind of real problem; Prepare the PTD again
751
* and retry from the failed transaction on
753
if (cc && cc != TD_NOTACCESSED && cc != TD_DATAUNDERRUN) {
754
if (retries >= 100) {
756
/* The chip will have toggled the toggle bit for the failed
757
* transaction too. We have to toggle it back.
759
usb_settoggle(dev, epnum, dir_out, !PTD_GET_TOGGLE(ptd));
763
/* "Normal" errors; TD_NOTACCESSED would mean in effect that the function have NAKed
764
* the transactions from the first on for the whole frame. It may be busy and we retry
765
* with the same PTD. PTD_ACTIVE (and not TD_NOTACCESSED) would mean that some of the
766
* PTD didn't make it because the function was busy or the frame ended before the PTD
767
* finished. We prepare the rest of the data and try again.
769
else if (cc == TD_NOTACCESSED || PTD_GET_ACTIVE(ptd) || (cc != TD_DATAUNDERRUN && PTD_GET_COUNT(ptd) < PTD_GET_LEN(ptd))) {
772
if (cc == TD_NOTACCESSED && PTD_GET_ACTIVE(ptd) && !PTD_GET_COUNT(ptd)) goto retry_same;
773
usb_settoggle(dev, epnum, dir_out, PTD_GET_TOGGLE(ptd));
778
if (cc != TD_CC_NOERROR && cc != TD_DATAUNDERRUN) {
779
DBG("****** completition code error %x ******", cc);
781
case TD_CC_BITSTUFFING:
782
dev->status = USB_ST_BIT_ERR;
785
dev->status = USB_ST_STALLED;
787
case TD_BUFFEROVERRUN:
788
case TD_BUFFERUNDERRUN:
789
dev->status = USB_ST_BUF_ERR;
792
dev->status = USB_ST_CRC_ERR;
796
else usb_settoggle(dev, epnum, dir_out, PTD_GET_TOGGLE(ptd));
798
dump_msg(dev, pipe, buffer, len, "SUBMIT(ret)");
804
/* Adapted from au1x00_usb_ohci.c
806
static int isp116x_submit_rh_msg(struct usb_device *dev, unsigned long pipe,
807
void *buffer, int transfer_len,
808
struct devrequest *cmd)
810
struct isp116x *isp116x = &isp116x_dev;
813
int leni = transfer_len;
817
u8 *data_buf = (u8 *) datab;
823
if (usb_pipeint(pipe)) {
824
INFO("Root-Hub submit IRQ: NOT implemented");
828
bmRType_bReq = cmd->requesttype | (cmd->request << 8);
829
wValue = swap_16(cmd->value);
830
wIndex = swap_16(cmd->index);
831
wLength = swap_16(cmd->length);
833
DBG("--- HUB ----------------------------------------");
834
DBG("submit rh urb, req=%x val=%#x index=%#x len=%d",
835
bmRType_bReq, wValue, wIndex, wLength);
836
dump_msg(dev, pipe, buffer, transfer_len, "RH");
837
DBG("------------------------------------------------");
839
switch (bmRType_bReq) {
841
DBG("RH_GET_STATUS");
843
*(__u16 *) data_buf = swap_16(1);
847
case RH_GET_STATUS | RH_INTERFACE:
848
DBG("RH_GET_STATUS | RH_INTERFACE");
850
*(__u16 *) data_buf = swap_16(0);
854
case RH_GET_STATUS | RH_ENDPOINT:
855
DBG("RH_GET_STATUS | RH_ENDPOINT");
857
*(__u16 *) data_buf = swap_16(0);
861
case RH_GET_STATUS | RH_CLASS:
862
DBG("RH_GET_STATUS | RH_CLASS");
864
tmp = isp116x_read_reg32(isp116x, HCRHSTATUS);
866
*(__u32 *) data_buf = swap_32(tmp & ~(RH_HS_CRWE | RH_HS_DRWE));
870
case RH_GET_STATUS | RH_OTHER | RH_CLASS:
871
DBG("RH_GET_STATUS | RH_OTHER | RH_CLASS");
873
tmp = isp116x_read_reg32(isp116x, HCRHPORT1 + wIndex - 1);
874
*(__u32 *) data_buf = swap_32(tmp);
875
isp116x_show_regs(isp116x);
879
case RH_CLEAR_FEATURE | RH_ENDPOINT:
880
DBG("RH_CLEAR_FEATURE | RH_ENDPOINT");
883
case RH_ENDPOINT_STALL:
884
DBG("C_HUB_ENDPOINT_STALL");
890
case RH_CLEAR_FEATURE | RH_CLASS:
891
DBG("RH_CLEAR_FEATURE | RH_CLASS");
894
case RH_C_HUB_LOCAL_POWER:
895
DBG("C_HUB_LOCAL_POWER");
899
case RH_C_HUB_OVER_CURRENT:
900
DBG("C_HUB_OVER_CURRENT");
901
isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
907
case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
908
DBG("RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS");
912
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
917
case RH_PORT_SUSPEND:
918
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
924
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
929
case RH_C_PORT_CONNECTION:
930
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
935
case RH_C_PORT_ENABLE:
936
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
941
case RH_C_PORT_SUSPEND:
942
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
947
case RH_C_PORT_OVER_CURRENT:
948
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
953
case RH_C_PORT_RESET:
954
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
960
ERR("invalid wValue");
961
stat = USB_ST_STALLED;
964
isp116x_show_regs(isp116x);
968
case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
969
DBG("RH_SET_FEATURE | RH_OTHER | RH_CLASS");
972
case RH_PORT_SUSPEND:
973
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
979
/* Spin until any current reset finishes */
982
isp116x_read_reg32(isp116x,
983
HCRHPORT1 + wIndex - 1);
984
if (!(tmp & RH_PS_PRS))
988
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
996
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
1001
case RH_PORT_ENABLE:
1002
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
1008
ERR("invalid wValue");
1009
stat = USB_ST_STALLED;
1012
isp116x_show_regs(isp116x);
1016
case RH_SET_ADDRESS:
1017
DBG("RH_SET_ADDRESS");
1023
case RH_GET_DESCRIPTOR:
1024
DBG("RH_GET_DESCRIPTOR: %x, %d", wValue, wLength);
1027
case (USB_DT_DEVICE << 8): /* device descriptor */
1028
len = min_t(unsigned int,
1029
leni, min_t(unsigned int,
1030
sizeof(root_hub_dev_des),
1032
data_buf = root_hub_dev_des;
1035
case (USB_DT_CONFIG << 8): /* configuration descriptor */
1036
len = min_t(unsigned int,
1037
leni, min_t(unsigned int,
1038
sizeof(root_hub_config_des),
1040
data_buf = root_hub_config_des;
1043
case ((USB_DT_STRING << 8) | 0x00): /* string 0 descriptors */
1044
len = min_t(unsigned int,
1045
leni, min_t(unsigned int,
1046
sizeof(root_hub_str_index0),
1048
data_buf = root_hub_str_index0;
1051
case ((USB_DT_STRING << 8) | 0x01): /* string 1 descriptors */
1052
len = min_t(unsigned int,
1053
leni, min_t(unsigned int,
1054
sizeof(root_hub_str_index1),
1056
data_buf = root_hub_str_index1;
1060
ERR("invalid wValue");
1061
stat = USB_ST_STALLED;
1066
case RH_GET_DESCRIPTOR | RH_CLASS:
1067
DBG("RH_GET_DESCRIPTOR | RH_CLASS");
1069
tmp = isp116x_read_reg32(isp116x, HCRHDESCA);
1071
data_buf[0] = 0x09; /* min length; */
1073
data_buf[2] = tmp & RH_A_NDP;
1075
if (tmp & RH_A_PSM) /* per-port power switching? */
1076
data_buf[3] |= 0x01;
1077
if (tmp & RH_A_NOCP) /* no overcurrent reporting? */
1078
data_buf[3] |= 0x10;
1079
else if (tmp & RH_A_OCPM) /* per-port overcurrent rep? */
1080
data_buf[3] |= 0x08;
1082
/* Corresponds to data_buf[4-7] */
1084
data_buf[5] = (tmp & RH_A_POTPGT) >> 24;
1086
tmp = isp116x_read_reg32(isp116x, HCRHDESCB);
1088
data_buf[7] = tmp & RH_B_DR;
1089
if (data_buf[2] < 7)
1093
data_buf[8] = (tmp & RH_B_DR) >> 8;
1094
data_buf[10] = data_buf[9] = 0xff;
1097
len = min_t(unsigned int, leni,
1098
min_t(unsigned int, data_buf[0], wLength));
1101
case RH_GET_CONFIGURATION:
1102
DBG("RH_GET_CONFIGURATION");
1104
*(__u8 *) data_buf = 0x01;
1108
case RH_SET_CONFIGURATION:
1109
DBG("RH_SET_CONFIGURATION");
1111
isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPSC);
1116
ERR("*** *** *** unsupported root hub command *** *** ***");
1117
stat = USB_ST_STALLED;
1120
len = min_t(int, len, leni);
1121
if (buffer != data_buf)
1122
memcpy(buffer, data_buf, len);
1126
DBG("dev act_len %d, status %d", dev->act_len, dev->status);
1128
dump_msg(dev, pipe, buffer, transfer_len, "RH(ret)");
1133
/* --- Transfer functions -------------------------------------------------- */
1135
int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1136
int len, int interval)
1138
DBG("dev=%p pipe=%#lx buf=%p size=%d int=%d",
1139
dev, pipe, buffer, len, interval);
1144
int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1145
int len, struct devrequest *setup)
1147
int devnum = usb_pipedevice(pipe);
1148
int epnum = usb_pipeendpoint(pipe);
1149
int max = max_transfer_len(dev, pipe);
1150
int dir_in = usb_pipein(pipe);
1153
/* Control message is for the HUB? */
1154
if (devnum == rh_devnum)
1155
return isp116x_submit_rh_msg(dev, pipe, buffer, len, setup);
1157
/* Ok, no HUB message so send the message to the device */
1160
DBG("--- SETUP PHASE --------------------------------");
1161
usb_settoggle(dev, epnum, 1, 0);
1162
ret = isp116x_submit_job(dev, pipe,
1164
setup, sizeof(struct devrequest));
1166
DBG("control setup phase error (ret = %d", ret);
1171
DBG("--- DATA PHASE ---------------------------------");
1173
usb_settoggle(dev, epnum, !dir_in, 1);
1174
while (done < len) {
1175
ret = isp116x_submit_job(dev, pipe,
1176
dir_in ? PTD_DIR_IN : PTD_DIR_OUT,
1177
(__u8 *) buffer + done,
1178
max > len - done ? len - done : max);
1180
DBG("control data phase error (ret = %d)", ret);
1185
if (dir_in && ret < max) /* short packet */
1190
DBG("--- STATUS PHASE -------------------------------");
1191
usb_settoggle(dev, epnum, !dir_in, 1);
1192
ret = isp116x_submit_job(dev, pipe,
1193
!dir_in ? PTD_DIR_IN : PTD_DIR_OUT, NULL, 0);
1195
DBG("control status phase error (ret = %d", ret);
1199
dev->act_len = done;
1201
dump_msg(dev, pipe, buffer, len, "DEV(ret)");
1206
int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1209
int dir_out = usb_pipeout(pipe);
1210
int max = max_transfer_len(dev, pipe);
1213
DBG("--- BULK ---------------------------------------");
1214
DBG("dev=%ld pipe=%ld buf=%p size=%d dir_out=%d",
1215
usb_pipedevice(pipe), usb_pipeendpoint(pipe), buffer, len, dir_out);
1218
while (done < len) {
1219
ret = isp116x_submit_job(dev, pipe,
1220
!dir_out ? PTD_DIR_IN : PTD_DIR_OUT,
1221
(__u8 *) buffer + done,
1222
max > len - done ? len - done : max);
1224
DBG("error on bulk message (ret = %d)", ret);
1230
if (!dir_out && ret < max) /* short packet */
1234
dev->act_len = done;
1239
/* --- Basic functions ----------------------------------------------------- */
1241
static int isp116x_sw_reset(struct isp116x *isp116x)
1248
isp116x->disabled = 1;
1250
isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1251
isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1253
/* It usually resets within 1 ms */
1255
if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1259
ERR("software reset timeout");
1265
static int isp116x_reset(struct isp116x *isp116x)
1269
int ret, timeout = 15 /* ms */ ;
1273
ret = isp116x_sw_reset(isp116x);
1277
for (t = 0; t < timeout; t++) {
1278
clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1284
ERR("clock not ready after %dms", timeout);
1285
/* After sw_reset the clock won't report to be ready, if
1286
H_WAKEUP pin is high. */
1287
ERR("please make sure that the H_WAKEUP pin is pulled low!");
1293
static void isp116x_stop(struct isp116x *isp116x)
1299
isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1301
/* Switch off ports' power, some devices don't come up
1302
after next 'start' without this */
1303
val = isp116x_read_reg32(isp116x, HCRHDESCA);
1304
val &= ~(RH_A_NPS | RH_A_PSM);
1305
isp116x_write_reg32(isp116x, HCRHDESCA, val);
1306
isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1308
isp116x_sw_reset(isp116x);
1312
* Configure the chip. The chip must be successfully reset by now.
1314
static int isp116x_start(struct isp116x *isp116x)
1316
struct isp116x_platform_data *board = isp116x->board;
1321
/* Clear interrupt status and disable all interrupt sources */
1322
isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1323
isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1325
isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1326
isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1328
/* Hardware configuration */
1329
val = HCHWCFG_DBWIDTH(1);
1330
if (board->sel15Kres)
1331
val |= HCHWCFG_15KRSEL;
1332
/* Remote wakeup won't work without working clock */
1333
if (board->remote_wakeup_enable)
1334
val |= HCHWCFG_CLKNOTSTOP;
1335
if (board->oc_enable)
1336
val |= HCHWCFG_ANALOG_OC;
1337
isp116x_write_reg16(isp116x, HCHWCFG, val);
1339
/* --- Root hub configuration */
1340
val = (25 << 24) & RH_A_POTPGT;
1341
/* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1342
be always set. Yet, instead, we request individual port
1345
/* Report overcurrent per port */
1347
isp116x_write_reg32(isp116x, HCRHDESCA, val);
1348
isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1351
isp116x_write_reg32(isp116x, HCRHDESCB, val);
1352
isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1355
if (board->remote_wakeup_enable)
1357
isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1358
isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1360
isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1362
/* Go operational */
1363
val = HCCONTROL_USB_OPER;
1364
if (board->remote_wakeup_enable)
1365
val |= HCCONTROL_RWE;
1366
isp116x_write_reg32(isp116x, HCCONTROL, val);
1368
/* Disable ports to avoid race in device enumeration */
1369
isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1370
isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1372
isp116x_show_regs(isp116x);
1374
isp116x->disabled = 0;
1379
/* --- Init functions ------------------------------------------------------ */
1381
int isp116x_check_id(struct isp116x *isp116x)
1385
val = isp116x_read_reg16(isp116x, HCCHIPID);
1386
if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1387
ERR("invalid chip ID %04x", val);
1394
int usb_lowlevel_init(void)
1396
struct isp116x *isp116x = &isp116x_dev;
1400
got_rhsc = rh_devnum = 0;
1402
/* Init device registers addr */
1403
isp116x->addr_reg = (u16 *) ISP116X_HCD_ADDR;
1404
isp116x->data_reg = (u16 *) ISP116X_HCD_DATA;
1406
/* Setup specific board settings */
1407
#ifdef ISP116X_HCD_SEL15kRES
1408
isp116x_board.sel15Kres = 1;
1410
#ifdef ISP116X_HCD_OC_ENABLE
1411
isp116x_board.oc_enable = 1;
1413
#ifdef ISP116X_HCD_REMOTE_WAKEUP_ENABLE
1414
isp116x_board.remote_wakeup_enable = 1;
1416
isp116x->board = &isp116x_board;
1418
/* Try to get ISP116x silicon chip ID */
1419
if (isp116x_check_id(isp116x) < 0)
1422
isp116x->disabled = 1;
1423
isp116x->sleeping = 0;
1425
isp116x_reset(isp116x);
1426
isp116x_start(isp116x);
1431
int usb_lowlevel_stop(void)
1433
struct isp116x *isp116x = &isp116x_dev;
1437
if (!isp116x->disabled)
1438
isp116x_stop(isp116x);
added
removed
drivers/usb/host/isp116x-hcd.c
