drivers/usb/host/isp116x-hcd.c

   1 /*
   2  * ISP116x HCD (Host Controller Driver) for USB.
   3  *
   4  * Derived from the SL811 HCD, rewritten for ISP116x.
   5  * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
   6  *
   7  * Portions:
   8  * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
   9  * Copyright (C) 2004 David Brownell
  10  *
  11  * Periodic scheduling is based on Roman's OHCI code
  12  * Copyright (C) 1999 Roman Weissgaerber
  13  *
  14  */
  15
  16 /*
  17  * The driver basically works. A number of people have used it with a range
  18  * of devices.
  19  *
  20  * The driver passes all usbtests 1-14.
  21  *
  22  * Suspending/resuming of root hub via sysfs works. Remote wakeup works too.
  23  * And suspending/resuming of platform device works too. Suspend/resume
  24  * via HCD operations vector is not implemented.
  25  *
  26  * Iso transfer support is not implemented. Adding this would include
  27  * implementing recovery from the failure to service the processed ITL
  28  * fifo ram in time, which will involve chip reset.
  29  *
  30  * TODO:
  31  + More testing of suspend/resume.
  32 */
  33
  34 /*
  35   ISP116x chips require certain delays between accesses to its
  36   registers. The following timing options exist.
  37
  38   1. Configure your memory controller (the best)
  39   2. Implement platform-specific delay function possibly
  40   combined with configuring the memory controller; see
  41   include/linux/usb-isp116x.h for more info. Some broken
  42   memory controllers line LH7A400 SMC need this. Also,
  43   uncomment for that to work the following
  44   USE_PLATFORM_DELAY macro.
  45   3. Use ndelay (easiest, poorest). For that, uncomment
  46   the following USE_NDELAY macro.
  47 */
  48 #define USE_PLATFORM_DELAY
  49 //#define USE_NDELAY
  50
  51 //#define DEBUG
  52 //#define VERBOSE
  53 /* Transfer descriptors. See dump_ptd() for printout format  */
  54 //#define PTD_TRACE
  55 /* enqueuing/finishing log of urbs */
  56 //#define URB_TRACE
  57
  58 #include <linux/module.h>
  59 #include <linux/delay.h>
  60 #include <linux/debugfs.h>
  61 #include <linux/seq_file.h>
  62 #include <linux/errno.h>
  63 #include <linux/init.h>
  64 #include <linux/list.h>
  65 #include <linux/slab.h>
  66 #include <linux/usb.h>
  67 #include <linux/usb/isp116x.h>
  68 #include <linux/usb/hcd.h>
  69 #include <linux/platform_device.h>
  70
  71 #include <asm/io.h>
  72 #include <asm/irq.h>
  73 #include <asm/system.h>
  74 #include <asm/byteorder.h>
  75
  76 #include "isp116x.h"
  77
  78 #define DRIVER_VERSION  "03 Nov 2005"
  79 #define DRIVER_DESC     "ISP116x USB Host Controller Driver"
  80
  81 MODULE_DESCRIPTION(DRIVER_DESC);
  82 MODULE_LICENSE("GPL");
  83
  84 static const char hcd_name[] = "isp116x-hcd";
  85
  86 /*-----------------------------------------------------------------*/
  87
  88 /*
  89   Write len bytes to fifo, pad till 32-bit boundary
  90  */
  91 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
  92 {
  93         u8 *dp = (u8 *) buf;
  94         u16 *dp2 = (u16 *) buf;
  95         u16 w;
  96         int quot = len % 4;
  97
  98         /* buffer is already in 'usb data order', which is LE. */
  99         /* When reading buffer as u16, we have to take care byte order */
 100         /* doesn't get mixed up */
 101
 102         if ((unsigned long)dp2 & 1) {
 103                 /* not aligned */
 104                 for (; len > 1; len -= 2) {
 105                         w = *dp++;
 106                         w |= *dp++ << 8;
 107                         isp116x_raw_write_data16(isp116x, w);
 108                 }
 109                 if (len)
 110                         isp116x_write_data16(isp116x, (u16) * dp);
 111         } else {
 112                 /* aligned */
 113                 for (; len > 1; len -= 2) {
 114                         /* Keep byte order ! */
 115                         isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
 116                 }
 117
 118                 if (len)
 119                         isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
 120         }
 121         if (quot == 1 || quot == 2)
 122                 isp116x_raw_write_data16(isp116x, 0);
 123 }
 124
 125 /*
 126   Read len bytes from fifo and then read till 32-bit boundary.
 127  */
 128 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
 129 {
 130         u8 *dp = (u8 *) buf;
 131         u16 *dp2 = (u16 *) buf;
 132         u16 w;
 133         int quot = len % 4;
 134
 135         /* buffer is already in 'usb data order', which is LE. */
 136         /* When reading buffer as u16, we have to take care byte order */
 137         /* doesn't get mixed up */
 138
 139         if ((unsigned long)dp2 & 1) {
 140                 /* not aligned */
 141                 for (; len > 1; len -= 2) {
 142                         w = isp116x_raw_read_data16(isp116x);
 143                         *dp++ = w & 0xff;
 144                         *dp++ = (w >> 8) & 0xff;
 145                 }
 146
 147                 if (len)
 148                         *dp = 0xff & isp116x_read_data16(isp116x);
 149         } else {
 150                 /* aligned */
 151                 for (; len > 1; len -= 2) {
 152                         /* Keep byte order! */
 153                         *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
 154                 }
 155
 156                 if (len)
 157                         *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
 158         }
 159         if (quot == 1 || quot == 2)
 160                 isp116x_raw_read_data16(isp116x);
 161 }
 162
 163 /*
 164   Write ptd's and data for scheduled transfers into
 165   the fifo ram. Fifo must be empty and ready.
 166 */
 167 static void pack_fifo(struct isp116x *isp116x)
 168 {
 169         struct isp116x_ep *ep;
 170         struct ptd *ptd;
 171         int buflen = isp116x->atl_last_dir == PTD_DIR_IN
 172             ? isp116x->atl_bufshrt : isp116x->atl_buflen;
 173
 174         isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
 175         isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
 176         isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
 177         for (ep = isp116x->atl_active; ep; ep = ep->active) {
 178                 ptd = &ep->ptd;
 179                 dump_ptd(ptd);
 180                 dump_ptd_out_data(ptd, ep->data);
 181                 isp116x_write_data16(isp116x, ptd->count);
 182                 isp116x_write_data16(isp116x, ptd->mps);
 183                 isp116x_write_data16(isp116x, ptd->len);
 184                 isp116x_write_data16(isp116x, ptd->faddr);
 185                 buflen -= sizeof(struct ptd);
 186                 /* Skip writing data for last IN PTD */
 187                 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) {
 188                         write_ptddata_to_fifo(isp116x, ep->data, ep->length);
 189                         buflen -= ALIGN(ep->length, 4);
 190                 }
 191         }
 192         BUG_ON(buflen);
 193 }
 194
 195 /*
 196   Read the processed ptd's and data from fifo ram back to
 197   URBs' buffers. Fifo must be full and done
 198 */
 199 static void unpack_fifo(struct isp116x *isp116x)
 200 {
 201         struct isp116x_ep *ep;
 202         struct ptd *ptd;
 203         int buflen = isp116x->atl_last_dir == PTD_DIR_IN
 204             ? isp116x->atl_buflen : isp116x->atl_bufshrt;
 205
 206         isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
 207         isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
 208         isp116x_write_addr(isp116x, HCATLPORT);
 209         for (ep = isp116x->atl_active; ep; ep = ep->active) {
 210                 ptd = &ep->ptd;
 211                 ptd->count = isp116x_read_data16(isp116x);
 212                 ptd->mps = isp116x_read_data16(isp116x);
 213                 ptd->len = isp116x_read_data16(isp116x);
 214                 ptd->faddr = isp116x_read_data16(isp116x);
 215                 buflen -= sizeof(struct ptd);
 216                 /* Skip reading data for last Setup or Out PTD */
 217                 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) {
 218                         read_ptddata_from_fifo(isp116x, ep->data, ep->length);
 219                         buflen -= ALIGN(ep->length, 4);
 220                 }
 221                 dump_ptd(ptd);
 222                 dump_ptd_in_data(ptd, ep->data);
 223         }
 224         BUG_ON(buflen);
 225 }
 226
 227 /*---------------------------------------------------------------*/
 228
 229 /*
 230   Set up PTD's.
 231 */
 232 static void preproc_atl_queue(struct isp116x *isp116x)
 233 {
 234         struct isp116x_ep *ep;
 235         struct urb *urb;
 236         struct ptd *ptd;
 237         u16 len;
 238
 239         for (ep = isp116x->atl_active; ep; ep = ep->active) {
 240                 u16 toggle = 0, dir = PTD_DIR_SETUP;
 241
 242                 BUG_ON(list_empty(&ep->hep->urb_list));
 243                 urb = container_of(ep->hep->urb_list.next,
 244                                    struct urb, urb_list);
 245                 ptd = &ep->ptd;
 246                 len = ep->length;
 247                 ep->data = (unsigned char *)urb->transfer_buffer
 248                     + urb->actual_length;
 249
 250                 switch (ep->nextpid) {
 251                 case USB_PID_IN:
 252                         toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
 253                         dir = PTD_DIR_IN;
 254                         break;
 255                 case USB_PID_OUT:
 256                         toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
 257                         dir = PTD_DIR_OUT;
 258                         break;
 259                 case USB_PID_SETUP:
 260                         len = sizeof(struct usb_ctrlrequest);
 261                         ep->data = urb->setup_packet;
 262                         break;
 263                 case USB_PID_ACK:
 264                         toggle = 1;
 265                         len = 0;
 266                         dir = (urb->transfer_buffer_length
 267                                && usb_pipein(urb->pipe))
 268                             ? PTD_DIR_OUT : PTD_DIR_IN;
 269                         break;
 270                 default:
 271                         ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__,
 272                             ep->nextpid);
 273                         BUG();
 274                 }
 275
 276                 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
 277                 ptd->mps = PTD_MPS(ep->maxpacket)
 278                     | PTD_SPD(urb->dev->speed == USB_SPEED_LOW)
 279                     | PTD_EP(ep->epnum);
 280                 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
 281                 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
 282                 if (!ep->active) {
 283                         ptd->mps |= PTD_LAST_MSK;
 284                         isp116x->atl_last_dir = dir;
 285                 }
 286                 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen;
 287                 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4);
 288         }
 289 }
 290
 291 /*
 292   Take done or failed requests out of schedule. Give back
 293   processed urbs.
 294 */
 295 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
 296                            struct urb *urb, int status)
 297 __releases(isp116x->lock) __acquires(isp116x->lock)
 298 {
 299         unsigned i;
 300
 301         ep->error_count = 0;
 302
 303         if (usb_pipecontrol(urb->pipe))
 304                 ep->nextpid = USB_PID_SETUP;
 305
 306         urb_dbg(urb, "Finish");
 307
 308         usb_hcd_unlink_urb_from_ep(isp116x_to_hcd(isp116x), urb);
 309         spin_unlock(&isp116x->lock);
 310         usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, status);
 311         spin_lock(&isp116x->lock);
 312
 313         /* take idle endpoints out of the schedule */
 314         if (!list_empty(&ep->hep->urb_list))
 315                 return;
 316
 317         /* async deschedule */
 318         if (!list_empty(&ep->schedule)) {
 319                 list_del_init(&ep->schedule);
 320                 return;
 321         }
 322
 323         /* periodic deschedule */
 324         DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
 325         for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
 326                 struct isp116x_ep *temp;
 327                 struct isp116x_ep **prev = &isp116x->periodic[i];
 328
 329                 while (*prev && ((temp = *prev) != ep))
 330                         prev = &temp->next;
 331                 if (*prev)
 332                         *prev = ep->next;
 333                 isp116x->load[i] -= ep->load;
 334         }
 335         ep->branch = PERIODIC_SIZE;
 336         isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
 337             ep->load / ep->period;
 338
 339         /* switch irq type? */
 340         if (!--isp116x->periodic_count) {
 341                 isp116x->irqenb &= ~HCuPINT_SOF;
 342                 isp116x->irqenb |= HCuPINT_ATL;
 343         }
 344 }
 345
 346 /*
 347   Analyze transfer results, handle partial transfers and errors
 348 */
 349 static void postproc_atl_queue(struct isp116x *isp116x)
 350 {
 351         struct isp116x_ep *ep;
 352         struct urb *urb;
 353         struct usb_device *udev;
 354         struct ptd *ptd;
 355         int short_not_ok;
 356         int status;
 357         u8 cc;
 358
 359         for (ep = isp116x->atl_active; ep; ep = ep->active) {
 360                 BUG_ON(list_empty(&ep->hep->urb_list));
 361                 urb =
 362                     container_of(ep->hep->urb_list.next, struct urb, urb_list);
 363                 udev = urb->dev;
 364                 ptd = &ep->ptd;
 365                 cc = PTD_GET_CC(ptd);
 366                 short_not_ok = 1;
 367                 status = -EINPROGRESS;
 368
 369                 /* Data underrun is special. For allowed underrun
 370                    we clear the error and continue as normal. For
 371                    forbidden underrun we finish the DATA stage
 372                    immediately while for control transfer,
 373                    we do a STATUS stage. */
 374                 if (cc == TD_DATAUNDERRUN) {
 375                         if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
 376                                         usb_pipecontrol(urb->pipe)) {
 377                                 DBG("Allowed or control data underrun\n");
 378                                 cc = TD_CC_NOERROR;
 379                                 short_not_ok = 0;
 380                         } else {
 381                                 ep->error_count = 1;
 382                                 usb_settoggle(udev, ep->epnum,
 383                                               ep->nextpid == USB_PID_OUT,
 384                                               PTD_GET_TOGGLE(ptd));
 385                                 urb->actual_length += PTD_GET_COUNT(ptd);
 386                                 status = cc_to_error[TD_DATAUNDERRUN];
 387                                 goto done;
 388                         }
 389                 }
 390
 391                 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
 392                     && (++ep->error_count >= 3 || cc == TD_CC_STALL
 393                         || cc == TD_DATAOVERRUN)) {
 394                         status = cc_to_error[cc];
 395                         if (ep->nextpid == USB_PID_ACK)
 396                                 ep->nextpid = 0;
 397                         goto done;
 398                 }
 399                 /* According to usb spec, zero-length Int transfer signals
 400                    finishing of the urb. Hey, does this apply only
 401                    for IN endpoints? */
 402                 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
 403                         status = 0;
 404                         goto done;
 405                 }
 406
 407                 /* Relax after previously failed, but later succeeded
 408                    or correctly NAK'ed retransmission attempt */
 409                 if (ep->error_count
 410                     && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED))
 411                         ep->error_count = 0;
 412
 413                 /* Take into account idiosyncracies of the isp116x chip
 414                    regarding toggle bit for failed transfers */
 415                 if (ep->nextpid == USB_PID_OUT)
 416                         usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd)
 417                                       ^ (ep->error_count > 0));
 418                 else if (ep->nextpid == USB_PID_IN)
 419                         usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd)
 420                                       ^ (ep->error_count > 0));
 421
 422                 switch (ep->nextpid) {
 423                 case USB_PID_IN:
 424                 case USB_PID_OUT:
 425                         urb->actual_length += PTD_GET_COUNT(ptd);
 426                         if (PTD_GET_ACTIVE(ptd)
 427                             || (cc != TD_CC_NOERROR && cc < 0x0E))
 428                                 break;
 429                         if (urb->transfer_buffer_length != urb->actual_length) {
 430                                 if (short_not_ok)
 431                                         break;
 432                         } else {
 433                                 if (urb->transfer_flags & URB_ZERO_PACKET
 434                                     && ep->nextpid == USB_PID_OUT
 435                                     && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) {
 436                                         DBG("Zero packet requested\n");
 437                                         break;
 438                                 }
 439                         }
 440                         /* All data for this URB is transferred, let's finish */
 441                         if (usb_pipecontrol(urb->pipe))
 442                                 ep->nextpid = USB_PID_ACK;
 443                         else
 444                                 status = 0;
 445                         break;
 446                 case USB_PID_SETUP:
 447                         if (PTD_GET_ACTIVE(ptd)
 448                             || (cc != TD_CC_NOERROR && cc < 0x0E))
 449                                 break;
 450                         if (urb->transfer_buffer_length == urb->actual_length)
 451                                 ep->nextpid = USB_PID_ACK;
 452                         else if (usb_pipeout(urb->pipe)) {
 453                                 usb_settoggle(udev, 0, 1, 1);
 454                                 ep->nextpid = USB_PID_OUT;
 455                         } else {
 456                                 usb_settoggle(udev, 0, 0, 1);
 457                                 ep->nextpid = USB_PID_IN;
 458                         }
 459                         break;
 460                 case USB_PID_ACK:
 461                         if (PTD_GET_ACTIVE(ptd)
 462                             || (cc != TD_CC_NOERROR && cc < 0x0E))
 463                                 break;
 464                         status = 0;
 465                         ep->nextpid = 0;
 466                         break;
 467                 default:
 468                         BUG();
 469                 }
 470
 471  done:
 472                 if (status != -EINPROGRESS || urb->unlinked)
 473                         finish_request(isp116x, ep, urb, status);
 474         }
 475 }
 476
 477 /*
 478   Scan transfer lists, schedule transfers, send data off
 479   to chip.
 480  */
 481 static void start_atl_transfers(struct isp116x *isp116x)
 482 {
 483         struct isp116x_ep *last_ep = NULL, *ep;
 484         struct urb *urb;
 485         u16 load = 0;
 486         int len, index, speed, byte_time;
 487
 488         if (atomic_read(&isp116x->atl_finishing))
 489                 return;
 490
 491         if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state))
 492                 return;
 493
 494         /* FIFO not empty? */
 495         if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL)
 496                 return;
 497
 498         isp116x->atl_active = NULL;
 499         isp116x->atl_buflen = isp116x->atl_bufshrt = 0;
 500
 501         /* Schedule int transfers */
 502         if (isp116x->periodic_count) {
 503                 isp116x->fmindex = index =
 504                     (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1);
 505                 if ((load = isp116x->load[index])) {
 506                         /* Bring all int transfers for this frame
 507                            into the active queue */
 508                         isp116x->atl_active = last_ep =
 509                             isp116x->periodic[index];
 510                         while (last_ep->next)
 511                                 last_ep = (last_ep->active = last_ep->next);
 512                         last_ep->active = NULL;
 513                 }
 514         }
 515
 516         /* Schedule control/bulk transfers */
 517         list_for_each_entry(ep, &isp116x->async, schedule) {
 518                 urb = container_of(ep->hep->urb_list.next,
 519                                    struct urb, urb_list);
 520                 speed = urb->dev->speed;
 521                 byte_time = speed == USB_SPEED_LOW
 522                     ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
 523
 524                 if (ep->nextpid == USB_PID_SETUP) {
 525                         len = sizeof(struct usb_ctrlrequest);
 526                 } else if (ep->nextpid == USB_PID_ACK) {
 527                         len = 0;
 528                 } else {
 529                         /* Find current free length ... */
 530                         len = (MAX_LOAD_LIMIT - load) / byte_time;
 531
 532                         /* ... then limit it to configured max size ... */
 533                         len = min(len, speed == USB_SPEED_LOW ?
 534                                   MAX_TRANSFER_SIZE_LOWSPEED :
 535                                   MAX_TRANSFER_SIZE_FULLSPEED);
 536
 537                         /* ... and finally cut to the multiple of MaxPacketSize,
 538                            or to the real length if there's enough room. */
 539                         if (len <
 540                             (urb->transfer_buffer_length -
 541                              urb->actual_length)) {
 542                                 len -= len % ep->maxpacket;
 543                                 if (!len)
 544                                         continue;
 545                         } else
 546                                 len = urb->transfer_buffer_length -
 547                                     urb->actual_length;
 548                         BUG_ON(len < 0);
 549                 }
 550
 551                 load += len * byte_time;
 552                 if (load > MAX_LOAD_LIMIT)
 553                         break;
 554
 555                 ep->active = NULL;
 556                 ep->length = len;
 557                 if (last_ep)
 558                         last_ep->active = ep;
 559                 else
 560                         isp116x->atl_active = ep;
 561                 last_ep = ep;
 562         }
 563
 564         /* Avoid starving of endpoints */
 565         if ((&isp116x->async)->next != (&isp116x->async)->prev)
 566                 list_move(&isp116x->async, (&isp116x->async)->next);
 567
 568         if (isp116x->atl_active) {
 569                 preproc_atl_queue(isp116x);
 570                 pack_fifo(isp116x);
 571         }
 572 }
 573
 574 /*
 575   Finish the processed transfers
 576 */
 577 static void finish_atl_transfers(struct isp116x *isp116x)
 578 {
 579         if (!isp116x->atl_active)
 580                 return;
 581         /* Fifo not ready? */
 582         if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
 583                 return;
 584
 585         atomic_inc(&isp116x->atl_finishing);
 586         unpack_fifo(isp116x);
 587         postproc_atl_queue(isp116x);
 588         atomic_dec(&isp116x->atl_finishing);
 589 }
 590
 591 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
 592 {
 593         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 594         u16 irqstat;
 595         irqreturn_t ret = IRQ_NONE;
 596
 597         spin_lock(&isp116x->lock);
 598         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
 599         irqstat = isp116x_read_reg16(isp116x, HCuPINT);
 600         isp116x_write_reg16(isp116x, HCuPINT, irqstat);
 601
 602         if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
 603                 ret = IRQ_HANDLED;
 604                 finish_atl_transfers(isp116x);
 605         }
 606
 607         if (irqstat & HCuPINT_OPR) {
 608                 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
 609                 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
 610                 if (intstat & HCINT_UE) {
 611                         ERR("Unrecoverable error, HC is dead!\n");
 612                         /* IRQ's are off, we do no DMA,
 613                            perfectly ready to die ... */
 614                         hcd->state = HC_STATE_HALT;
 615                         usb_hc_died(hcd);
 616                         ret = IRQ_HANDLED;
 617                         goto done;
 618                 }
 619                 if (intstat & HCINT_RHSC)
 620                         /* When root hub or any of its ports is going
 621                            to come out of suspend, it may take more
 622                            than 10ms for status bits to stabilize. */
 623                         mod_timer(&hcd->rh_timer, jiffies
 624                                   + msecs_to_jiffies(20) + 1);
 625                 if (intstat & HCINT_RD) {
 626                         DBG("---- remote wakeup\n");
 627                         usb_hcd_resume_root_hub(hcd);
 628                 }
 629                 irqstat &= ~HCuPINT_OPR;
 630                 ret = IRQ_HANDLED;
 631         }
 632
 633         if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
 634                 start_atl_transfers(isp116x);
 635         }
 636
 637         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
 638       done:
 639         spin_unlock(&isp116x->lock);
 640         return ret;
 641 }
 642
 643 /*-----------------------------------------------------------------*/
 644
 645 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
 646  * this driver doesn't promise that much since it's got to handle an
 647  * IRQ per packet; irq handling latencies also use up that time.
 648  */
 649
 650 /* out of 1000 us */
 651 #define MAX_PERIODIC_LOAD       600
 652 static int balance(struct isp116x *isp116x, u16 period, u16 load)
 653 {
 654         int i, branch = -ENOSPC;
 655
 656         /* search for the least loaded schedule branch of that period
 657            which has enough bandwidth left unreserved. */
 658         for (i = 0; i < period; i++) {
 659                 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
 660                         int j;
 661
 662                         for (j = i; j < PERIODIC_SIZE; j += period) {
 663                                 if ((isp116x->load[j] + load)
 664                                     > MAX_PERIODIC_LOAD)
 665                                         break;
 666                         }
 667                         if (j < PERIODIC_SIZE)
 668                                 continue;
 669                         branch = i;
 670                 }
 671         }
 672         return branch;
 673 }
 674
 675 /* NB! ALL the code above this point runs with isp116x->lock
 676    held, irqs off
 677 */
 678
 679 /*-----------------------------------------------------------------*/
 680
 681 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
 682                                struct urb *urb,
 683                                gfp_t mem_flags)
 684 {
 685         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 686         struct usb_device *udev = urb->dev;
 687         unsigned int pipe = urb->pipe;
 688         int is_out = !usb_pipein(pipe);
 689         int type = usb_pipetype(pipe);
 690         int epnum = usb_pipeendpoint(pipe);
 691         struct usb_host_endpoint *hep = urb->ep;
 692         struct isp116x_ep *ep = NULL;
 693         unsigned long flags;
 694         int i;
 695         int ret = 0;
 696
 697         urb_dbg(urb, "Enqueue");
 698
 699         if (type == PIPE_ISOCHRONOUS) {
 700                 ERR("Isochronous transfers not supported\n");
 701                 urb_dbg(urb, "Refused to enqueue");
 702                 return -ENXIO;
 703         }
 704         /* avoid all allocations within spinlocks: request or endpoint */
 705         if (!hep->hcpriv) {
 706                 ep = kzalloc(sizeof *ep, mem_flags);
 707                 if (!ep)
 708                         return -ENOMEM;
 709         }
 710
 711         spin_lock_irqsave(&isp116x->lock, flags);
 712         if (!HC_IS_RUNNING(hcd->state)) {
 713                 kfree(ep);
 714                 ret = -ENODEV;
 715                 goto fail_not_linked;
 716         }
 717         ret = usb_hcd_link_urb_to_ep(hcd, urb);
 718         if (ret) {
 719                 kfree(ep);
 720                 goto fail_not_linked;
 721         }
 722
 723         if (hep->hcpriv)
 724                 ep = hep->hcpriv;
 725         else {
 726                 INIT_LIST_HEAD(&ep->schedule);
 727                 ep->udev = udev;
 728                 ep->epnum = epnum;
 729                 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
 730                 usb_settoggle(udev, epnum, is_out, 0);
 731
 732                 if (type == PIPE_CONTROL) {
 733                         ep->nextpid = USB_PID_SETUP;
 734                 } else if (is_out) {
 735                         ep->nextpid = USB_PID_OUT;
 736                 } else {
 737                         ep->nextpid = USB_PID_IN;
 738                 }
 739
 740                 if (urb->interval) {
 741                         /*
 742                            With INT URBs submitted, the driver works with SOF
 743                            interrupt enabled and ATL interrupt disabled. After
 744                            the PTDs are written to fifo ram, the chip starts
 745                            fifo processing and usb transfers after the next
 746                            SOF and continues until the transfers are finished
 747                            (succeeded or failed) or the frame ends. Therefore,
 748                            the transfers occur only in every second frame,
 749                            while fifo reading/writing and data processing
 750                            occur in every other second frame. */
 751                         if (urb->interval < 2)
 752                                 urb->interval = 2;
 753                         if (urb->interval > 2 * PERIODIC_SIZE)
 754                                 urb->interval = 2 * PERIODIC_SIZE;
 755                         ep->period = urb->interval >> 1;
 756                         ep->branch = PERIODIC_SIZE;
 757                         ep->load = usb_calc_bus_time(udev->speed,
 758                                                      !is_out,
 759                                                      (type == PIPE_ISOCHRONOUS),
 760                                                      usb_maxpacket(udev, pipe,
 761                                                                    is_out)) /
 762                             1000;
 763                 }
 764                 hep->hcpriv = ep;
 765                 ep->hep = hep;
 766         }
 767
 768         /* maybe put endpoint into schedule */
 769         switch (type) {
 770         case PIPE_CONTROL:
 771         case PIPE_BULK:
 772                 if (list_empty(&ep->schedule))
 773                         list_add_tail(&ep->schedule, &isp116x->async);
 774                 break;
 775         case PIPE_INTERRUPT:
 776                 urb->interval = ep->period;
 777                 ep->length = min_t(u32, ep->maxpacket,
 778                                  urb->transfer_buffer_length);
 779
 780                 /* urb submitted for already existing endpoint */
 781                 if (ep->branch < PERIODIC_SIZE)
 782                         break;
 783
 784                 ep->branch = ret = balance(isp116x, ep->period, ep->load);
 785                 if (ret < 0)
 786                         goto fail;
 787                 ret = 0;
 788
 789                 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
 790                     + ep->branch;
 791
 792                 /* sort each schedule branch by period (slow before fast)
 793                    to share the faster parts of the tree without needing
 794                    dummy/placeholder nodes */
 795                 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
 796                 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
 797                         struct isp116x_ep **prev = &isp116x->periodic[i];
 798                         struct isp116x_ep *here = *prev;
 799
 800                         while (here && ep != here) {
 801                                 if (ep->period > here->period)
 802                                         break;
 803                                 prev = &here->next;
 804                                 here = *prev;
 805                         }
 806                         if (ep != here) {
 807                                 ep->next = here;
 808                                 *prev = ep;
 809                         }
 810                         isp116x->load[i] += ep->load;
 811                 }
 812                 hcd->self.bandwidth_allocated += ep->load / ep->period;
 813
 814                 /* switch over to SOFint */
 815                 if (!isp116x->periodic_count++) {
 816                         isp116x->irqenb &= ~HCuPINT_ATL;
 817                         isp116x->irqenb |= HCuPINT_SOF;
 818                         isp116x_write_reg16(isp116x, HCuPINTENB,
 819                                             isp116x->irqenb);
 820                 }
 821         }
 822
 823         urb->hcpriv = hep;
 824         start_atl_transfers(isp116x);
 825
 826       fail:
 827         if (ret)
 828                 usb_hcd_unlink_urb_from_ep(hcd, urb);
 829       fail_not_linked:
 830         spin_unlock_irqrestore(&isp116x->lock, flags);
 831         return ret;
 832 }
 833
 834 /*
 835    Dequeue URBs.
 836 */
 837 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
 838                 int status)
 839 {
 840         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 841         struct usb_host_endpoint *hep;
 842         struct isp116x_ep *ep, *ep_act;
 843         unsigned long flags;
 844         int rc;
 845
 846         spin_lock_irqsave(&isp116x->lock, flags);
 847         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
 848         if (rc)
 849                 goto done;
 850
 851         hep = urb->hcpriv;
 852         ep = hep->hcpriv;
 853         WARN_ON(hep != ep->hep);
 854
 855         /* In front of queue? */
 856         if (ep->hep->urb_list.next == &urb->urb_list)
 857                 /* active? */
 858                 for (ep_act = isp116x->atl_active; ep_act;
 859                      ep_act = ep_act->active)
 860                         if (ep_act == ep) {
 861                                 VDBG("dequeue, urb %p active; wait for irq\n",
 862                                      urb);
 863                                 urb = NULL;
 864                                 break;
 865                         }
 866
 867         if (urb)
 868                 finish_request(isp116x, ep, urb, status);
 869  done:
 870         spin_unlock_irqrestore(&isp116x->lock, flags);
 871         return rc;
 872 }
 873
 874 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
 875                                      struct usb_host_endpoint *hep)
 876 {
 877         int i;
 878         struct isp116x_ep *ep = hep->hcpriv;
 879
 880         if (!ep)
 881                 return;
 882
 883         /* assume we'd just wait for the irq */
 884         for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
 885                 msleep(3);
 886         if (!list_empty(&hep->urb_list))
 887                 WARNING("ep %p not empty?\n", ep);
 888
 889         kfree(ep);
 890         hep->hcpriv = NULL;
 891 }
 892
 893 static int isp116x_get_frame(struct usb_hcd *hcd)
 894 {
 895         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 896         u32 fmnum;
 897         unsigned long flags;
 898
 899         spin_lock_irqsave(&isp116x->lock, flags);
 900         fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
 901         spin_unlock_irqrestore(&isp116x->lock, flags);
 902         return (int)fmnum;
 903 }
 904
 905 /*
 906   Adapted from ohci-hub.c. Currently we don't support autosuspend.
 907 */
 908 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 909 {
 910         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 911         int ports, i, changed = 0;
 912         unsigned long flags;
 913
 914         if (!HC_IS_RUNNING(hcd->state))
 915                 return -ESHUTDOWN;
 916
 917         /* Report no status change now, if we are scheduled to be
 918            called later */
 919         if (timer_pending(&hcd->rh_timer))
 920                 return 0;
 921
 922         ports = isp116x->rhdesca & RH_A_NDP;
 923         spin_lock_irqsave(&isp116x->lock, flags);
 924         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
 925         if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
 926                 buf[0] = changed = 1;
 927         else
 928                 buf[0] = 0;
 929
 930         for (i = 0; i < ports; i++) {
 931                 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
 932
 933                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
 934                               | RH_PS_OCIC | RH_PS_PRSC)) {
 935                         changed = 1;
 936                         buf[0] |= 1 << (i + 1);
 937                 }
 938         }
 939         spin_unlock_irqrestore(&isp116x->lock, flags);
 940         return changed;
 941 }
 942
 943 static void isp116x_hub_descriptor(struct isp116x *isp116x,
 944                                    struct usb_hub_descriptor *desc)
 945 {
 946         u32 reg = isp116x->rhdesca;
 947
 948         desc->bDescriptorType = 0x29;
 949         desc->bDescLength = 9;
 950         desc->bHubContrCurrent = 0;
 951         desc->bNbrPorts = (u8) (reg & 0x3);
 952         /* Power switching, device type, overcurrent. */
 953         desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
 954         desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
 955         /* ports removable, and legacy PortPwrCtrlMask */
 956         desc->u.hs.DeviceRemovable[0] = 0;
 957         desc->u.hs.DeviceRemovable[1] = ~0;
 958 }
 959
 960 /* Perform reset of a given port.
 961    It would be great to just start the reset and let the
 962    USB core to clear the reset in due time. However,
 963    root hub ports should be reset for at least 50 ms, while
 964    our chip stays in reset for about 10 ms. I.e., we must
 965    repeatedly reset it ourself here.
 966 */
 967 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
 968 {
 969         u32 tmp;
 970         unsigned long flags, t;
 971
 972         /* Root hub reset should be 50 ms, but some devices
 973            want it even longer. */
 974         t = jiffies + msecs_to_jiffies(100);
 975
 976         while (time_before(jiffies, t)) {
 977                 spin_lock_irqsave(&isp116x->lock, flags);
 978                 /* spin until any current reset finishes */
 979                 for (;;) {
 980                         tmp = isp116x_read_reg32(isp116x, port ?
 981                                                  HCRHPORT2 : HCRHPORT1);
 982                         if (!(tmp & RH_PS_PRS))
 983                                 break;
 984                         udelay(500);
 985                 }
 986                 /* Don't reset a disconnected port */
 987                 if (!(tmp & RH_PS_CCS)) {
 988                         spin_unlock_irqrestore(&isp116x->lock, flags);
 989                         break;
 990                 }
 991                 /* Reset lasts 10ms (claims datasheet) */
 992                 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
 993                                     HCRHPORT1, (RH_PS_PRS));
 994                 spin_unlock_irqrestore(&isp116x->lock, flags);
 995                 msleep(10);
 996         }
 997 }
 998
 999 /* Adapted from ohci-hub.c */
