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