Merge with git://www.denx.de/git/u-boot.git
[platform/kernel/u-boot.git] / drivers / isp116x-hcd.c
1 /*
2  * ISP116x HCD (Host Controller Driver) for u-boot.
3  *
4  * Copyright (C) 2006-2007 Rodolfo Giometti <giometti@linux.it>
5  * Copyright (C) 2006-2007 Eurotech S.p.A. <info@eurotech.it>
6  *
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.
11  *
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.
16  *
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,
20  * MA 02111-1307 USA
21  *
22  *
23  * Derived in part from the SL811 HCD driver "u-boot/drivers/sl811_usb.c"
24  * (original copyright message follows):
25  *
26  *    (C) Copyright 2004
27  *    Wolfgang Denk, DENX Software Engineering, wd@denx.de.
28  *
29  *    This code is based on linux driver for sl811hs chip, source at
30  *    drivers/usb/host/sl811.c:
31  *
32  *    SL811 Host Controller Interface driver for USB.
33  *
34  *    Copyright (c) 2003/06, Courage Co., Ltd.
35  *
36  *    Based on:
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>
42  *
43  *    [[GNU/GPL disclaimer]]
44  *
45  * and in part from AU1x00 OHCI HCD driver "u-boot/cpu/mips/au1x00_usb_ohci.c"
46  * (original copyright message follows):
47  *
48  *    URB OHCI HCD (Host Controller Driver) for USB on the AU1x00.
49  *
50  *    (C) Copyright 2003
51  *    Gary Jennejohn, DENX Software Engineering <gj@denx.de>
52  *
53  *    [[GNU/GPL disclaimer]]
54  *
55  *    Note: Part of this code has been derived from linux
56  */
57
58 #include <common.h>
59
60 #ifdef CONFIG_USB_ISP116X_HCD
61 #include <asm/io.h>
62 #include <usb.h>
63 #include <malloc.h>
64 #include <linux/list.h>
65
66 /*
67  * ISP116x chips require certain delays between accesses to its
68  * registers. The following timing options exist.
69  *
70  * 1. Configure your memory controller (the best)
71  * 2. Use ndelay (easiest, poorest). For that, enable the following macro.
72  *
73  * Value is in microseconds.
74  */
75 #ifdef ISP116X_HCD_USE_UDELAY
76 #define UDELAY          1
77 #endif
78
79 /*
80  * On some (slowly?) machines an extra delay after data packing into
81  * controller's FIFOs is required, * otherwise you may get the following
82  * error:
83  *
84  *   uboot> usb start
85  *   (Re)start USB...
86  *   USB:   scanning bus for devices... isp116x: isp116x_submit_job: CTL:TIMEOUT
87  *   isp116x: isp116x_submit_job: ****** FIFO not ready! ******
88  *
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
95  *
96  * Value is in milliseconds.
97  */
98 #ifdef ISP116X_HCD_USE_EXTRA_DELAY
99 #define EXTRA_DELAY     2
100 #endif
101
102 /*
103  * Enable the following defines if you wish enable debugging messages.
104  */
105 #undef DEBUG                    /* enable debugging messages */
106 #undef TRACE                    /* enable tracing code */
107 #undef VERBOSE                  /* verbose debugging messages */
108
109 #include "isp116x.h"
110
111 #define DRIVER_VERSION  "08 Jan 2007"
112 static const char hcd_name[] = "isp116x-hcd";
113
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 */
119
120 /* ------------------------------------------------------------------------- */
121
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; })
125
126 /* ------------------------------------------------------------------------- */
127
128 static int isp116x_reset(struct isp116x *isp116x);
129
130 /* --- Debugging functions ------------------------------------------------- */
131
132 #define isp116x_show_reg(d, r) {                                \
133         if ((r) < 0x20) {                                       \
134                 DBG("%-12s[%02x]: %08x", #r,                    \
135                         r, isp116x_read_reg32(d, r));           \
136         } else {                                                \
137                 DBG("%-12s[%02x]:     %04x", #r,                \
138                         r, isp116x_read_reg16(d, r));           \
139         }                                                       \
140 }
141
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);                       \
169 }
170
171 #if defined(TRACE)
172
173 static int isp116x_get_current_frame_number(struct usb_device *usb_dev)
174 {
175         struct isp116x *isp116x = &isp116x_dev;
176
177         return isp116x_read_reg32(isp116x, HCFMNUM);
178 }
179
180 static void dump_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
181                      int len, char *str)
182 {
183 #if defined(VERBOSE)
184         int i;
185 #endif
186
187         DBG("%s URB:[%4x] dev:%2d,ep:%2d-%c,type:%s,len:%d stat:%#lx",
188             str,
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 ?
194             (usb_pipeint(pipe) ?
195              "INTR" : "ISOC") :
196             (usb_pipecontrol(pipe) ? "CTRL" : "BULK"), len, dev->status);
197 #if defined(VERBOSE)
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 ? "..." : "");
203         }
204 #endif
205 }
206
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;              \
212         }; __c;})
213
214 /*
215   Dump PTD info. The code documents the format
216   perfectly, right :)
217 */
218 static inline void dump_ptd(struct ptd *ptd)
219 {
220 #if defined(VERBOSE)
221         int k;
222 #endif
223
224         DBG("PTD(ext) : cc:%x %d%c%d %d,%d,%d t:%x %x%x%x",
225             PTD_GET_CC(ptd),
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),
228             PTD_GET_TOGGLE(ptd),
229             PTD_GET_ACTIVE(ptd), PTD_GET_SPD(ptd), PTD_GET_LAST(ptd));
230 #if defined(VERBOSE)
231         printf("isp116x: %s: PTD(byte): ", __FUNCTION__);
232         for (k = 0; k < sizeof(struct ptd); ++k)
233                 printf("%02x ", ((u8 *) ptd)[k]);
234         printf("\n");
235 #endif
236 }
237
238 static inline void dump_ptd_data(struct ptd *ptd, u8 * buf, int type)
239 {
240 #if defined(VERBOSE)
241         int k;
242
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]);
247                 printf("\n");
248         }
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]);
253                 printf("\n");
254         }
255
256         if (PTD_GET_LAST(ptd))
257                 DBG("--- last PTD ---");
258 #endif
259 }
260
261 #else
262
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)
265
266 #define dump_ptd(ptd)                   do {} while (0)
267 #define dump_ptd_data(ptd, buf, type)   do {} while (0)
268
269 #endif
270
271 /* --- Virtual Root Hub ---------------------------------------------------- */
272
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 */
278         0x01,
279         0x09,                   /*  __u8  bDeviceClass; HUB_CLASSCODE */
280         0x00,                   /*  __u8  bDeviceSubClass; */
281         0x00,                   /*  __u8  bDeviceProtocol; */
282         0x08,                   /*  __u8  bMaxPacketSize0; 8 Bytes */
283         0x00,                   /*  __u16 idVendor; */
284         0x00,
285         0x00,                   /*  __u16 idProduct; */
286         0x00,
287         0x00,                   /*  __u16 bcdDevice; */
288         0x00,
289         0x00,                   /*  __u8  iManufacturer; */
290         0x01,                   /*  __u8  iProduct; */
291         0x00,                   /*  __u8  iSerialNumber; */
292         0x01                    /*  __u8  bNumConfigurations; */
293 };
294
295 /* Configuration descriptor */
296 static __u8 root_hub_config_des[] = {
297         0x09,                   /*  __u8  bLength; */
298         0x02,                   /*  __u8  bDescriptorType; Configuration */
299         0x19,                   /*  __u16 wTotalLength; */
300         0x00,
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; */
307
308         /* interface */
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; */
318
319         /* endpoint */
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 */
325         0x02,
326         0xff                    /*  __u8  ep_bInterval; 255 ms */
327 };
328
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 */
334 };
335
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 */
371 };
372
373 /*
374  * Hub class-specific descriptor is constructed dynamically
375  */
376
377 /* --- Virtual root hub management functions ------------------------------- */
378
379 static int rh_check_port_status(struct isp116x *isp116x)
380 {
381         u32 temp, ndp, i;
382         int res;
383
384         res = -1;
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)) {
392                         res = i;
393                         break;
394                 }
395         }
396         return res;
397 }
398
399 /* --- HC management functions --------------------------------------------- */
400
401 /* Write len bytes to fifo, pad till 32-bit boundary
402  */
403 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
404 {
405         u8 *dp = (u8 *) buf;
406         u16 *dp2 = (u16 *) buf;
407         u16 w;
408         int quot = len % 4;
409
410         if ((unsigned long)dp2 & 1) {
411                 /* not aligned */
412                 for (; len > 1; len -= 2) {
413                         w = *dp++;
414                         w |= *dp++ << 8;
415                         isp116x_raw_write_data16(isp116x, w);
416                 }
417                 if (len)
418                         isp116x_write_data16(isp116x, (u16) * dp);
419         } else {
420                 /* aligned */
421                 for (; len > 1; len -= 2)
422                         isp116x_raw_write_data16(isp116x, *dp2++);
423                 if (len)
424                         isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
425         }
426         if (quot == 1 || quot == 2)
427                 isp116x_raw_write_data16(isp116x, 0);
428 }
429
430 /* Read len bytes from fifo and then read till 32-bit boundary
431  */
432 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
433 {
434         u8 *dp = (u8 *) buf;
435         u16 *dp2 = (u16 *) buf;
436         u16 w;
437         int quot = len % 4;
438
439         if ((unsigned long)dp2 & 1) {
440                 /* not aligned */
441                 for (; len > 1; len -= 2) {
442                         w = isp116x_raw_read_data16(isp116x);
443                         *dp++ = w & 0xff;
444                         *dp++ = (w >> 8) & 0xff;
445                 }
446                 if (len)
447                         *dp = 0xff & isp116x_read_data16(isp116x);
448         } else {
449                 /* aligned */
450                 for (; len > 1; len -= 2)
451                         *dp2++ = isp116x_raw_read_data16(isp116x);
452                 if (len)
453                         *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
454         }
455         if (quot == 1 || quot == 2)
456                 isp116x_raw_read_data16(isp116x);
457 }
458
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,
463                       int len)
464 {
465         int buflen = n * sizeof(struct ptd) + len;
466         int i, done;
467
468         DBG("--- pack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
469
470         isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
471         isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
472         isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
473
474         done = 0;
475         for (i = 0; i < n; i++) {
476                 DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
477
478                 dump_ptd(&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);
483
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]));
488
489                 done += PTD_GET_LEN(&ptd[i]);
490         }
491 }
492
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,
497                        int len)
498 {
499         int buflen = n * sizeof(struct ptd) + len;
500         int i, done, cc, ret;
501
502         isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
503         isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
504         isp116x_write_addr(isp116x, HCATLPORT);
505
506         ret = TD_CC_NOERROR;
507         done = 0;
508         for (i = 0; i < n; i++) {
509                 DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
510
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);
515                 dump_ptd(&ptd[i]);
516
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);
521
522                 done += PTD_GET_LEN(&ptd[i]);
523
524                 cc = PTD_GET_CC(&ptd[i]);
525                 if (cc == TD_DATAUNDERRUN) {    /* underrun is no error... */
526                         DBG("allowed data underrun");
527                         cc = TD_CC_NOERROR;
528                 }
529                 if (cc != TD_CC_NOERROR && ret == TD_CC_NOERROR)
530                         ret = cc;
531         }
532
533         DBG("--- unpack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
534
535         return ret;
536 }
537
538 /* Interrupt handling
539  */
540 static int isp116x_interrupt(struct isp116x *isp116x)
541 {
542         u16 irqstat;
543         u32 intstat;
544         int ret = 0;
545
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);
550
551         if (irqstat & HCuPINT_ATL) {
552                 DBG(">>>>>> HCuPINT_ATL <<<<<<");
553                 ret = 1;
554         }
555
556         if (irqstat & HCuPINT_OPR) {
557                 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
558                 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
559                 DBG(">>>>>> HCuPINT_OPR %x <<<<<<", intstat);
560
561                 if (intstat & HCINT_UE) {
562                         ERR("unrecoverable error, controller disabled");
563
564                         /* FIXME: be optimistic, hope that bug won't repeat
565                          * often. Make some non-interrupt context restart the
566                          * controller. Count and limit the retries though;
567                          * either hardware or software errors can go forever...
568                          */
569                         isp116x_reset(isp116x);
570                         ret = -1;
571                         return -1;
572                 }
573
574                 if (intstat & HCINT_RHSC) {
575                         got_rhsc = 1;
576                         ret = 1;
577                         /* When root hub or any of its ports is going
578                            to come out of suspend, it may take more
579                            than 10ms for status bits to stabilize. */
580                         wait_ms(20);
581                 }
582
583                 if (intstat & HCINT_SO) {
584                         ERR("schedule overrun");
585                         ret = -1;
586                 }
587
588                 irqstat &= ~HCuPINT_OPR;
589         }
590
591         return ret;
592 }
593
594 #define PTD_NUM                 64      /* it should be enougth... */
595 struct ptd ptd[PTD_NUM];
596 static inline int max_transfer_len(struct usb_device *dev, unsigned long pipe)
597 {
598         return min(PTD_NUM * usb_maxpacket(dev, pipe), PTD_NUM * 16);
599 }
600
601 /* Do an USB transfer
602  */
603 static int isp116x_submit_job(struct usb_device *dev, unsigned long pipe,
604                               int dir, void *buffer, int len)
605 {
606         struct isp116x *isp116x = &isp116x_dev;
607         int type = usb_pipetype(pipe);
608         int epnum = usb_pipeendpoint(pipe);
609         int max = usb_maxpacket(dev, pipe);
610         int dir_out = usb_pipeout(pipe);
611         int speed_low = usb_pipeslow(pipe);
612         int i, done, stat, timeout, cc;
613         int retries = 10;
614
615         DBG("------------------------------------------------");
616         dump_msg(dev, pipe, buffer, len, "SUBMIT");
617         DBG("------------------------------------------------");
618
619         if (isp116x->disabled) {
620                 ERR("EPIPE");
621                 dev->status = USB_ST_CRC_ERR;
622                 return -1;
623         }
624
625         /* device pulled? Shortcut the action. */
626         if (devgone == dev) {
627                 ERR("ENODEV");
628                 dev->status = USB_ST_CRC_ERR;
629                 return USB_ST_CRC_ERR;
630         }
631
632         if (!max) {
633                 ERR("pipesize for pipe %lx is zero", pipe);
634                 dev->status = USB_ST_CRC_ERR;
635                 return -1;
636         }
637
638         if (type == PIPE_ISOCHRONOUS) {
639                 ERR("isochronous transfers not supported");
640                 dev->status = USB_ST_CRC_ERR;
641                 return -1;
642         }
643
644         /* FIFO not empty? */
645         if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL) {
646                 ERR("****** FIFO not empty! ******");
647                 dev->status = USB_ST_BUF_ERR;
648                 return -1;
649         }
650
651       retry:
652         isp116x_write_reg32(isp116x, HCINTSTAT, 0xff);
653
654         /* Prepare the PTD data */
655         done = 0;
656         i = 0;
657         do {
658                 ptd[i].count = PTD_CC_MSK | PTD_ACTIVE_MSK |
659                     PTD_TOGGLE(usb_gettoggle(dev, epnum, dir_out));
660                 ptd[i].mps = PTD_MPS(max) | PTD_SPD(speed_low) | PTD_EP(epnum);
661                 ptd[i].len = PTD_LEN(max > len - done ? len - done : max) |
662                     PTD_DIR(dir);
663                 ptd[i].faddr = PTD_FA(usb_pipedevice(pipe));
664
665                 usb_dotoggle(dev, epnum, dir_out);
666                 done += PTD_GET_LEN(&ptd[i]);
667                 i++;
668                 if (i >= PTD_NUM) {
669                         ERR("****** Cannot pack buffer! ******");
670                         dev->status = USB_ST_BUF_ERR;
671                         return -1;
672                 }
673         } while (done < len);
674         ptd[i - 1].mps |= PTD_LAST_MSK;
675
676         /* Pack data into FIFO ram */
677         pack_fifo(isp116x, dev, pipe, ptd, i, buffer, len);
678 #ifdef EXTRA_DELAY
679         wait_ms(EXTRA_DELAY);
680 #endif
681
682         /* Start the data transfer */
683
684         /* Allow more time for a BULK device to react - some are slow */
685         if (usb_pipetype(pipe) == PIPE_BULK)
686                 timeout = 5000;
687         else
688                 timeout = 100;
689
690         /* Wait for it to complete */
691         for (;;) {
692                 /* Check whether the controller is done */
693                 stat = isp116x_interrupt(isp116x);
694
695                 if (stat < 0) {
696                         dev->status = USB_ST_CRC_ERR;
697                         break;
698                 }
699                 if (stat > 0)
700                         break;
701
702                 /* Check the timeout */
703                 if (--timeout)
704                         udelay(1);
705                 else {
706                         ERR("CTL:TIMEOUT ");
707                         stat = USB_ST_CRC_ERR;
708                         break;
709                 }
710         }
711
712         /* We got an Root Hub Status Change interrupt */
713         if (got_rhsc) {
714                 isp116x_show_regs(isp116x);
715
716                 got_rhsc = 0;
717
718                 /* Abuse timeout */
719                 timeout = rh_check_port_status(isp116x);
720                 if (timeout >= 0) {
721                         /*
722                          * FIXME! NOTE! AAAARGH!
723                          * This is potentially dangerous because it assumes
724                          * that only one device is ever plugged in!
725                          */
726                         devgone = dev;
727                 }
728         }
729
730         /* Ok, now we can read transfer status */
731
732         /* FIFO not ready? */
733         if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE)) {
734                 ERR("****** FIFO not ready! ******");
735                 dev->status = USB_ST_BUF_ERR;
736                 return -1;
737         }
738
739         /* Unpack data from FIFO ram */
740         cc = unpack_fifo(isp116x, dev, pipe, ptd, i, buffer, len);
741
742         /* Mmm... sometime we get 0x0f as cc which is a non sense!
743          * Just retry the transfer...
744          */
745         if (cc == 0x0f && retries-- > 0) {
746                 usb_dotoggle(dev, epnum, dir_out);
747                 goto retry;
748         }
749
750         if (cc != TD_CC_NOERROR) {
751                 DBG("****** completition code error %x ******", cc);
752                 switch (cc) {
753                 case TD_CC_BITSTUFFING:
754                         dev->status = USB_ST_BIT_ERR;
755                         break;
756                 case TD_CC_STALL:
757                         dev->status = USB_ST_STALLED;
758                         break;
759                 case TD_BUFFEROVERRUN:
760                 case TD_BUFFERUNDERRUN:
761                         dev->status = USB_ST_BUF_ERR;
762                         break;
763                 default:
764                         dev->status = USB_ST_CRC_ERR;
765                 }
766                 return -cc;
767         }
768
769         dump_msg(dev, pipe, buffer, len, "SUBMIT(ret)");
770
771         dev->status = 0;
772         return done;
773 }
774
775 /* Adapted from au1x00_usb_ohci.c
776  */
777 static int isp116x_submit_rh_msg(struct usb_device *dev, unsigned long pipe,
778                                  void *buffer, int transfer_len,
779                                  struct devrequest *cmd)
780 {
781         struct isp116x *isp116x = &isp116x_dev;
782         u32 tmp = 0;
783
784         int leni = transfer_len;
785         int len = 0;
786         int stat = 0;
787         u32 datab[4];
788         u8 *data_buf = (u8 *) datab;
789         u16 bmRType_bReq;
790         u16 wValue;
791         u16 wIndex;
792         u16 wLength;
793
794         if ((pipe & PIPE_INTERRUPT) == PIPE_INTERRUPT) {
795                 INFO("Root-Hub submit IRQ: NOT implemented");
796                 return 0;
797         }
798
799         bmRType_bReq = cmd->requesttype | (cmd->request << 8);
800         wValue = swap_16(cmd->value);
801         wIndex = swap_16(cmd->index);
802         wLength = swap_16(cmd->length);
803
804         DBG("--- HUB ----------------------------------------");
805         DBG("submit rh urb, req=%x val=%#x index=%#x len=%d",
806             bmRType_bReq, wValue, wIndex, wLength);
807         dump_msg(dev, pipe, buffer, transfer_len, "RH");
808         DBG("------------------------------------------------");
809
810         switch (bmRType_bReq) {
811         case RH_GET_STATUS:
812                 DBG("RH_GET_STATUS");
813
814                 *(__u16 *) data_buf = swap_16(1);
815                 len = 2;
816                 break;
817
818         case RH_GET_STATUS | RH_INTERFACE:
819                 DBG("RH_GET_STATUS | RH_INTERFACE");
820
821                 *(__u16 *) data_buf = swap_16(0);
822                 len = 2;
823                 break;
824
825         case RH_GET_STATUS | RH_ENDPOINT:
826                 DBG("RH_GET_STATUS | RH_ENDPOINT");
827
828                 *(__u16 *) data_buf = swap_16(0);
829                 len = 2;
830                 break;
831
832         case RH_GET_STATUS | RH_CLASS:
833                 DBG("RH_GET_STATUS | RH_CLASS");
834
835                 tmp = isp116x_read_reg32(isp116x, HCRHSTATUS);
836
837                 *(__u32 *) data_buf = swap_32(tmp & ~(RH_HS_CRWE | RH_HS_DRWE));
838                 len = 4;
839                 break;
840
841         case RH_GET_STATUS | RH_OTHER | RH_CLASS:
842                 DBG("RH_GET_STATUS | RH_OTHER | RH_CLASS");
843
844                 tmp = isp116x_read_reg32(isp116x, HCRHPORT1 + wIndex - 1);
845                 *(__u32 *) data_buf = swap_32(tmp);
846                 isp116x_show_regs(isp116x);
847                 len = 4;
848                 break;
849
850         case RH_CLEAR_FEATURE | RH_ENDPOINT:
851                 DBG("RH_CLEAR_FEATURE | RH_ENDPOINT");
852
853                 switch (wValue) {
854                 case RH_ENDPOINT_STALL:
855                         DBG("C_HUB_ENDPOINT_STALL");
856                         len = 0;
857                         break;
858                 }
859                 break;
860
861         case RH_CLEAR_FEATURE | RH_CLASS:
862                 DBG("RH_CLEAR_FEATURE | RH_CLASS");
863
864                 switch (wValue) {
865                 case RH_C_HUB_LOCAL_POWER:
866                         DBG("C_HUB_LOCAL_POWER");
867                         len = 0;
868                         break;
869
870                 case RH_C_HUB_OVER_CURRENT:
871                         DBG("C_HUB_OVER_CURRENT");
872                         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
873                         len = 0;
874                         break;
875                 }
876                 break;
877
878         case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
879                 DBG("RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS");
880
881                 switch (wValue) {
882                 case RH_PORT_ENABLE:
883                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
884                                             RH_PS_CCS);
885                         len = 0;
886                         break;
887
888                 case RH_PORT_SUSPEND:
889                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
890                                             RH_PS_POCI);
891                         len = 0;
892                         break;
893
894                 case RH_PORT_POWER:
895                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
896                                             RH_PS_LSDA);
897                         len = 0;
898                         break;
899
900                 case RH_C_PORT_CONNECTION:
901                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
902                                             RH_PS_CSC);
903                         len = 0;
904                         break;
905
906                 case RH_C_PORT_ENABLE:
907                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
908                                             RH_PS_PESC);
909                         len = 0;
910                         break;
911
912                 case RH_C_PORT_SUSPEND:
913                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
914                                             RH_PS_PSSC);
915                         len = 0;
916                         break;
917
918                 case RH_C_PORT_OVER_CURRENT:
919                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
920                                             RH_PS_POCI);
921                         len = 0;
922                         break;
923
924                 case RH_C_PORT_RESET:
925                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
926                                             RH_PS_PRSC);
927                         len = 0;
928                         break;
929
930                 default:
931                         ERR("invalid wValue");
932                         stat = USB_ST_STALLED;
933                 }
934
935                 isp116x_show_regs(isp116x);
936
937                 break;
938
939         case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
940                 DBG("RH_SET_FEATURE | RH_OTHER | RH_CLASS");
941
942                 switch (wValue) {
943                 case RH_PORT_SUSPEND:
944                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
945                                             RH_PS_PSS);
946                         len = 0;
947                         break;
948
949                 case RH_PORT_RESET:
950                         /* Spin until any current reset finishes */
951                         while (1) {
952                                 tmp =
953                                     isp116x_read_reg32(isp116x,
954                                                        HCRHPORT1 + wIndex - 1);
955                                 if (!(tmp & RH_PS_PRS))
956                                         break;
957                                 wait_ms(1);
958                         }
959                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
960                                             RH_PS_PRS);
961                         wait_ms(10);
962
963                         len = 0;
964                         break;
965
966                 case RH_PORT_POWER:
967                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
968                                             RH_PS_PPS);
969                         len = 0;
970                         break;
971
972                 case RH_PORT_ENABLE:
973                         isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
974                                             RH_PS_PES);
975                         len = 0;
976                         break;
977
978                 default:
979                         ERR("invalid wValue");
980                         stat = USB_ST_STALLED;
981                 }
982
983                 isp116x_show_regs(isp116x);
984
985                 break;
986
987         case RH_SET_ADDRESS:
988                 DBG("RH_SET_ADDRESS");
989
990                 rh_devnum = wValue;
991                 len = 0;
992                 break;
993
994         case RH_GET_DESCRIPTOR:
995                 DBG("RH_GET_DESCRIPTOR: %x, %d", wValue, wLength);
996
997                 switch (wValue) {
998                 case (USB_DT_DEVICE << 8):      /* device descriptor */
999                         len = min_t(unsigned int,
1000                                     leni, min_t(unsigned int,
1001                                                 sizeof(root_hub_dev_des),
1002                                                 wLength));
1003                         data_buf = root_hub_dev_des;
1004                         break;
1005
1006                 case (USB_DT_CONFIG << 8):      /* configuration descriptor */
1007                         len = min_t(unsigned int,
1008                                     leni, min_t(unsigned int,
1009                                                 sizeof(root_hub_config_des),
1010                                                 wLength));
1011                         data_buf = root_hub_config_des;
1012                         break;
1013
1014                 case ((USB_DT_STRING << 8) | 0x00):     /* string 0 descriptors */
1015                         len = min_t(unsigned int,
1016                                     leni, min_t(unsigned int,
1017                                                 sizeof(root_hub_str_index0),
1018                                                 wLength));
1019                         data_buf = root_hub_str_index0;
1020                         break;
1021
1022                 case ((USB_DT_STRING << 8) | 0x01):     /* string 1 descriptors */
1023                         len = min_t(unsigned int,
1024                                     leni, min_t(unsigned int,
1025                                                 sizeof(root_hub_str_index1),
1026                                                 wLength));
1027                         data_buf = root_hub_str_index1;
1028                         break;
1029
1030                 default:
1031                         ERR("invalid wValue");
1032                         stat = USB_ST_STALLED;
1033                 }
1034
1035                 break;
1036
1037         case RH_GET_DESCRIPTOR | RH_CLASS:
1038                 DBG("RH_GET_DESCRIPTOR | RH_CLASS");
1039
1040                 tmp = isp116x_read_reg32(isp116x, HCRHDESCA);
1041
1042                 data_buf[0] = 0x09;     /* min length; */
1043                 data_buf[1] = 0x29;
1044                 data_buf[2] = tmp & RH_A_NDP;
1045                 data_buf[3] = 0;
1046                 if (tmp & RH_A_PSM)     /* per-port power switching? */
1047                         data_buf[3] |= 0x01;
1048                 if (tmp & RH_A_NOCP)    /* no overcurrent reporting? */
1049                         data_buf[3] |= 0x10;
1050                 else if (tmp & RH_A_OCPM)       /* per-port overcurrent rep? */
1051                         data_buf[3] |= 0x08;
1052
1053                 /* Corresponds to data_buf[4-7] */
1054                 datab[1] = 0;
1055                 data_buf[5] = (tmp & RH_A_POTPGT) >> 24;
1056
1057                 tmp = isp116x_read_reg32(isp116x, HCRHDESCB);
1058
1059                 data_buf[7] = tmp & RH_B_DR;
1060                 if (data_buf[2] < 7)
1061                         data_buf[8] = 0xff;
1062                 else {
1063                         data_buf[0] += 2;
1064                         data_buf[8] = (tmp & RH_B_DR) >> 8;
1065                         data_buf[10] = data_buf[9] = 0xff;
1066                 }
1067
1068                 len = min_t(unsigned int, leni,
1069                             min_t(unsigned int, data_buf[0], wLength));
1070                 break;
1071
1072         case RH_GET_CONFIGURATION:
1073                 DBG("RH_GET_CONFIGURATION");
1074
1075                 *(__u8 *) data_buf = 0x01;
1076                 len = 1;
1077                 break;
1078
1079         case RH_SET_CONFIGURATION:
1080                 DBG("RH_SET_CONFIGURATION");
1081
1082                 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPSC);
1083                 len = 0;
1084                 break;
1085
1086         default:
1087                 ERR("*** *** *** unsupported root hub command *** *** ***");
1088                 stat = USB_ST_STALLED;
1089         }
1090
1091         len = min_t(int, len, leni);
1092         if (buffer != data_buf)
1093                 memcpy(buffer, data_buf, len);
1094
1095         dev->act_len = len;
1096         dev->status = stat;
1097         DBG("dev act_len %d, status %d", dev->act_len, dev->status);
1098
1099         dump_msg(dev, pipe, buffer, transfer_len, "RH(ret)");
1100
1101         return stat;
1102 }
1103
1104 /* --- Transfer functions -------------------------------------------------- */
1105
1106 int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1107                    int len, int interval)
1108 {
1109         DBG("dev=%p pipe=%#lx buf=%p size=%d int=%d",
1110             dev, pipe, buffer, len, interval);
1111
1112         return -1;
1113 }
1114
1115 int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1116                        int len, struct devrequest *setup)
1117 {
1118         int devnum = usb_pipedevice(pipe);
1119         int epnum = usb_pipeendpoint(pipe);
1120         int max = max_transfer_len(dev, pipe);
1121         int dir_in = usb_pipein(pipe);
1122         int done, ret;
1123
1124         /* Control message is for the HUB? */
1125         if (devnum == rh_devnum)
1126                 return isp116x_submit_rh_msg(dev, pipe, buffer, len, setup);
1127
1128         /* Ok, no HUB message so send the message to the device */
1129
1130         /* Setup phase */
1131         DBG("--- SETUP PHASE --------------------------------");
1132         usb_settoggle(dev, epnum, 1, 0);
1133         ret = isp116x_submit_job(dev, pipe,
1134                                  PTD_DIR_SETUP,
1135                                  setup, sizeof(struct devrequest));
1136         if (ret < 0) {
1137                 DBG("control setup phase error (ret = %d", ret);
1138                 return -1;
1139         }
1140
1141         /* Data phase */
1142         DBG("--- DATA PHASE ---------------------------------");
1143         done = 0;
1144         usb_settoggle(dev, epnum, !dir_in, 1);
1145         while (done < len) {
1146                 ret = isp116x_submit_job(dev, pipe,
1147                                          dir_in ? PTD_DIR_IN : PTD_DIR_OUT,
1148                                          (__u8 *) buffer + done,
1149                                          max > len - done ? len - done : max);
1150                 if (ret < 0) {
1151                         DBG("control data phase error (ret = %d)", ret);
1152                         return -1;
1153                 }
1154                 done += ret;
1155
1156                 if (dir_in && ret < max)        /* short packet */
1157                         break;
1158         }
1159
1160         /* Status phase */
1161         DBG("--- STATUS PHASE -------------------------------");
1162         usb_settoggle(dev, epnum, !dir_in, 1);
1163         ret = isp116x_submit_job(dev, pipe,
1164                                  !dir_in ? PTD_DIR_IN : PTD_DIR_OUT, NULL, 0);
1165         if (ret < 0) {
1166                 DBG("control status phase error (ret = %d", ret);
1167                 return -1;
1168         }
1169
1170         dev->act_len = done;
1171
1172         dump_msg(dev, pipe, buffer, len, "DEV(ret)");
1173
1174         return done;
1175 }
1176
1177 int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
1178                     int len)
1179 {
1180         int dir_out = usb_pipeout(pipe);
1181         int max = max_transfer_len(dev, pipe);
1182         int done, ret;
1183
1184         DBG("--- BULK ---------------------------------------");
1185         DBG("dev=%ld pipe=%ld buf=%p size=%d dir_out=%d",
1186             usb_pipedevice(pipe), usb_pipeendpoint(pipe), buffer, len, dir_out);
1187
1188         done = 0;
1189         while (done < len) {
1190                 ret = isp116x_submit_job(dev, pipe,
1191                                          !dir_out ? PTD_DIR_IN : PTD_DIR_OUT,
1192                                          (__u8 *) buffer + done,
1193                                          max > len - done ? len - done : max);
1194                 if (ret < 0) {
1195                         DBG("error on bulk message (ret = %d)", ret);
1196                         return -1;
1197                 }
1198
1199                 done += ret;
1200
1201                 if (!dir_out && ret < max)      /* short packet */
1202                         break;
1203         }
1204
1205         dev->act_len = done;
1206
1207         return 0;
1208 }
1209
1210 /* --- Basic functions ----------------------------------------------------- */
1211
1212 static int isp116x_sw_reset(struct isp116x *isp116x)
1213 {
1214         int retries = 15;
1215         int ret = 0;
1216
1217         DBG("");
1218
1219         isp116x->disabled = 1;
1220
1221         isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1222         isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1223         while (--retries) {
1224                 /* It usually resets within 1 ms */
1225                 wait_ms(1);
1226                 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1227                         break;
1228         }
1229         if (!retries) {
1230                 ERR("software reset timeout");
1231                 ret = -1;
1232         }
1233         return ret;
1234 }
1235
1236 static int isp116x_reset(struct isp116x *isp116x)
1237 {
1238         unsigned long t;
1239         u16 clkrdy = 0;
1240         int ret, timeout = 15 /* ms */ ;
1241
1242         DBG("");
1243
1244         ret = isp116x_sw_reset(isp116x);
1245         if (ret)
1246                 return ret;
1247
1248         for (t = 0; t < timeout; t++) {
1249                 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1250                 if (clkrdy)
1251                         break;
1252                 wait_ms(1);
1253         }
1254         if (!clkrdy) {
1255                 ERR("clock not ready after %dms", timeout);
1256                 /* After sw_reset the clock won't report to be ready, if
1257                    H_WAKEUP pin is high. */
1258                 ERR("please make sure that the H_WAKEUP pin is pulled low!");
1259                 ret = -1;
1260         }
1261         return ret;
1262 }
1263
1264 static void isp116x_stop(struct isp116x *isp116x)
1265 {
1266         u32 val;
1267
1268         DBG("");
1269
1270         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1271
1272         /* Switch off ports' power, some devices don't come up
1273            after next 'start' without this */
1274         val = isp116x_read_reg32(isp116x, HCRHDESCA);
1275         val &= ~(RH_A_NPS | RH_A_PSM);
1276         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1277         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1278
1279         isp116x_sw_reset(isp116x);
1280 }
1281
1282 /*
1283  *  Configure the chip. The chip must be successfully reset by now.
1284  */
1285 static int isp116x_start(struct isp116x *isp116x)
1286 {
1287         struct isp116x_platform_data *board = isp116x->board;
1288         u32 val;
1289
1290         DBG("");
1291
1292         /* Clear interrupt status and disable all interrupt sources */
1293         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1294         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1295
1296         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1297         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1298
1299         /* Hardware configuration */
1300         val = HCHWCFG_DBWIDTH(1);
1301         if (board->sel15Kres)
1302                 val |= HCHWCFG_15KRSEL;
1303         /* Remote wakeup won't work without working clock */
1304         if (board->remote_wakeup_enable)
1305                 val |= HCHWCFG_CLKNOTSTOP;
1306         if (board->oc_enable)
1307                 val |= HCHWCFG_ANALOG_OC;
1308         isp116x_write_reg16(isp116x, HCHWCFG, val);
1309
1310         /* --- Root hub configuration */
1311         val = (25 << 24) & RH_A_POTPGT;
1312         /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1313            be always set. Yet, instead, we request individual port
1314            power switching. */
1315         val |= RH_A_PSM;
1316         /* Report overcurrent per port */
1317         val |= RH_A_OCPM;
1318         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1319         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1320
1321         val = RH_B_PPCM;
1322         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1323         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1324
1325         val = 0;
1326         if (board->remote_wakeup_enable)
1327                 val |= RH_HS_DRWE;
1328         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1329         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1330
1331         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1332
1333         /* Go operational */
1334         val = HCCONTROL_USB_OPER;
1335         if (board->remote_wakeup_enable)
1336                 val |= HCCONTROL_RWE;
1337         isp116x_write_reg32(isp116x, HCCONTROL, val);
1338
1339         /* Disable ports to avoid race in device enumeration */
1340         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1341         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1342
1343         isp116x_show_regs(isp116x);
1344
1345         isp116x->disabled = 0;
1346
1347         return 0;
1348 }
1349
1350 /* --- Init functions ------------------------------------------------------ */
1351
1352 int isp116x_check_id(struct isp116x *isp116x)
1353 {
1354         int val;
1355
1356         val = isp116x_read_reg16(isp116x, HCCHIPID);
1357         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1358                 ERR("invalid chip ID %04x", val);
1359                 return -1;
1360         }
1361
1362         return 0;
1363 }
1364
1365 int usb_lowlevel_init(void)
1366 {
1367         struct isp116x *isp116x = &isp116x_dev;
1368
1369         DBG("");
1370
1371         /* Init device registers addr */
1372         isp116x->addr_reg = (u16 *) ISP116X_HCD_ADDR;
1373         isp116x->data_reg = (u16 *) ISP116X_HCD_DATA;
1374
1375         /* Setup specific board settings */
1376 #ifdef ISP116X_HCD_SEL15kRES
1377         isp116x_board.sel15Kres = 1;
1378 #endif
1379 #ifdef ISP116X_HCD_OC_ENABLE
1380         isp116x_board.oc_enable = 1;
1381 #endif
1382 #ifdef ISP116X_HCD_REMOTE_WAKEUP_ENABLE
1383         isp116x_board.remote_wakeup_enable = 1;
1384 #endif
1385         isp116x->board = &isp116x_board;
1386
1387         /* Try to get ISP116x silicon chip ID */
1388         if (isp116x_check_id(isp116x) < 0)
1389                 return -1;
1390
1391         isp116x->disabled = 1;
1392         isp116x->sleeping = 0;
1393
1394         isp116x_reset(isp116x);
1395         isp116x_start(isp116x);
1396
1397         return 0;
1398 }
1399
1400 int usb_lowlevel_stop(void)
1401 {
1402         struct isp116x *isp116x = &isp116x_dev;
1403
1404         DBG("");
1405
1406         if (!isp116x->disabled)
1407                 isp116x_stop(isp116x);
1408
1409         return 0;
1410 }
1411
1412 #endif                          /* CONFIG_USB_ISP116X_HCD */