1000 static int isp116x_hub_control(struct usb_hcd *hcd,
1001                                u16 typeReq,
1002                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
1003 {
1004         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1005         int ret = 0;
1006         unsigned long flags;
1007         int ports = isp116x->rhdesca & RH_A_NDP;
1008         u32 tmp = 0;
1009
1010         switch (typeReq) {
1011         case ClearHubFeature:
1012                 DBG("ClearHubFeature: ");
1013                 switch (wValue) {
1014                 case C_HUB_OVER_CURRENT:
1015                         DBG("C_HUB_OVER_CURRENT\n");
1016                         spin_lock_irqsave(&isp116x->lock, flags);
1017                         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1018                         spin_unlock_irqrestore(&isp116x->lock, flags);
1019                 case C_HUB_LOCAL_POWER:
1020                         DBG("C_HUB_LOCAL_POWER\n");
1021                         break;
1022                 default:
1023                         goto error;
1024                 }
1025                 break;
1026         case SetHubFeature:
1027                 DBG("SetHubFeature: ");
1028                 switch (wValue) {
1029                 case C_HUB_OVER_CURRENT:
1030                 case C_HUB_LOCAL_POWER:
1031                         DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1032                         break;
1033                 default:
1034                         goto error;
1035                 }
1036                 break;
1037         case GetHubDescriptor:
1038                 DBG("GetHubDescriptor\n");
1039                 isp116x_hub_descriptor(isp116x,
1040                                        (struct usb_hub_descriptor *)buf);
1041                 break;
1042         case GetHubStatus:
1043                 DBG("GetHubStatus\n");
1044                 *(__le32 *) buf = 0;
1045                 break;
1046         case GetPortStatus:
1047                 DBG("GetPortStatus\n");
1048                 if (!wIndex || wIndex > ports)
1049                         goto error;
1050                 spin_lock_irqsave(&isp116x->lock, flags);
1051                 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1052                 spin_unlock_irqrestore(&isp116x->lock, flags);
1053                 *(__le32 *) buf = cpu_to_le32(tmp);
1054                 DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1055                 break;
1056         case ClearPortFeature:
1057                 DBG("ClearPortFeature: ");
1058                 if (!wIndex || wIndex > ports)
1059                         goto error;
1060                 wIndex--;
1061
1062                 switch (wValue) {
1063                 case USB_PORT_FEAT_ENABLE:
1064                         DBG("USB_PORT_FEAT_ENABLE\n");
1065                         tmp = RH_PS_CCS;
1066                         break;
1067                 case USB_PORT_FEAT_C_ENABLE:
1068                         DBG("USB_PORT_FEAT_C_ENABLE\n");
1069                         tmp = RH_PS_PESC;
1070                         break;
1071                 case USB_PORT_FEAT_SUSPEND:
1072                         DBG("USB_PORT_FEAT_SUSPEND\n");
1073                         tmp = RH_PS_POCI;
1074                         break;
1075                 case USB_PORT_FEAT_C_SUSPEND:
1076                         DBG("USB_PORT_FEAT_C_SUSPEND\n");
1077                         tmp = RH_PS_PSSC;
1078                         break;
1079                 case USB_PORT_FEAT_POWER:
1080                         DBG("USB_PORT_FEAT_POWER\n");
1081                         tmp = RH_PS_LSDA;
1082                         break;
1083                 case USB_PORT_FEAT_C_CONNECTION:
1084                         DBG("USB_PORT_FEAT_C_CONNECTION\n");
1085                         tmp = RH_PS_CSC;
1086                         break;
1087                 case USB_PORT_FEAT_C_OVER_CURRENT:
1088                         DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1089                         tmp = RH_PS_OCIC;
1090                         break;
1091                 case USB_PORT_FEAT_C_RESET:
1092                         DBG("USB_PORT_FEAT_C_RESET\n");
1093                         tmp = RH_PS_PRSC;
1094                         break;
1095                 default:
1096                         goto error;
1097                 }
1098                 spin_lock_irqsave(&isp116x->lock, flags);
1099                 isp116x_write_reg32(isp116x, wIndex
1100                                     ? HCRHPORT2 : HCRHPORT1, tmp);
1101                 spin_unlock_irqrestore(&isp116x->lock, flags);
1102                 break;
1103         case SetPortFeature:
1104                 DBG("SetPortFeature: ");
1105                 if (!wIndex || wIndex > ports)
1106                         goto error;
1107                 wIndex--;
1108                 switch (wValue) {
1109                 case USB_PORT_FEAT_SUSPEND:
1110                         DBG("USB_PORT_FEAT_SUSPEND\n");
1111                         spin_lock_irqsave(&isp116x->lock, flags);
1112                         isp116x_write_reg32(isp116x, wIndex
1113                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1114                         spin_unlock_irqrestore(&isp116x->lock, flags);
1115                         break;
1116                 case USB_PORT_FEAT_POWER:
1117                         DBG("USB_PORT_FEAT_POWER\n");
1118                         spin_lock_irqsave(&isp116x->lock, flags);
1119                         isp116x_write_reg32(isp116x, wIndex
1120                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1121                         spin_unlock_irqrestore(&isp116x->lock, flags);
1122                         break;
1123                 case USB_PORT_FEAT_RESET:
1124                         DBG("USB_PORT_FEAT_RESET\n");
1125                         root_port_reset(isp116x, wIndex);
1126                         break;
1127                 default:
1128                         goto error;
1129                 }
1130                 break;
1131
1132         default:
1133               error:
1134                 /* "protocol stall" on error */
1135                 DBG("PROTOCOL STALL\n");
1136                 ret = -EPIPE;
1137         }
1138         return ret;
1139 }
1140
1141 /*-----------------------------------------------------------------*/
1142
1143 #ifdef CONFIG_DEBUG_FS
1144
1145 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1146 {
1147         seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1148                    mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1149                    mask & HCuPINT_SUSP ? " susp" : "",
1150                    mask & HCuPINT_OPR ? " opr" : "",
1151                    mask & HCuPINT_AIIEOT ? " eot" : "",
1152                    mask & HCuPINT_ATL ? " atl" : "",
1153                    mask & HCuPINT_SOF ? " sof" : "");
1154 }
1155
1156 static void dump_int(struct seq_file *s, char *label, u32 mask)
1157 {
1158         seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1159                    mask & HCINT_MIE ? " MIE" : "",
1160                    mask & HCINT_RHSC ? " rhsc" : "",
1161                    mask & HCINT_FNO ? " fno" : "",
1162                    mask & HCINT_UE ? " ue" : "",
1163                    mask & HCINT_RD ? " rd" : "",
1164                    mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1165 }
1166
1167 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1168 {
1169         struct isp116x *isp116x = s->private;
1170
1171         seq_printf(s, "%s\n%s version %s\n",
1172                    isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1173                    DRIVER_VERSION);
1174
1175         if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1176                 seq_printf(s, "HCD is suspended\n");
1177                 return 0;
1178         }
1179         if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1180                 seq_printf(s, "HCD not running\n");
1181                 return 0;
1182         }
1183
1184         spin_lock_irq(&isp116x->lock);
1185         dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1186         dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1187         dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1188         dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1189         isp116x_show_regs_seq(isp116x, s);
1190         spin_unlock_irq(&isp116x->lock);
1191         seq_printf(s, "\n");
1192
1193         return 0;
1194 }
1195
1196 static int isp116x_open_seq(struct inode *inode, struct file *file)
1197 {
1198         return single_open(file, isp116x_show_dbg, inode->i_private);
1199 }
1200
1201 static const struct file_operations isp116x_debug_fops = {
1202         .open = isp116x_open_seq,
1203         .read = seq_read,
1204         .llseek = seq_lseek,
1205         .release = single_release,
1206 };
1207
1208 static int create_debug_file(struct isp116x *isp116x)
1209 {
1210         isp116x->dentry = debugfs_create_file(hcd_name,
1211                                               S_IRUGO, NULL, isp116x,
1212                                               &isp116x_debug_fops);
1213         if (!isp116x->dentry)
1214                 return -ENOMEM;
1215         return 0;
1216 }
1217
1218 static void remove_debug_file(struct isp116x *isp116x)
1219 {
1220         debugfs_remove(isp116x->dentry);
1221 }
1222
1223 #else
1224
1225 #define create_debug_file(d)    0
1226 #define remove_debug_file(d)    do{}while(0)
1227
1228 #endif                          /* CONFIG_DEBUG_FS */
1229
1230 /*-----------------------------------------------------------------*/
1231
1232 /*
1233   Software reset - can be called from any contect.
1234 */
1235 static int isp116x_sw_reset(struct isp116x *isp116x)
1236 {
1237         int retries = 15;
1238         unsigned long flags;
1239         int ret = 0;
1240
1241         spin_lock_irqsave(&isp116x->lock, flags);
1242         isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1243         isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1244         while (--retries) {
1245                 /* It usually resets within 1 ms */
1246                 mdelay(1);
1247                 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1248                         break;
1249         }
1250         if (!retries) {
1251                 ERR("Software reset timeout\n");
1252                 ret = -ETIME;
1253         }
1254         spin_unlock_irqrestore(&isp116x->lock, flags);
1255         return ret;
1256 }
1257
1258 static int isp116x_reset(struct usb_hcd *hcd)
1259 {
1260         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1261         unsigned long t;
1262         u16 clkrdy = 0;
1263         int ret, timeout = 15 /* ms */ ;
1264
1265         ret = isp116x_sw_reset(isp116x);
1266         if (ret)
1267                 return ret;
1268
1269         t = jiffies + msecs_to_jiffies(timeout);
1270         while (time_before_eq(jiffies, t)) {
1271                 msleep(4);
1272                 spin_lock_irq(&isp116x->lock);
1273                 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1274                 spin_unlock_irq(&isp116x->lock);
1275                 if (clkrdy)
1276                         break;
1277         }
1278         if (!clkrdy) {
1279                 ERR("Clock not ready after %dms\n", timeout);
1280                 /* After sw_reset the clock won't report to be ready, if
1281                    H_WAKEUP pin is high. */
1282                 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1283                 ret = -ENODEV;
1284         }
1285         return ret;
1286 }
1287
1288 static void isp116x_stop(struct usb_hcd *hcd)
1289 {
1290         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1291         unsigned long flags;
1292         u32 val;
1293
1294         spin_lock_irqsave(&isp116x->lock, flags);
1295         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1296
1297         /* Switch off ports' power, some devices don't come up
1298            after next 'insmod' without this */
1299         val = isp116x_read_reg32(isp116x, HCRHDESCA);
1300         val &= ~(RH_A_NPS | RH_A_PSM);
1301         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1302         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1303         spin_unlock_irqrestore(&isp116x->lock, flags);
1304
1305         isp116x_sw_reset(isp116x);
1306 }
1307
1308 /*
1309   Configure the chip. The chip must be successfully reset by now.
1310 */
1311 static int isp116x_start(struct usb_hcd *hcd)
1312 {
1313         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1314         struct isp116x_platform_data *board = isp116x->board;
1315         u32 val;
1316         unsigned long flags;
1317
1318         spin_lock_irqsave(&isp116x->lock, flags);
1319
1320         /* clear interrupt status and disable all interrupt sources */
1321         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1322         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1323
1324         val = isp116x_read_reg16(isp116x, HCCHIPID);
1325         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1326                 ERR("Invalid chip ID %04x\n", val);
1327                 spin_unlock_irqrestore(&isp116x->lock, flags);
1328                 return -ENODEV;
1329         }
1330
1331         /* To be removed in future */
1332         hcd->uses_new_polling = 1;
1333
1334         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1335         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1336
1337         /* ----- HW conf */
1338         val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1339         if (board->sel15Kres)
1340                 val |= HCHWCFG_15KRSEL;
1341         /* Remote wakeup won't work without working clock */
1342         if (board->remote_wakeup_enable)
1343                 val |= HCHWCFG_CLKNOTSTOP;
1344         if (board->oc_enable)
1345                 val |= HCHWCFG_ANALOG_OC;
1346         if (board->int_act_high)
1347                 val |= HCHWCFG_INT_POL;
1348         if (board->int_edge_triggered)
1349                 val |= HCHWCFG_INT_TRIGGER;
1350         isp116x_write_reg16(isp116x, HCHWCFG, val);
1351
1352         /* ----- Root hub conf */
1353         val = (25 << 24) & RH_A_POTPGT;
1354         /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1355            be always set. Yet, instead, we request individual port
1356            power switching. */
1357         val |= RH_A_PSM;
1358         /* Report overcurrent per port */
1359         val |= RH_A_OCPM;
1360         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1361         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1362
1363         val = RH_B_PPCM;
1364         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1365         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1366
1367         val = 0;
1368         if (board->remote_wakeup_enable) {
1369                 if (!device_can_wakeup(hcd->self.controller))
1370                         device_init_wakeup(hcd->self.controller, 1);
1371                 val |= RH_HS_DRWE;
1372         }
1373         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1374         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1375
1376         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1377
1378         hcd->state = HC_STATE_RUNNING;
1379
1380         /* Set up interrupts */
1381         isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1382         if (board->remote_wakeup_enable)
1383                 isp116x->intenb |= HCINT_RD;
1384         isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1385         isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1386         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1387
1388         /* Go operational */
1389         val = HCCONTROL_USB_OPER;
1390         if (board->remote_wakeup_enable)
1391                 val |= HCCONTROL_RWE;
1392         isp116x_write_reg32(isp116x, HCCONTROL, val);
1393
1394         /* Disable ports to avoid race in device enumeration */
1395         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1396         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1397
1398         isp116x_show_regs_log(isp116x);
1399         spin_unlock_irqrestore(&isp116x->lock, flags);
1400         return 0;
1401 }
1402
1403 #ifdef  CONFIG_PM
1404
1405 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1406 {
1407         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1408         unsigned long flags;
1409         u32 val;
1410         int ret = 0;
1411
1412         spin_lock_irqsave(&isp116x->lock, flags);
1413         val = isp116x_read_reg32(isp116x, HCCONTROL);
1414
1415         switch (val & HCCONTROL_HCFS) {
1416         case HCCONTROL_USB_OPER:
1417                 spin_unlock_irqrestore(&isp116x->lock, flags);
1418                 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1419                 val |= HCCONTROL_USB_SUSPEND;
1420                 if (hcd->self.root_hub->do_remote_wakeup)
1421                         val |= HCCONTROL_RWE;
1422                 /* Wait for usb transfers to finish */
1423                 msleep(2);
1424                 spin_lock_irqsave(&isp116x->lock, flags);
1425                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1426                 spin_unlock_irqrestore(&isp116x->lock, flags);
1427                 /* Wait for devices to suspend */
1428                 msleep(5);
1429                 break;
1430         case HCCONTROL_USB_RESUME:
1431                 isp116x_write_reg32(isp116x, HCCONTROL,
1432                                     (val & ~HCCONTROL_HCFS) |
1433                                     HCCONTROL_USB_RESET);
1434         case HCCONTROL_USB_RESET:
1435                 ret = -EBUSY;
1436         default:                /* HCCONTROL_USB_SUSPEND */
1437                 spin_unlock_irqrestore(&isp116x->lock, flags);
1438                 break;
1439         }
1440
1441         return ret;
1442 }
1443
1444 static int isp116x_bus_resume(struct usb_hcd *hcd)
1445 {
1446         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1447         u32 val;
1448
1449         msleep(5);
1450         spin_lock_irq(&isp116x->lock);
1451
1452         val = isp116x_read_reg32(isp116x, HCCONTROL);
1453         switch (val & HCCONTROL_HCFS) {
1454         case HCCONTROL_USB_SUSPEND:
1455                 val &= ~HCCONTROL_HCFS;
1456                 val |= HCCONTROL_USB_RESUME;
1457                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1458         case HCCONTROL_USB_RESUME:
1459                 break;
1460         case HCCONTROL_USB_OPER:
1461                 spin_unlock_irq(&isp116x->lock);
1462                 return 0;
1463         default:
1464                 /* HCCONTROL_USB_RESET: this may happen, when during
1465                    suspension the HC lost power. Reinitialize completely */
1466                 spin_unlock_irq(&isp116x->lock);
1467                 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1468                 isp116x_reset(hcd);
1469                 isp116x_start(hcd);
1470                 isp116x_hub_control(hcd, SetPortFeature,
1471                                     USB_PORT_FEAT_POWER, 1, NULL, 0);
1472                 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1473                         isp116x_hub_control(hcd, SetPortFeature,
1474                                             USB_PORT_FEAT_POWER, 2, NULL, 0);
1475                 return 0;
1476         }
1477
1478         val = isp116x->rhdesca & RH_A_NDP;
1479         while (val--) {
1480                 u32 stat =
1481                     isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1482                 /* force global, not selective, resume */
1483                 if (!(stat & RH_PS_PSS))
1484                         continue;
1485                 DBG("%s: Resuming port %d\n", __func__, val);
1486                 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1487                                     ? HCRHPORT2 : HCRHPORT1);
1488         }
1489         spin_unlock_irq(&isp116x->lock);
1490
1491         hcd->state = HC_STATE_RESUMING;
1492         msleep(20);
1493
1494         /* Go operational */
1495         spin_lock_irq(&isp116x->lock);
1496         val = isp116x_read_reg32(isp116x, HCCONTROL);
1497         isp116x_write_reg32(isp116x, HCCONTROL,
1498                             (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1499         spin_unlock_irq(&isp116x->lock);
1500         hcd->state = HC_STATE_RUNNING;
1501
1502         return 0;
1503 }
1504
1505 #else
1506
1507 #define isp116x_bus_suspend     NULL
1508 #define isp116x_bus_resume      NULL
1509
1510 #endif
1511
1512 static struct hc_driver isp116x_hc_driver = {
1513         .description = hcd_name,
1514         .product_desc = "ISP116x Host Controller",
1515         .hcd_priv_size = sizeof(struct isp116x),
1516
1517         .irq = isp116x_irq,
1518         .flags = HCD_USB11,
1519
1520         .reset = isp116x_reset,
1521         .start = isp116x_start,
1522         .stop = isp116x_stop,
1523
1524         .urb_enqueue = isp116x_urb_enqueue,
1525         .urb_dequeue = isp116x_urb_dequeue,
1526         .endpoint_disable = isp116x_endpoint_disable,
1527
1528         .get_frame_number = isp116x_get_frame,
1529
1530         .hub_status_data = isp116x_hub_status_data,
1531         .hub_control = isp116x_hub_control,
1532         .bus_suspend = isp116x_bus_suspend,
1533         .bus_resume = isp116x_bus_resume,
1534 };
1535
1536 /*----------------------------------------------------------------*/
1537
1538 static int isp116x_remove(struct platform_device *pdev)
1539 {
1540         struct usb_hcd *hcd = platform_get_drvdata(pdev);
1541         struct isp116x *isp116x;
1542         struct resource *res;
1543
1544         if (!hcd)
1545                 return 0;
1546         isp116x = hcd_to_isp116x(hcd);
1547         remove_debug_file(isp116x);
1548         usb_remove_hcd(hcd);
1549
1550         iounmap(isp116x->data_reg);
1551         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1552         release_mem_region(res->start, 2);
1553         iounmap(isp116x->addr_reg);
1554         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1555         release_mem_region(res->start, 2);
1556
1557         usb_put_hcd(hcd);
1558         return 0;
1559 }
1560
1561 static int __devinit isp116x_probe(struct platform_device *pdev)
1562 {
1563         struct usb_hcd *hcd;
1564         struct isp116x *isp116x;
1565         struct resource *addr, *data, *ires;
1566         void __iomem *addr_reg;
1567         void __iomem *data_reg;
1568         int irq;
1569         int ret = 0;
1570         unsigned long irqflags;
1571
1572         if (pdev->num_resources < 3) {
1573                 ret = -ENODEV;
1574                 goto err1;
1575         }
1576
1577         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1578         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1579         ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1580
1581         if (!addr || !data || !ires) {
1582                 ret = -ENODEV;
1583                 goto err1;
1584         }
1585
1586         irq = ires->start;
1587         irqflags = ires->flags & IRQF_TRIGGER_MASK;
1588
1589         if (pdev->dev.dma_mask) {
1590                 DBG("DMA not supported\n");
1591                 ret = -EINVAL;
1592                 goto err1;
1593         }
1594
1595         if (!request_mem_region(addr->start, 2, hcd_name)) {
1596                 ret = -EBUSY;
1597                 goto err1;
1598         }
1599         addr_reg = ioremap(addr->start, resource_size(addr));
1600         if (addr_reg == NULL) {
1601                 ret = -ENOMEM;
1602                 goto err2;
1603         }
1604         if (!request_mem_region(data->start, 2, hcd_name)) {
1605                 ret = -EBUSY;
1606                 goto err3;
1607         }
1608         data_reg = ioremap(data->start, resource_size(data));
1609         if (data_reg == NULL) {
1610                 ret = -ENOMEM;
1611                 goto err4;
1612         }
1613
1614         /* allocate and initialize hcd */
1615         hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1616         if (!hcd) {
1617                 ret = -ENOMEM;
1618                 goto err5;
1619         }
1620         /* this rsrc_start is bogus */
1621         hcd->rsrc_start = addr->start;
1622         isp116x = hcd_to_isp116x(hcd);
1623         isp116x->data_reg = data_reg;
1624         isp116x->addr_reg = addr_reg;
1625         spin_lock_init(&isp116x->lock);
1626         INIT_LIST_HEAD(&isp116x->async);
1627         isp116x->board = pdev->dev.platform_data;
1628
1629         if (!isp116x->board) {
1630                 ERR("Platform data structure not initialized\n");
1631                 ret = -ENODEV;
1632                 goto err6;
1633         }
1634         if (isp116x_check_platform_delay(isp116x)) {
1635                 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1636                     "implemented.\n");
1637                 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1638                 ret = -ENODEV;
1639                 goto err6;
1640         }
1641
1642         ret = usb_add_hcd(hcd, irq, irqflags);
1643         if (ret)
1644                 goto err6;
1645
1646         ret = create_debug_file(isp116x);
1647         if (ret) {
1648                 ERR("Couldn't create debugfs entry\n");
1649                 goto err7;
1650         }
1651
1652         return 0;
1653
1654       err7:
1655         usb_remove_hcd(hcd);
1656       err6:
1657         usb_put_hcd(hcd);
1658       err5:
1659         iounmap(data_reg);
1660       err4:
1661         release_mem_region(data->start, 2);
1662       err3:
1663         iounmap(addr_reg);
1664       err2:
1665         release_mem_region(addr->start, 2);
1666       err1:
1667         ERR("init error, %d\n", ret);
1668         return ret;
1669 }
1670
1671 #ifdef  CONFIG_PM
1672 /*
1673   Suspend of platform device
1674 */
1675 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1676 {
1677         VDBG("%s: state %x\n", __func__, state.event);
1678         return 0;
1679 }
1680
1681 /*
1682   Resume platform device
1683 */
1684 static int isp116x_resume(struct platform_device *dev)
1685 {
1686         VDBG("%s\n", __func__);
1687         return 0;
1688 }
1689
1690 #else
1691
1692 #define isp116x_suspend    NULL
1693 #define isp116x_resume     NULL
1694
1695 #endif
1696
1697 /* work with hotplug and coldplug */
1698 MODULE_ALIAS("platform:isp116x-hcd");
1699
1700 static struct platform_driver isp116x_driver = {
1701         .probe = isp116x_probe,
1702         .remove = isp116x_remove,
1703         .suspend = isp116x_suspend,
1704         .resume = isp116x_resume,
1705         .driver = {
1706                 .name = (char *)hcd_name,
1707                 .owner  = THIS_MODULE,
1708         },
1709 };
1710
1711 /*-----------------------------------------------------------------*/
1712
1713 static int __init isp116x_init(void)
1714 {
1715         if (usb_disabled())
1716                 return -ENODEV;
1717
1718         INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1719         return platform_driver_register(&isp116x_driver);
1720 }
1721
1722 module_init(isp116x_init);
1723
1724 static void __exit isp116x_cleanup(void)
1725 {
1726         platform_driver_unregister(&isp116x_driver);
1727 }
1728
1729 module_exit(isp116x_cleanup);