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/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 <gj@denx.de>
53 * [[GNU/GPL disclaimer]]
55 * Note: Part of this code has been derived from linux
60 #ifdef CONFIG_USB_ISP116X_HCD
64 #include <linux/list.h>
67 * ISP116x chips require certain delays between accesses to its
68 * registers. The following timing options exist.
70 * 1. Configure your memory controller (the best)
71 * 2. Use ndelay (easiest, poorest). For that, enable the following macro.
73 * Value is in microseconds.
75 #ifdef ISP116X_HCD_USE_UDELAY
80 * On some (slowly?) machines an extra delay after data packing into
81 * controller's FIFOs is required, * otherwise you may get the following
86 * USB: scanning bus for devices... isp116x: isp116x_submit_job: CTL:TIMEOUT
87 * isp116x: isp116x_submit_job: ****** FIFO not ready! ******
89 * USB device not responding, giving up (status=4)
90 * isp116x: isp116x_submit_job: ****** FIFO not empty! ******
91 * isp116x: isp116x_submit_job: ****** FIFO not empty! ******
92 * isp116x: isp116x_submit_job: ****** FIFO not empty! ******
93 * 3 USB Device(s) found
94 * scanning bus for storage devices... 0 Storage Device(s) found
96 * Value is in milliseconds.
98 #ifdef ISP116X_HCD_USE_EXTRA_DELAY
103 * Enable the following defines if you wish enable debugging messages.
105 #undef DEBUG /* enable debugging messages */
106 #undef TRACE /* enable tracing code */
107 #undef VERBOSE /* verbose debugging messages */
111 #define DRIVER_VERSION "08 Jan 2007"
112 static const char hcd_name
[] = "isp116x-hcd";
114 struct isp116x isp116x_dev
;
115 struct isp116x_platform_data isp116x_board
;
116 int got_rhsc
= 0; /* root hub status change */
117 struct usb_device
*devgone
; /* device which was disconnected */
118 int rh_devnum
= 0; /* address of Root Hub endpoint */
120 /* ------------------------------------------------------------------------- */
122 #define ALIGN(x,a) (((x)+(a)-1UL)&~((a)-1UL))
123 #define min_t(type,x,y) \
124 ({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
126 /* ------------------------------------------------------------------------- */
128 static int isp116x_reset(struct isp116x
*isp116x
);
130 /* --- Debugging functions ------------------------------------------------- */
132 #define isp116x_show_reg(d, r) { \
134 DBG("%-12s[%02x]: %08x", #r, \
135 r, isp116x_read_reg32(d, r)); \
137 DBG("%-12s[%02x]: %04x", #r, \
138 r, isp116x_read_reg16(d, r)); \
142 #define isp116x_show_regs(d) { \
143 isp116x_show_reg(d, HCREVISION); \
144 isp116x_show_reg(d, HCCONTROL); \
145 isp116x_show_reg(d, HCCMDSTAT); \
146 isp116x_show_reg(d, HCINTSTAT); \
147 isp116x_show_reg(d, HCINTENB); \
148 isp116x_show_reg(d, HCFMINTVL); \
149 isp116x_show_reg(d, HCFMREM); \
150 isp116x_show_reg(d, HCFMNUM); \
151 isp116x_show_reg(d, HCLSTHRESH); \
152 isp116x_show_reg(d, HCRHDESCA); \
153 isp116x_show_reg(d, HCRHDESCB); \
154 isp116x_show_reg(d, HCRHSTATUS); \
155 isp116x_show_reg(d, HCRHPORT1); \
156 isp116x_show_reg(d, HCRHPORT2); \
157 isp116x_show_reg(d, HCHWCFG); \
158 isp116x_show_reg(d, HCDMACFG); \
159 isp116x_show_reg(d, HCXFERCTR); \
160 isp116x_show_reg(d, HCuPINT); \
161 isp116x_show_reg(d, HCuPINTENB); \
162 isp116x_show_reg(d, HCCHIPID); \
163 isp116x_show_reg(d, HCSCRATCH); \
164 isp116x_show_reg(d, HCITLBUFLEN); \
165 isp116x_show_reg(d, HCATLBUFLEN); \
166 isp116x_show_reg(d, HCBUFSTAT); \
167 isp116x_show_reg(d, HCRDITL0LEN); \
168 isp116x_show_reg(d, HCRDITL1LEN); \
173 static int isp116x_get_current_frame_number(struct usb_device
*usb_dev
)
175 struct isp116x
*isp116x
= &isp116x_dev
;
177 return isp116x_read_reg32(isp116x
, HCFMNUM
);
180 static void dump_msg(struct usb_device
*dev
, unsigned long pipe
, void *buffer
,
187 DBG("%s URB:[%4x] dev:%2d,ep:%2d-%c,type:%s,len:%d stat:%#lx",
189 isp116x_get_current_frame_number(dev
),
190 usb_pipedevice(pipe
),
191 usb_pipeendpoint(pipe
),
192 usb_pipeout(pipe
) ? 'O' : 'I',
193 usb_pipetype(pipe
) < 2 ?
196 (usb_pipecontrol(pipe
) ? "CTRL" : "BULK"), len
, dev
->status
);
198 if (len
> 0 && buffer
) {
199 printf(__FILE__
": data(%d):", len
);
200 for (i
= 0; i
< 16 && i
< len
; i
++)
201 printf(" %02x", ((__u8
*) buffer
)[i
]);
202 printf("%s\n", i
< len
? "..." : "");
207 #define PTD_DIR_STR(ptd) ({char __c; \
208 switch(PTD_GET_DIR(ptd)){ \
209 case 0: __c = 's'; break; \
210 case 1: __c = 'o'; break; \
211 default: __c = 'i'; break; \
215 Dump PTD info. The code documents the format
218 static inline void dump_ptd(struct ptd
*ptd
)
224 DBG("PTD(ext) : cc:%x %d%c%d %d,%d,%d t:%x %x%x%x",
226 PTD_GET_FA(ptd
), PTD_DIR_STR(ptd
), PTD_GET_EP(ptd
),
227 PTD_GET_COUNT(ptd
), PTD_GET_LEN(ptd
), PTD_GET_MPS(ptd
),
229 PTD_GET_ACTIVE(ptd
), PTD_GET_SPD(ptd
), PTD_GET_LAST(ptd
));
231 printf("isp116x: %s: PTD(byte): ", __FUNCTION__
);
232 for (k
= 0; k
< sizeof(struct ptd
); ++k
)
233 printf("%02x ", ((u8
*) ptd
)[k
]);
238 static inline void dump_ptd_data(struct ptd
*ptd
, u8
* buf
, int type
)
243 if (type
== 0 /* 0ut data */ ) {
244 printf("isp116x: %s: out data: ", __FUNCTION__
);
245 for (k
= 0; k
< PTD_GET_LEN(ptd
); ++k
)
246 printf("%02x ", ((u8
*) buf
)[k
]);
249 if (type
== 1 /* 1n data */ ) {
250 printf("isp116x: %s: in data: ", __FUNCTION__
);
251 for (k
= 0; k
< PTD_GET_COUNT(ptd
); ++k
)
252 printf("%02x ", ((u8
*) buf
)[k
]);
256 if (PTD_GET_LAST(ptd
))
257 DBG("--- last PTD ---");
263 #define dump_msg(dev, pipe, buffer, len, str) do { } while (0)
264 #define dump_pkt(dev, pipe, buffer, len, setup, str, small) do {} while (0)
266 #define dump_ptd(ptd) do {} while (0)
267 #define dump_ptd_data(ptd, buf, type) do {} while (0)
271 /* --- Virtual Root Hub ---------------------------------------------------- */
273 /* Device descriptor */
274 static __u8 root_hub_dev_des
[] = {
275 0x12, /* __u8 bLength; */
276 0x01, /* __u8 bDescriptorType; Device */
277 0x10, /* __u16 bcdUSB; v1.1 */
279 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
280 0x00, /* __u8 bDeviceSubClass; */
281 0x00, /* __u8 bDeviceProtocol; */
282 0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
283 0x00, /* __u16 idVendor; */
285 0x00, /* __u16 idProduct; */
287 0x00, /* __u16 bcdDevice; */
289 0x00, /* __u8 iManufacturer; */
290 0x01, /* __u8 iProduct; */
291 0x00, /* __u8 iSerialNumber; */
292 0x01 /* __u8 bNumConfigurations; */
295 /* Configuration descriptor */
296 static __u8 root_hub_config_des
[] = {
297 0x09, /* __u8 bLength; */
298 0x02, /* __u8 bDescriptorType; Configuration */
299 0x19, /* __u16 wTotalLength; */
301 0x01, /* __u8 bNumInterfaces; */
302 0x01, /* __u8 bConfigurationValue; */
303 0x00, /* __u8 iConfiguration; */
304 0x40, /* __u8 bmAttributes;
305 Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
306 0x00, /* __u8 MaxPower; */
309 0x09, /* __u8 if_bLength; */
310 0x04, /* __u8 if_bDescriptorType; Interface */
311 0x00, /* __u8 if_bInterfaceNumber; */
312 0x00, /* __u8 if_bAlternateSetting; */
313 0x01, /* __u8 if_bNumEndpoints; */
314 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
315 0x00, /* __u8 if_bInterfaceSubClass; */
316 0x00, /* __u8 if_bInterfaceProtocol; */
317 0x00, /* __u8 if_iInterface; */
320 0x07, /* __u8 ep_bLength; */
321 0x05, /* __u8 ep_bDescriptorType; Endpoint */
322 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
323 0x03, /* __u8 ep_bmAttributes; Interrupt */
324 0x00, /* __u16 ep_wMaxPacketSize; ((MAX_ROOT_PORTS + 1) / 8 */
326 0xff /* __u8 ep_bInterval; 255 ms */
329 static unsigned char root_hub_str_index0
[] = {
330 0x04, /* __u8 bLength; */
331 0x03, /* __u8 bDescriptorType; String-descriptor */
332 0x09, /* __u8 lang ID */
333 0x04, /* __u8 lang ID */
336 static unsigned char root_hub_str_index1
[] = {
337 0x22, /* __u8 bLength; */
338 0x03, /* __u8 bDescriptorType; String-descriptor */
339 'I', /* __u8 Unicode */
340 0, /* __u8 Unicode */
341 'S', /* __u8 Unicode */
342 0, /* __u8 Unicode */
343 'P', /* __u8 Unicode */
344 0, /* __u8 Unicode */
345 '1', /* __u8 Unicode */
346 0, /* __u8 Unicode */
347 '1', /* __u8 Unicode */
348 0, /* __u8 Unicode */
349 '6', /* __u8 Unicode */
350 0, /* __u8 Unicode */
351 'x', /* __u8 Unicode */
352 0, /* __u8 Unicode */
353 ' ', /* __u8 Unicode */
354 0, /* __u8 Unicode */
355 'R', /* __u8 Unicode */
356 0, /* __u8 Unicode */
357 'o', /* __u8 Unicode */
358 0, /* __u8 Unicode */
359 'o', /* __u8 Unicode */
360 0, /* __u8 Unicode */
361 't', /* __u8 Unicode */
362 0, /* __u8 Unicode */
363 ' ', /* __u8 Unicode */
364 0, /* __u8 Unicode */
365 'H', /* __u8 Unicode */
366 0, /* __u8 Unicode */
367 'u', /* __u8 Unicode */
368 0, /* __u8 Unicode */
369 'b', /* __u8 Unicode */
370 0, /* __u8 Unicode */
374 * Hub class-specific descriptor is constructed dynamically
377 /* --- Virtual root hub management functions ------------------------------- */
379 static int rh_check_port_status(struct isp116x
*isp116x
)
385 temp
= isp116x_read_reg32(isp116x
, HCRHSTATUS
);
386 ndp
= (temp
& RH_A_NDP
);
387 for (i
= 0; i
< ndp
; i
++) {
388 temp
= isp116x_read_reg32(isp116x
, HCRHPORT1
+ i
);
389 /* check for a device disconnect */
390 if (((temp
& (RH_PS_PESC
| RH_PS_CSC
)) ==
391 (RH_PS_PESC
| RH_PS_CSC
)) && ((temp
& RH_PS_CCS
) == 0)) {
399 /* --- HC management functions --------------------------------------------- */
401 /* Write len bytes to fifo, pad till 32-bit boundary
403 static void write_ptddata_to_fifo(struct isp116x
*isp116x
, void *buf
, int len
)
406 u16
*dp2
= (u16
*) buf
;
410 if ((unsigned long)dp2
& 1) {
412 for (; len
> 1; len
-= 2) {
415 isp116x_raw_write_data16(isp116x
, w
);
418 isp116x_write_data16(isp116x
, (u16
) * dp
);
421 for (; len
> 1; len
-= 2)
422 isp116x_raw_write_data16(isp116x
, *dp2
++);
424 isp116x_write_data16(isp116x
, 0xff & *((u8
*) dp2
));
426 if (quot
== 1 || quot
== 2)
427 isp116x_raw_write_data16(isp116x
, 0);
430 /* Read len bytes from fifo and then read till 32-bit boundary
432 static void read_ptddata_from_fifo(struct isp116x
*isp116x
, void *buf
, int len
)
435 u16
*dp2
= (u16
*) buf
;
439 if ((unsigned long)dp2
& 1) {
441 for (; len
> 1; len
-= 2) {
442 w
= isp116x_raw_read_data16(isp116x
);
444 *dp
++ = (w
>> 8) & 0xff;
447 *dp
= 0xff & isp116x_read_data16(isp116x
);
450 for (; len
> 1; len
-= 2)
451 *dp2
++ = isp116x_raw_read_data16(isp116x
);
453 *(u8
*) dp2
= 0xff & isp116x_read_data16(isp116x
);
455 if (quot
== 1 || quot
== 2)
456 isp116x_raw_read_data16(isp116x
);
459 /* Write PTD's and data for scheduled transfers into the fifo ram.
460 * Fifo must be empty and ready */
461 static void pack_fifo(struct isp116x
*isp116x
, struct usb_device
*dev
,
462 unsigned long pipe
, struct ptd
*ptd
, int n
, void *data
,
465 int buflen
= n
* sizeof(struct ptd
) + len
;
468 DBG("--- pack buffer %p - %d bytes (fifo %d) ---", data
, len
, buflen
);
470 isp116x_write_reg16(isp116x
, HCuPINT
, HCuPINT_AIIEOT
);
471 isp116x_write_reg16(isp116x
, HCXFERCTR
, buflen
);
472 isp116x_write_addr(isp116x
, HCATLPORT
| ISP116x_WRITE_OFFSET
);
475 for (i
= 0; i
< n
; i
++) {
476 DBG("i=%d - done=%d - len=%d", i
, done
, PTD_GET_LEN(&ptd
[i
]));
479 isp116x_write_data16(isp116x
, ptd
[i
].count
);
480 isp116x_write_data16(isp116x
, ptd
[i
].mps
);
481 isp116x_write_data16(isp116x
, ptd
[i
].len
);
482 isp116x_write_data16(isp116x
, ptd
[i
].faddr
);
484 dump_ptd_data(&ptd
[i
], (__u8
*) data
+ done
, 0);
485 write_ptddata_to_fifo(isp116x
,
486 (__u8
*) data
+ done
,
487 PTD_GET_LEN(&ptd
[i
]));
489 done
+= PTD_GET_LEN(&ptd
[i
]);
493 /* Read the processed PTD's and data from fifo ram back to URBs' buffers.
494 * Fifo must be full and done */
495 static int unpack_fifo(struct isp116x
*isp116x
, struct usb_device
*dev
,
496 unsigned long pipe
, struct ptd
*ptd
, int n
, void *data
,
499 int buflen
= n
* sizeof(struct ptd
) + len
;
500 int i
, done
, cc
, ret
;
502 isp116x_write_reg16(isp116x
, HCuPINT
, HCuPINT_AIIEOT
);
503 isp116x_write_reg16(isp116x
, HCXFERCTR
, buflen
);
504 isp116x_write_addr(isp116x
, HCATLPORT
);
508 for (i
= 0; i
< n
; i
++) {
509 DBG("i=%d - done=%d - len=%d", i
, done
, PTD_GET_LEN(&ptd
[i
]));
511 ptd
[i
].count
= isp116x_read_data16(isp116x
);
512 ptd
[i
].mps
= isp116x_read_data16(isp116x
);
513 ptd
[i
].len
= isp116x_read_data16(isp116x
);
514 ptd
[i
].faddr
= isp116x_read_data16(isp116x
);
517 read_ptddata_from_fifo(isp116x
,
518 (__u8
*) data
+ done
,
519 PTD_GET_LEN(&ptd
[i
]));
520 dump_ptd_data(&ptd
[i
], (__u8
*) data
+ done
, 1);
522 done
+= PTD_GET_LEN(&ptd
[i
]);
524 cc
= PTD_GET_CC(&ptd
[i
]);
525 if (cc
== TD_DATAUNDERRUN
) { /* underrun is no error... */
526 DBG("allowed data underrun");
529 if (cc
!= TD_CC_NOERROR
&& ret
== TD_CC_NOERROR
)
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 #define PTD_NUM 64 /* it should be enougth... */
596 struct ptd ptd
[PTD_NUM
];
597 static inline int max_transfer_len(struct usb_device
*dev
, unsigned long pipe
)
599 return min(PTD_NUM
* usb_maxpacket(dev
, pipe
), PTD_NUM
* 16);
602 /* Do an USB transfer
604 static int isp116x_submit_job(struct usb_device
*dev
, unsigned long pipe
,
605 int dir
, void *buffer
, int len
)
607 struct isp116x
*isp116x
= &isp116x_dev
;
608 int type
= usb_pipetype(pipe
);
609 int epnum
= usb_pipeendpoint(pipe
);
610 int max
= usb_maxpacket(dev
, pipe
);
611 int dir_out
= usb_pipeout(pipe
);
612 int speed_low
= usb_pipeslow(pipe
);
613 int i
, done
, stat
, timeout
, cc
;
616 DBG("------------------------------------------------");
617 dump_msg(dev
, pipe
, buffer
, len
, "SUBMIT");
618 DBG("------------------------------------------------");
620 if (isp116x
->disabled
) {
622 dev
->status
= USB_ST_CRC_ERR
;
626 /* device pulled? Shortcut the action. */
627 if (devgone
== dev
) {
629 dev
->status
= USB_ST_CRC_ERR
;
630 return USB_ST_CRC_ERR
;
634 ERR("pipesize for pipe %lx is zero", pipe
);
635 dev
->status
= USB_ST_CRC_ERR
;
639 if (type
== PIPE_ISOCHRONOUS
) {
640 ERR("isochronous transfers not supported");
641 dev
->status
= USB_ST_CRC_ERR
;
645 /* FIFO not empty? */
646 if (isp116x_read_reg16(isp116x
, HCBUFSTAT
) & HCBUFSTAT_ATL_FULL
) {
647 ERR("****** FIFO not empty! ******");
648 dev
->status
= USB_ST_BUF_ERR
;
653 isp116x_write_reg32(isp116x
, HCINTSTAT
, 0xff);
655 /* Prepare the PTD data */
659 ptd
[i
].count
= PTD_CC_MSK
| PTD_ACTIVE_MSK
|
660 PTD_TOGGLE(usb_gettoggle(dev
, epnum
, dir_out
));
661 ptd
[i
].mps
= PTD_MPS(max
) | PTD_SPD(speed_low
) | PTD_EP(epnum
);
662 ptd
[i
].len
= PTD_LEN(max
> len
- done
? len
- done
: max
) |
664 ptd
[i
].faddr
= PTD_FA(usb_pipedevice(pipe
));
666 usb_dotoggle(dev
, epnum
, dir_out
);
667 done
+= PTD_GET_LEN(&ptd
[i
]);
670 ERR("****** Cannot pack buffer! ******");
671 dev
->status
= USB_ST_BUF_ERR
;
674 } while (done
< len
);
675 ptd
[i
- 1].mps
|= PTD_LAST_MSK
;
677 /* Pack data into FIFO ram */
678 pack_fifo(isp116x
, dev
, pipe
, ptd
, i
, buffer
, len
);
680 wait_ms(EXTRA_DELAY
);
683 /* Start the data transfer */
685 /* Allow more time for a BULK device to react - some are slow */
686 if (usb_pipetype(pipe
) == PIPE_BULK
)
691 /* Wait for it to complete */
693 /* Check whether the controller is done */
694 stat
= isp116x_interrupt(isp116x
);
697 dev
->status
= USB_ST_CRC_ERR
;
703 /* Check the timeout */
708 stat
= USB_ST_CRC_ERR
;
713 /* We got an Root Hub Status Change interrupt */
715 isp116x_show_regs(isp116x
);
720 timeout
= rh_check_port_status(isp116x
);
723 * FIXME! NOTE! AAAARGH!
724 * This is potentially dangerous because it assumes
725 * that only one device is ever plugged in!
731 /* Ok, now we can read transfer status */
733 /* FIFO not ready? */
734 if (!(isp116x_read_reg16(isp116x
, HCBUFSTAT
) & HCBUFSTAT_ATL_DONE
)) {
735 ERR("****** FIFO not ready! ******");
736 dev
->status
= USB_ST_BUF_ERR
;
740 /* Unpack data from FIFO ram */
741 cc
= unpack_fifo(isp116x
, dev
, pipe
, ptd
, i
, buffer
, len
);
743 /* Mmm... sometime we get 0x0f as cc which is a non sense!
744 * Just retry the transfer...
746 if (cc
== 0x0f && retries
-- > 0) {
747 usb_dotoggle(dev
, epnum
, dir_out
);
751 if (cc
!= TD_CC_NOERROR
) {
752 DBG("****** completition code error %x ******", cc
);
754 case TD_CC_BITSTUFFING
:
755 dev
->status
= USB_ST_BIT_ERR
;
758 dev
->status
= USB_ST_STALLED
;
760 case TD_BUFFEROVERRUN
:
761 case TD_BUFFERUNDERRUN
:
762 dev
->status
= USB_ST_BUF_ERR
;
765 dev
->status
= USB_ST_CRC_ERR
;
770 dump_msg(dev
, pipe
, buffer
, len
, "SUBMIT(ret)");
776 /* Adapted from au1x00_usb_ohci.c
778 static int isp116x_submit_rh_msg(struct usb_device
*dev
, unsigned long pipe
,
779 void *buffer
, int transfer_len
,
780 struct devrequest
*cmd
)
782 struct isp116x
*isp116x
= &isp116x_dev
;
785 int leni
= transfer_len
;
789 u8
*data_buf
= (u8
*) datab
;
795 if ((pipe
& PIPE_INTERRUPT
) == PIPE_INTERRUPT
) {
796 INFO("Root-Hub submit IRQ: NOT implemented");
800 bmRType_bReq
= cmd
->requesttype
| (cmd
->request
<< 8);
801 wValue
= swap_16(cmd
->value
);
802 wIndex
= swap_16(cmd
->index
);
803 wLength
= swap_16(cmd
->length
);
805 DBG("--- HUB ----------------------------------------");
806 DBG("submit rh urb, req=%x val=%#x index=%#x len=%d",
807 bmRType_bReq
, wValue
, wIndex
, wLength
);
808 dump_msg(dev
, pipe
, buffer
, transfer_len
, "RH");
809 DBG("------------------------------------------------");
811 switch (bmRType_bReq
) {
813 DBG("RH_GET_STATUS");
815 *(__u16
*) data_buf
= swap_16(1);
819 case RH_GET_STATUS
| RH_INTERFACE
:
820 DBG("RH_GET_STATUS | RH_INTERFACE");
822 *(__u16
*) data_buf
= swap_16(0);
826 case RH_GET_STATUS
| RH_ENDPOINT
:
827 DBG("RH_GET_STATUS | RH_ENDPOINT");
829 *(__u16
*) data_buf
= swap_16(0);
833 case RH_GET_STATUS
| RH_CLASS
:
834 DBG("RH_GET_STATUS | RH_CLASS");
836 tmp
= isp116x_read_reg32(isp116x
, HCRHSTATUS
);
838 *(__u32
*) data_buf
= swap_32(tmp
& ~(RH_HS_CRWE
| RH_HS_DRWE
));
842 case RH_GET_STATUS
| RH_OTHER
| RH_CLASS
:
843 DBG("RH_GET_STATUS | RH_OTHER | RH_CLASS");
845 tmp
= isp116x_read_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1);
846 *(__u32
*) data_buf
= swap_32(tmp
);
847 isp116x_show_regs(isp116x
);
851 case RH_CLEAR_FEATURE
| RH_ENDPOINT
:
852 DBG("RH_CLEAR_FEATURE | RH_ENDPOINT");
855 case RH_ENDPOINT_STALL
:
856 DBG("C_HUB_ENDPOINT_STALL");
862 case RH_CLEAR_FEATURE
| RH_CLASS
:
863 DBG("RH_CLEAR_FEATURE | RH_CLASS");
866 case RH_C_HUB_LOCAL_POWER
:
867 DBG("C_HUB_LOCAL_POWER");
871 case RH_C_HUB_OVER_CURRENT
:
872 DBG("C_HUB_OVER_CURRENT");
873 isp116x_write_reg32(isp116x
, HCRHSTATUS
, RH_HS_OCIC
);
879 case RH_CLEAR_FEATURE
| RH_OTHER
| RH_CLASS
:
880 DBG("RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS");
884 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
889 case RH_PORT_SUSPEND
:
890 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
896 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
901 case RH_C_PORT_CONNECTION
:
902 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
907 case RH_C_PORT_ENABLE
:
908 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
913 case RH_C_PORT_SUSPEND
:
914 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
919 case RH_C_PORT_OVER_CURRENT
:
920 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
925 case RH_C_PORT_RESET
:
926 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
932 ERR("invalid wValue");
933 stat
= USB_ST_STALLED
;
936 isp116x_show_regs(isp116x
);
940 case RH_SET_FEATURE
| RH_OTHER
| RH_CLASS
:
941 DBG("RH_SET_FEATURE | RH_OTHER | RH_CLASS");
944 case RH_PORT_SUSPEND
:
945 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
951 /* Spin until any current reset finishes */
954 isp116x_read_reg32(isp116x
,
955 HCRHPORT1
+ wIndex
- 1);
956 if (!(tmp
& RH_PS_PRS
))
960 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
968 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
974 isp116x_write_reg32(isp116x
, HCRHPORT1
+ wIndex
- 1,
980 ERR("invalid wValue");
981 stat
= USB_ST_STALLED
;
984 isp116x_show_regs(isp116x
);
989 DBG("RH_SET_ADDRESS");
995 case RH_GET_DESCRIPTOR
:
996 DBG("RH_GET_DESCRIPTOR: %x, %d", wValue
, wLength
);
999 case (USB_DT_DEVICE
<< 8): /* device descriptor */
1000 len
= min_t(unsigned int,
1001 leni
, min_t(unsigned int,
1002 sizeof(root_hub_dev_des
),
1004 data_buf
= root_hub_dev_des
;
1007 case (USB_DT_CONFIG
<< 8): /* configuration descriptor */
1008 len
= min_t(unsigned int,
1009 leni
, min_t(unsigned int,
1010 sizeof(root_hub_config_des
),
1012 data_buf
= root_hub_config_des
;
1015 case ((USB_DT_STRING
<< 8) | 0x00): /* string 0 descriptors */
1016 len
= min_t(unsigned int,
1017 leni
, min_t(unsigned int,
1018 sizeof(root_hub_str_index0
),
1020 data_buf
= root_hub_str_index0
;
1023 case ((USB_DT_STRING
<< 8) | 0x01): /* string 1 descriptors */
1024 len
= min_t(unsigned int,
1025 leni
, min_t(unsigned int,
1026 sizeof(root_hub_str_index1
),
1028 data_buf
= root_hub_str_index1
;
1032 ERR("invalid wValue");
1033 stat
= USB_ST_STALLED
;
1038 case RH_GET_DESCRIPTOR
| RH_CLASS
:
1039 DBG("RH_GET_DESCRIPTOR | RH_CLASS");
1041 tmp
= isp116x_read_reg32(isp116x
, HCRHDESCA
);
1043 data_buf
[0] = 0x09; /* min length; */
1045 data_buf
[2] = tmp
& RH_A_NDP
;
1047 if (tmp
& RH_A_PSM
) /* per-port power switching? */
1048 data_buf
[3] |= 0x01;
1049 if (tmp
& RH_A_NOCP
) /* no overcurrent reporting? */
1050 data_buf
[3] |= 0x10;
1051 else if (tmp
& RH_A_OCPM
) /* per-port overcurrent rep? */
1052 data_buf
[3] |= 0x08;
1054 /* Corresponds to data_buf[4-7] */
1056 data_buf
[5] = (tmp
& RH_A_POTPGT
) >> 24;
1058 tmp
= isp116x_read_reg32(isp116x
, HCRHDESCB
);
1060 data_buf
[7] = tmp
& RH_B_DR
;
1061 if (data_buf
[2] < 7)
1065 data_buf
[8] = (tmp
& RH_B_DR
) >> 8;
1066 data_buf
[10] = data_buf
[9] = 0xff;
1069 len
= min_t(unsigned int, leni
,
1070 min_t(unsigned int, data_buf
[0], wLength
));
1073 case RH_GET_CONFIGURATION
:
1074 DBG("RH_GET_CONFIGURATION");
1076 *(__u8
*) data_buf
= 0x01;
1080 case RH_SET_CONFIGURATION
:
1081 DBG("RH_SET_CONFIGURATION");
1083 isp116x_write_reg32(isp116x
, HCRHSTATUS
, RH_HS_LPSC
);
1088 ERR("*** *** *** unsupported root hub command *** *** ***");
1089 stat
= USB_ST_STALLED
;
1092 len
= min_t(int, len
, leni
);
1093 if (buffer
!= data_buf
)
1094 memcpy(buffer
, data_buf
, len
);
1098 DBG("dev act_len %d, status %d", dev
->act_len
, dev
->status
);
1100 dump_msg(dev
, pipe
, buffer
, transfer_len
, "RH(ret)");
1105 /* --- Transfer functions -------------------------------------------------- */
1107 int submit_int_msg(struct usb_device
*dev
, unsigned long pipe
, void *buffer
,
1108 int len
, int interval
)
1110 DBG("dev=%p pipe=%#lx buf=%p size=%d int=%d",
1111 dev
, pipe
, buffer
, len
, interval
);
1116 int submit_control_msg(struct usb_device
*dev
, unsigned long pipe
, void *buffer
,
1117 int len
, struct devrequest
*setup
)
1119 int devnum
= usb_pipedevice(pipe
);
1120 int epnum
= usb_pipeendpoint(pipe
);
1121 int max
= max_transfer_len(dev
, pipe
);
1122 int dir_in
= usb_pipein(pipe
);
1125 /* Control message is for the HUB? */
1126 if (devnum
== rh_devnum
)
1127 return isp116x_submit_rh_msg(dev
, pipe
, buffer
, len
, setup
);
1129 /* Ok, no HUB message so send the message to the device */
1132 DBG("--- SETUP PHASE --------------------------------");
1133 usb_settoggle(dev
, epnum
, 1, 0);
1134 ret
= isp116x_submit_job(dev
, pipe
,
1136 setup
, sizeof(struct devrequest
));
1138 DBG("control setup phase error (ret = %d", ret
);
1143 DBG("--- DATA PHASE ---------------------------------");
1145 usb_settoggle(dev
, epnum
, !dir_in
, 1);
1146 while (done
< len
) {
1147 ret
= isp116x_submit_job(dev
, pipe
,
1148 dir_in
? PTD_DIR_IN
: PTD_DIR_OUT
,
1149 (__u8
*) buffer
+ done
,
1150 max
> len
- done
? len
- done
: max
);
1152 DBG("control data phase error (ret = %d)", ret
);
1157 if (dir_in
&& ret
< max
) /* short packet */
1162 DBG("--- STATUS PHASE -------------------------------");
1163 usb_settoggle(dev
, epnum
, !dir_in
, 1);
1164 ret
= isp116x_submit_job(dev
, pipe
,
1165 !dir_in
? PTD_DIR_IN
: PTD_DIR_OUT
, NULL
, 0);
1167 DBG("control status phase error (ret = %d", ret
);
1171 dev
->act_len
= done
;
1173 dump_msg(dev
, pipe
, buffer
, len
, "DEV(ret)");
1178 int submit_bulk_msg(struct usb_device
*dev
, unsigned long pipe
, void *buffer
,
1181 int dir_out
= usb_pipeout(pipe
);
1182 int max
= max_transfer_len(dev
, pipe
);
1185 DBG("--- BULK ---------------------------------------");
1186 DBG("dev=%ld pipe=%ld buf=%p size=%d dir_out=%d",
1187 usb_pipedevice(pipe
), usb_pipeendpoint(pipe
), buffer
, len
, dir_out
);
1190 while (done
< len
) {
1191 ret
= isp116x_submit_job(dev
, pipe
,
1192 !dir_out
? PTD_DIR_IN
: PTD_DIR_OUT
,
1193 (__u8
*) buffer
+ done
,
1194 max
> len
- done
? len
- done
: max
);
1196 DBG("error on bulk message (ret = %d)", ret
);
1202 if (!dir_out
&& ret
< max
) /* short packet */
1206 dev
->act_len
= done
;
1211 /* --- Basic functions ----------------------------------------------------- */
1213 static int isp116x_sw_reset(struct isp116x
*isp116x
)
1220 isp116x
->disabled
= 1;
1222 isp116x_write_reg16(isp116x
, HCSWRES
, HCSWRES_MAGIC
);
1223 isp116x_write_reg32(isp116x
, HCCMDSTAT
, HCCMDSTAT_HCR
);
1225 /* It usually resets within 1 ms */
1227 if (!(isp116x_read_reg32(isp116x
, HCCMDSTAT
) & HCCMDSTAT_HCR
))
1231 ERR("software reset timeout");
1237 static int isp116x_reset(struct isp116x
*isp116x
)
1241 int ret
, timeout
= 15 /* ms */ ;
1245 ret
= isp116x_sw_reset(isp116x
);
1249 for (t
= 0; t
< timeout
; t
++) {
1250 clkrdy
= isp116x_read_reg16(isp116x
, HCuPINT
) & HCuPINT_CLKRDY
;
1256 ERR("clock not ready after %dms", timeout
);
1257 /* After sw_reset the clock won't report to be ready, if
1258 H_WAKEUP pin is high. */
1259 ERR("please make sure that the H_WAKEUP pin is pulled low!");
1265 static void isp116x_stop(struct isp116x
*isp116x
)
1271 isp116x_write_reg16(isp116x
, HCuPINTENB
, 0);
1273 /* Switch off ports' power, some devices don't come up
1274 after next 'start' without this */
1275 val
= isp116x_read_reg32(isp116x
, HCRHDESCA
);
1276 val
&= ~(RH_A_NPS
| RH_A_PSM
);
1277 isp116x_write_reg32(isp116x
, HCRHDESCA
, val
);
1278 isp116x_write_reg32(isp116x
, HCRHSTATUS
, RH_HS_LPS
);
1280 isp116x_sw_reset(isp116x
);
1284 * Configure the chip. The chip must be successfully reset by now.
1286 static int isp116x_start(struct isp116x
*isp116x
)
1288 struct isp116x_platform_data
*board
= isp116x
->board
;
1293 /* Clear interrupt status and disable all interrupt sources */
1294 isp116x_write_reg16(isp116x
, HCuPINT
, 0xff);
1295 isp116x_write_reg16(isp116x
, HCuPINTENB
, 0);
1297 isp116x_write_reg16(isp116x
, HCITLBUFLEN
, ISP116x_ITL_BUFSIZE
);
1298 isp116x_write_reg16(isp116x
, HCATLBUFLEN
, ISP116x_ATL_BUFSIZE
);
1300 /* Hardware configuration */
1301 val
= HCHWCFG_DBWIDTH(1);
1302 if (board
->sel15Kres
)
1303 val
|= HCHWCFG_15KRSEL
;
1304 /* Remote wakeup won't work without working clock */
1305 if (board
->remote_wakeup_enable
)
1306 val
|= HCHWCFG_CLKNOTSTOP
;
1307 if (board
->oc_enable
)
1308 val
|= HCHWCFG_ANALOG_OC
;
1309 isp116x_write_reg16(isp116x
, HCHWCFG
, val
);
1311 /* --- Root hub configuration */
1312 val
= (25 << 24) & RH_A_POTPGT
;
1313 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1314 be always set. Yet, instead, we request individual port
1317 /* Report overcurrent per port */
1319 isp116x_write_reg32(isp116x
, HCRHDESCA
, val
);
1320 isp116x
->rhdesca
= isp116x_read_reg32(isp116x
, HCRHDESCA
);
1323 isp116x_write_reg32(isp116x
, HCRHDESCB
, val
);
1324 isp116x
->rhdescb
= isp116x_read_reg32(isp116x
, HCRHDESCB
);
1327 if (board
->remote_wakeup_enable
)
1329 isp116x_write_reg32(isp116x
, HCRHSTATUS
, val
);
1330 isp116x
->rhstatus
= isp116x_read_reg32(isp116x
, HCRHSTATUS
);
1332 isp116x_write_reg32(isp116x
, HCFMINTVL
, 0x27782edf);
1334 /* Go operational */
1335 val
= HCCONTROL_USB_OPER
;
1336 if (board
->remote_wakeup_enable
)
1337 val
|= HCCONTROL_RWE
;
1338 isp116x_write_reg32(isp116x
, HCCONTROL
, val
);
1340 /* Disable ports to avoid race in device enumeration */
1341 isp116x_write_reg32(isp116x
, HCRHPORT1
, RH_PS_CCS
);
1342 isp116x_write_reg32(isp116x
, HCRHPORT2
, RH_PS_CCS
);
1344 isp116x_show_regs(isp116x
);
1346 isp116x
->disabled
= 0;
1351 /* --- Init functions ------------------------------------------------------ */
1353 int isp116x_check_id(struct isp116x
*isp116x
)
1357 val
= isp116x_read_reg16(isp116x
, HCCHIPID
);
1358 if ((val
& HCCHIPID_MASK
) != HCCHIPID_MAGIC
) {
1359 ERR("invalid chip ID %04x", val
);
1366 int usb_lowlevel_init(void)
1368 struct isp116x
*isp116x
= &isp116x_dev
;
1372 /* Init device registers addr */
1373 isp116x
->addr_reg
= (u16
*) ISP116X_HCD_ADDR
;
1374 isp116x
->data_reg
= (u16
*) ISP116X_HCD_DATA
;
1376 /* Setup specific board settings */
1377 #ifdef ISP116X_HCD_SEL15kRES
1378 isp116x_board
.sel15Kres
= 1;
1380 #ifdef ISP116X_HCD_OC_ENABLE
1381 isp116x_board
.oc_enable
= 1;
1383 #ifdef ISP116X_HCD_REMOTE_WAKEUP_ENABLE
1384 isp116x_board
.remote_wakeup_enable
= 1;
1386 isp116x
->board
= &isp116x_board
;
1388 /* Try to get ISP116x silicon chip ID */
1389 if (isp116x_check_id(isp116x
) < 0)
1392 isp116x
->disabled
= 1;
1393 isp116x
->sleeping
= 0;
1395 isp116x_reset(isp116x
);
1396 isp116x_start(isp116x
);
1401 int usb_lowlevel_stop(void)
1403 struct isp116x
*isp116x
= &isp116x_dev
;
1407 if (!isp116x
->disabled
)
1408 isp116x_stop(isp116x
);
1413 #endif /* CONFIG_USB_ISP116X_HCD */