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