SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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         urb->hcpriv = hep;
 819         start_atl_transfers(isp116x);
 820
 821       fail:
 822         if (ret)
 823                 usb_hcd_unlink_urb_from_ep(hcd, urb);
 824       fail_not_linked:
 825         spin_unlock_irqrestore(&isp116x->lock, flags);
 826         return ret;
 827 }
 828
 829 /*
 830    Dequeue URBs.
 831 */
 832 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
 833                 int status)
 834 {
 835         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 836         struct usb_host_endpoint *hep;
 837         struct isp116x_ep *ep, *ep_act;
 838         unsigned long flags;
 839         int rc;
 840
 841         spin_lock_irqsave(&isp116x->lock, flags);
 842         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
 843         if (rc)
 844                 goto done;
 845
 846         hep = urb->hcpriv;
 847         ep = hep->hcpriv;
 848         WARN_ON(hep != ep->hep);
 849
 850         /* In front of queue? */
 851         if (ep->hep->urb_list.next == &urb->urb_list)
 852                 /* active? */
 853                 for (ep_act = isp116x->atl_active; ep_act;
 854                      ep_act = ep_act->active)
 855                         if (ep_act == ep) {
 856                                 VDBG("dequeue, urb %p active; wait for irq\n",
 857                                      urb);
 858                                 urb = NULL;
 859                                 break;
 860                         }
 861
 862         if (urb)
 863                 finish_request(isp116x, ep, urb);
 864  done:
 865         spin_unlock_irqrestore(&isp116x->lock, flags);
 866         return rc;
 867 }
 868
 869 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
 870                                      struct usb_host_endpoint *hep)
 871 {
 872         int i;
 873         struct isp116x_ep *ep = hep->hcpriv;
 874
 875         if (!ep)
 876                 return;
 877
 878         /* assume we'd just wait for the irq */
 879         for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
 880                 msleep(3);
 881         if (!list_empty(&hep->urb_list))
 882                 WARN("ep %p not empty?\n", ep);
 883
 884         kfree(ep);
 885         hep->hcpriv = NULL;
 886 }
 887
 888 static int isp116x_get_frame(struct usb_hcd *hcd)
 889 {
 890         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 891         u32 fmnum;
 892         unsigned long flags;
 893
 894         spin_lock_irqsave(&isp116x->lock, flags);
 895         fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
 896         spin_unlock_irqrestore(&isp116x->lock, flags);
 897         return (int)fmnum;
 898 }
 899
 900 /*
 901   Adapted from ohci-hub.c. Currently we don't support autosuspend.
 902 */
 903 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 904 {
 905         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 906         int ports, i, changed = 0;
 907         unsigned long flags;
 908
 909         if (!HC_IS_RUNNING(hcd->state))
 910                 return -ESHUTDOWN;
 911
 912         /* Report no status change now, if we are scheduled to be
 913            called later */
 914         if (timer_pending(&hcd->rh_timer))
 915                 return 0;
 916
 917         ports = isp116x->rhdesca & RH_A_NDP;
 918         spin_lock_irqsave(&isp116x->lock, flags);
 919         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
 920         if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
 921                 buf[0] = changed = 1;
 922         else
 923                 buf[0] = 0;
 924
 925         for (i = 0; i < ports; i++) {
 926                 u32 status = isp116x->rhport[i] =
 927                     isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
 928
 929                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
 930                               | RH_PS_OCIC | RH_PS_PRSC)) {
 931                         changed = 1;
 932                         buf[0] |= 1 << (i + 1);
 933                         continue;
 934                 }
 935         }
 936         spin_unlock_irqrestore(&isp116x->lock, flags);
 937         return changed;
 938 }
 939
 940 static void isp116x_hub_descriptor(struct isp116x *isp116x,
 941                                    struct usb_hub_descriptor *desc)
 942 {
 943         u32 reg = isp116x->rhdesca;
 944
 945         desc->bDescriptorType = 0x29;
 946         desc->bDescLength = 9;
 947         desc->bHubContrCurrent = 0;
 948         desc->bNbrPorts = (u8) (reg & 0x3);
 949         /* Power switching, device type, overcurrent. */
 950         desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
 951         desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
 952         /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
 953         desc->bitmap[0] = 0;
 954         desc->bitmap[1] = ~0;
 955 }
 956
 957 /* Perform reset of a given port.
 958    It would be great to just start the reset and let the
 959    USB core to clear the reset in due time. However,
 960    root hub ports should be reset for at least 50 ms, while
 961    our chip stays in reset for about 10 ms. I.e., we must
 962    repeatedly reset it ourself here.
 963 */
 964 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
 965 {
 966         u32 tmp;
 967         unsigned long flags, t;
 968
 969         /* Root hub reset should be 50 ms, but some devices
 970            want it even longer. */
 971         t = jiffies + msecs_to_jiffies(100);
 972
 973         while (time_before(jiffies, t)) {
 974                 spin_lock_irqsave(&isp116x->lock, flags);
 975                 /* spin until any current reset finishes */
 976                 for (;;) {
 977                         tmp = isp116x_read_reg32(isp116x, port ?
 978                                                  HCRHPORT2 : HCRHPORT1);
 979                         if (!(tmp & RH_PS_PRS))
 980                                 break;
 981                         udelay(500);
 982                 }
 983                 /* Don't reset a disconnected port */
 984                 if (!(tmp & RH_PS_CCS)) {
 985                         spin_unlock_irqrestore(&isp116x->lock, flags);
 986                         break;
 987                 }
 988                 /* Reset lasts 10ms (claims datasheet) */
 989                 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
 990                                     HCRHPORT1, (RH_PS_PRS));
 991                 spin_unlock_irqrestore(&isp116x->lock, flags);
 992                 msleep(10);
 993         }
 994 }
 995
 996 /* Adapted from ohci-hub.c */
 997 static int isp116x_hub_control(struct usb_hcd *hcd,
 998                                u16 typeReq,
 999                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
1000 {
1001         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1002         int ret = 0;
1003         unsigned long flags;
1004         int ports = isp116x->rhdesca & RH_A_NDP;
1005         u32 tmp = 0;
1006
1007         switch (typeReq) {
1008         case ClearHubFeature:
1009                 DBG("ClearHubFeature: ");
1010                 switch (wValue) {
1011                 case C_HUB_OVER_CURRENT:
1012                         DBG("C_HUB_OVER_CURRENT\n");
1013                         spin_lock_irqsave(&isp116x->lock, flags);
1014                         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1015                         spin_unlock_irqrestore(&isp116x->lock, flags);
1016                 case C_HUB_LOCAL_POWER:
1017                         DBG("C_HUB_LOCAL_POWER\n");
1018                         break;
1019                 default:
1020                         goto error;
1021                 }
1022                 break;
1023         case SetHubFeature:
1024                 DBG("SetHubFeature: ");
1025                 switch (wValue) {
1026                 case C_HUB_OVER_CURRENT:
1027                 case C_HUB_LOCAL_POWER:
1028                         DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1029                         break;
1030                 default:
1031                         goto error;
1032                 }
1033                 break;
1034         case GetHubDescriptor:
1035                 DBG("GetHubDescriptor\n");
1036                 isp116x_hub_descriptor(isp116x,
1037                                        (struct usb_hub_descriptor *)buf);
1038                 break;
1039         case GetHubStatus:
1040                 DBG("GetHubStatus\n");
1041                 *(__le32 *) buf = 0;
1042                 break;
1043         case GetPortStatus:
1044                 DBG("GetPortStatus\n");
1045                 if (!wIndex || wIndex > ports)
1046                         goto error;
1047                 tmp = isp116x->rhport[--wIndex];
1048                 *(__le32 *) buf = cpu_to_le32(tmp);
1049                 DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1050                 break;
1051         case ClearPortFeature:
1052                 DBG("ClearPortFeature: ");
1053                 if (!wIndex || wIndex > ports)
1054                         goto error;
1055                 wIndex--;
1056
1057                 switch (wValue) {
1058                 case USB_PORT_FEAT_ENABLE:
1059                         DBG("USB_PORT_FEAT_ENABLE\n");
1060                         tmp = RH_PS_CCS;
1061                         break;
1062                 case USB_PORT_FEAT_C_ENABLE:
1063                         DBG("USB_PORT_FEAT_C_ENABLE\n");
1064                         tmp = RH_PS_PESC;
1065                         break;
1066                 case USB_PORT_FEAT_SUSPEND:
1067                         DBG("USB_PORT_FEAT_SUSPEND\n");
1068                         tmp = RH_PS_POCI;
1069                         break;
1070                 case USB_PORT_FEAT_C_SUSPEND:
1071                         DBG("USB_PORT_FEAT_C_SUSPEND\n");
1072                         tmp = RH_PS_PSSC;
1073                         break;
1074                 case USB_PORT_FEAT_POWER:
1075                         DBG("USB_PORT_FEAT_POWER\n");
1076                         tmp = RH_PS_LSDA;
1077                         break;
1078                 case USB_PORT_FEAT_C_CONNECTION:
1079                         DBG("USB_PORT_FEAT_C_CONNECTION\n");
1080                         tmp = RH_PS_CSC;
1081                         break;
1082                 case USB_PORT_FEAT_C_OVER_CURRENT:
1083                         DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1084                         tmp = RH_PS_OCIC;
1085                         break;
1086                 case USB_PORT_FEAT_C_RESET:
1087                         DBG("USB_PORT_FEAT_C_RESET\n");
1088                         tmp = RH_PS_PRSC;
1089                         break;
1090                 default:
1091                         goto error;
1092                 }
1093                 spin_lock_irqsave(&isp116x->lock, flags);
1094                 isp116x_write_reg32(isp116x, wIndex
1095                                     ? HCRHPORT2 : HCRHPORT1, tmp);
1096                 isp116x->rhport[wIndex] =
1097                     isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1098                 spin_unlock_irqrestore(&isp116x->lock, flags);
1099                 break;
1100         case SetPortFeature:
1101                 DBG("SetPortFeature: ");
1102                 if (!wIndex || wIndex > ports)
1103                         goto error;
1104                 wIndex--;
1105                 switch (wValue) {
1106                 case USB_PORT_FEAT_SUSPEND:
1107                         DBG("USB_PORT_FEAT_SUSPEND\n");
1108                         spin_lock_irqsave(&isp116x->lock, flags);
1109                         isp116x_write_reg32(isp116x, wIndex
1110                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1111                         break;
1112                 case USB_PORT_FEAT_POWER:
1113                         DBG("USB_PORT_FEAT_POWER\n");
1114                         spin_lock_irqsave(&isp116x->lock, flags);
1115                         isp116x_write_reg32(isp116x, wIndex
1116                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1117                         break;
1118                 case USB_PORT_FEAT_RESET:
1119                         DBG("USB_PORT_FEAT_RESET\n");
1120                         root_port_reset(isp116x, wIndex);
1121                         spin_lock_irqsave(&isp116x->lock, flags);
1122                         break;
1123                 default:
1124                         goto error;
1125                 }
1126                 isp116x->rhport[wIndex] =
1127                     isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1128                 spin_unlock_irqrestore(&isp116x->lock, flags);
1129                 break;
1130
1131         default:
1132               error:
1133                 /* "protocol stall" on error */
1134                 DBG("PROTOCOL STALL\n");
1135                 ret = -EPIPE;
1136         }
1137         return ret;
1138 }
1139
1140 /*-----------------------------------------------------------------*/
1141
1142 #ifdef CONFIG_DEBUG_FS
1143
1144 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1145 {
1146         seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1147                    mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1148                    mask & HCuPINT_SUSP ? " susp" : "",
1149                    mask & HCuPINT_OPR ? " opr" : "",
1150                    mask & HCuPINT_AIIEOT ? " eot" : "",
1151                    mask & HCuPINT_ATL ? " atl" : "",
1152                    mask & HCuPINT_SOF ? " sof" : "");
1153 }
1154
1155 static void dump_int(struct seq_file *s, char *label, u32 mask)
1156 {
1157         seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1158                    mask & HCINT_MIE ? " MIE" : "",
1159                    mask & HCINT_RHSC ? " rhsc" : "",
1160                    mask & HCINT_FNO ? " fno" : "",
1161                    mask & HCINT_UE ? " ue" : "",
1162                    mask & HCINT_RD ? " rd" : "",
1163                    mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1164 }
1165
1166 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1167 {
1168         struct isp116x *isp116x = s->private;
1169
1170         seq_printf(s, "%s\n%s version %s\n",
1171                    isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1172                    DRIVER_VERSION);
1173
1174         if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1175                 seq_printf(s, "HCD is suspended\n");
1176                 return 0;
1177         }
1178         if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1179                 seq_printf(s, "HCD not running\n");
1180                 return 0;
1181         }
1182
1183         spin_lock_irq(&isp116x->lock);
1184         dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1185         dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1186         dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1187         dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1188         isp116x_show_regs_seq(isp116x, s);
1189         spin_unlock_irq(&isp116x->lock);
1190         seq_printf(s, "\n");
1191
1192         return 0;
1193 }
1194
1195 static int isp116x_open_seq(struct inode *inode, struct file *file)
1196 {
1197         return single_open(file, isp116x_show_dbg, inode->i_private);
1198 }
1199
1200 static const struct file_operations isp116x_debug_fops = {
1201         .open = isp116x_open_seq,
1202         .read = seq_read,
1203         .llseek = seq_lseek,
1204         .release = single_release,
1205 };
1206
1207 static int create_debug_file(struct isp116x *isp116x)
1208 {
1209         isp116x->dentry = debugfs_create_file(hcd_name,
1210                                               S_IRUGO, NULL, isp116x,
1211                                               &isp116x_debug_fops);
1212         if (!isp116x->dentry)
1213                 return -ENOMEM;
1214         return 0;
1215 }
1216
1217 static void remove_debug_file(struct isp116x *isp116x)
1218 {
1219         debugfs_remove(isp116x->dentry);
1220 }
1221
1222 #else
1223
1224 #define create_debug_file(d)    0
1225 #define remove_debug_file(d)    do{}while(0)
1226
1227 #endif                          /* CONFIG_DEBUG_FS */
1228
1229 /*-----------------------------------------------------------------*/
1230
1231 /*
1232   Software reset - can be called from any contect.
1233 */
1234 static int isp116x_sw_reset(struct isp116x *isp116x)
1235 {
1236         int retries = 15;
1237         unsigned long flags;
1238         int ret = 0;
1239
1240         spin_lock_irqsave(&isp116x->lock, flags);
1241         isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1242         isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1243         while (--retries) {
1244                 /* It usually resets within 1 ms */
1245                 mdelay(1);
1246                 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1247                         break;
1248         }
1249         if (!retries) {
1250                 ERR("Software reset timeout\n");
1251                 ret = -ETIME;
1252         }
1253         spin_unlock_irqrestore(&isp116x->lock, flags);
1254         return ret;
1255 }
1256
1257 static int isp116x_reset(struct usb_hcd *hcd)
1258 {
1259         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1260         unsigned long t;
1261         u16 clkrdy = 0;
1262         int ret, timeout = 15 /* ms */ ;
1263
1264         ret = isp116x_sw_reset(isp116x);
1265         if (ret)
1266                 return ret;
1267
1268         t = jiffies + msecs_to_jiffies(timeout);
1269         while (time_before_eq(jiffies, t)) {
1270                 msleep(4);
1271                 spin_lock_irq(&isp116x->lock);
1272                 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1273                 spin_unlock_irq(&isp116x->lock);
1274                 if (clkrdy)
1275                         break;
1276         }
1277         if (!clkrdy) {
1278                 ERR("Clock not ready after %dms\n", timeout);
1279                 /* After sw_reset the clock won't report to be ready, if
1280                    H_WAKEUP pin is high. */
1281                 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1282                 ret = -ENODEV;
1283         }
1284         return ret;
1285 }
1286
1287 static void isp116x_stop(struct usb_hcd *hcd)
1288 {
1289         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1290         unsigned long flags;
1291         u32 val;
1292
1293         spin_lock_irqsave(&isp116x->lock, flags);
1294         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1295
1296         /* Switch off ports' power, some devices don't come up
1297            after next 'insmod' without this */
1298         val = isp116x_read_reg32(isp116x, HCRHDESCA);
1299         val &= ~(RH_A_NPS | RH_A_PSM);
1300         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1301         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1302         spin_unlock_irqrestore(&isp116x->lock, flags);
1303
1304         isp116x_sw_reset(isp116x);
1305 }
1306
1307 /*
1308   Configure the chip. The chip must be successfully reset by now.
1309 */
1310 static int isp116x_start(struct usb_hcd *hcd)
1311 {
1312         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1313         struct isp116x_platform_data *board = isp116x->board;
1314         u32 val;
1315         unsigned long flags;
1316
1317         spin_lock_irqsave(&isp116x->lock, flags);
1318
1319         /* clear interrupt status and disable all interrupt sources */
1320         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1321         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1322
1323         val = isp116x_read_reg16(isp116x, HCCHIPID);
1324         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1325                 ERR("Invalid chip ID %04x\n", val);
1326                 spin_unlock_irqrestore(&isp116x->lock, flags);
1327                 return -ENODEV;
1328         }
1329
1330         /* To be removed in future */
1331         hcd->uses_new_polling = 1;
1332
1333         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1334         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1335
1336         /* ----- HW conf */
1337         val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1338         if (board->sel15Kres)
1339                 val |= HCHWCFG_15KRSEL;
1340         /* Remote wakeup won't work without working clock */
1341         if (board->remote_wakeup_enable)
1342                 val |= HCHWCFG_CLKNOTSTOP;
1343         if (board->oc_enable)
1344                 val |= HCHWCFG_ANALOG_OC;
1345         if (board->int_act_high)
1346                 val |= HCHWCFG_INT_POL;
1347         if (board->int_edge_triggered)
1348                 val |= HCHWCFG_INT_TRIGGER;
1349         isp116x_write_reg16(isp116x, HCHWCFG, val);
1350
1351         /* ----- Root hub conf */
1352         val = (25 << 24) & RH_A_POTPGT;
1353         /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1354            be always set. Yet, instead, we request individual port
1355            power switching. */
1356         val |= RH_A_PSM;
1357         /* Report overcurrent per port */
1358         val |= RH_A_OCPM;
1359         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1360         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1361
1362         val = RH_B_PPCM;
1363         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1364         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1365
1366         val = 0;
1367         if (board->remote_wakeup_enable) {
1368                 if (!device_can_wakeup(hcd->self.controller))
1369                         device_init_wakeup(hcd->self.controller, 1);
1370                 val |= RH_HS_DRWE;
1371         }
1372         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1373         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1374
1375         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1376
1377         hcd->state = HC_STATE_RUNNING;
1378
1379         /* Set up interrupts */
1380         isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1381         if (board->remote_wakeup_enable)
1382                 isp116x->intenb |= HCINT_RD;
1383         isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1384         isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1385         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1386
1387         /* Go operational */
1388         val = HCCONTROL_USB_OPER;
1389         if (board->remote_wakeup_enable)
1390                 val |= HCCONTROL_RWE;
1391         isp116x_write_reg32(isp116x, HCCONTROL, val);
1392
1393         /* Disable ports to avoid race in device enumeration */
1394         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1395         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1396
1397         isp116x_show_regs_log(isp116x);
1398         spin_unlock_irqrestore(&isp116x->lock, flags);
1399         return 0;
1400 }
1401
1402 #ifdef  CONFIG_PM
1403
1404 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1405 {
1406         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1407         unsigned long flags;
1408         u32 val;
1409         int ret = 0;
1410
1411         spin_lock_irqsave(&isp116x->lock, flags);
1412         val = isp116x_read_reg32(isp116x, HCCONTROL);
1413
1414         switch (val & HCCONTROL_HCFS) {
1415         case HCCONTROL_USB_OPER:
1416                 spin_unlock_irqrestore(&isp116x->lock, flags);
1417                 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1418                 val |= HCCONTROL_USB_SUSPEND;
1419                 if (device_may_wakeup(&hcd->self.root_hub->dev))
1420                         val |= HCCONTROL_RWE;
1421                 /* Wait for usb transfers to finish */
1422                 msleep(2);
1423                 spin_lock_irqsave(&isp116x->lock, flags);
1424                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1425                 spin_unlock_irqrestore(&isp116x->lock, flags);
1426                 /* Wait for devices to suspend */
1427                 msleep(5);
1428                 break;
1429         case HCCONTROL_USB_RESUME:
1430                 isp116x_write_reg32(isp116x, HCCONTROL,
1431                                     (val & ~HCCONTROL_HCFS) |
1432                                     HCCONTROL_USB_RESET);
1433         case HCCONTROL_USB_RESET:
1434                 ret = -EBUSY;
1435         default:                /* HCCONTROL_USB_SUSPEND */
1436                 spin_unlock_irqrestore(&isp116x->lock, flags);
1437                 break;
1438         }
1439
1440         return ret;
1441 }
1442
1443 static int isp116x_bus_resume(struct usb_hcd *hcd)
1444 {
1445         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1446         u32 val;
1447
1448         msleep(5);
1449         spin_lock_irq(&isp116x->lock);
1450
1451         val = isp116x_read_reg32(isp116x, HCCONTROL);
1452         switch (val & HCCONTROL_HCFS) {
1453         case HCCONTROL_USB_SUSPEND:
1454                 val &= ~HCCONTROL_HCFS;
1455                 val |= HCCONTROL_USB_RESUME;
1456                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1457         case HCCONTROL_USB_RESUME:
1458                 break;
1459         case HCCONTROL_USB_OPER:
1460                 spin_unlock_irq(&isp116x->lock);
1461                 /* Without setting power_state here the
1462                    SUSPENDED state won't be removed from
1463                    sysfs/usbN/power.state as a response to remote
1464                    wakeup. Maybe in the future. */
1465                 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1466                 return 0;
1467         default:
1468                 /* HCCONTROL_USB_RESET: this may happen, when during
1469                    suspension the HC lost power. Reinitialize completely */
1470                 spin_unlock_irq(&isp116x->lock);
1471                 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1472                 isp116x_reset(hcd);
1473                 isp116x_start(hcd);
1474                 isp116x_hub_control(hcd, SetPortFeature,
1475                                     USB_PORT_FEAT_POWER, 1, NULL, 0);
1476                 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1477                         isp116x_hub_control(hcd, SetPortFeature,
1478                                             USB_PORT_FEAT_POWER, 2, NULL, 0);
1479                 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1480                 return 0;
1481         }
1482
1483         val = isp116x->rhdesca & RH_A_NDP;
1484         while (val--) {
1485                 u32 stat =
1486                     isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1487                 /* force global, not selective, resume */
1488                 if (!(stat & RH_PS_PSS))
1489                         continue;
1490                 DBG("%s: Resuming port %d\n", __func__, val);
1491                 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1492                                     ? HCRHPORT2 : HCRHPORT1);
1493         }
1494         spin_unlock_irq(&isp116x->lock);
1495
1496         hcd->state = HC_STATE_RESUMING;
1497         msleep(20);
1498
1499         /* Go operational */
1500         spin_lock_irq(&isp116x->lock);
1501         val = isp116x_read_reg32(isp116x, HCCONTROL);
1502         isp116x_write_reg32(isp116x, HCCONTROL,
1503                             (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1504         spin_unlock_irq(&isp116x->lock);
1505         /* see analogous comment above */
1506         hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1507         hcd->state = HC_STATE_RUNNING;
1508
1509         return 0;
1510 }
1511
1512 #else
1513
1514 #define isp116x_bus_suspend     NULL
1515 #define isp116x_bus_resume      NULL
1516
1517 #endif
1518
1519 static struct hc_driver isp116x_hc_driver = {
1520         .description = hcd_name,
1521         .product_desc = "ISP116x Host Controller",
1522         .hcd_priv_size = sizeof(struct isp116x),
1523
1524         .irq = isp116x_irq,
1525         .flags = HCD_USB11,
1526
1527         .reset = isp116x_reset,
1528         .start = isp116x_start,
1529         .stop = isp116x_stop,
1530
1531         .urb_enqueue = isp116x_urb_enqueue,
1532         .urb_dequeue = isp116x_urb_dequeue,
1533         .endpoint_disable = isp116x_endpoint_disable,
1534
1535         .get_frame_number = isp116x_get_frame,
1536
1537         .hub_status_data = isp116x_hub_status_data,
1538         .hub_control = isp116x_hub_control,
1539         .bus_suspend = isp116x_bus_suspend,
1540         .bus_resume = isp116x_bus_resume,
1541 };
1542
1543 /*----------------------------------------------------------------*/
1544
1545 static int isp116x_remove(struct platform_device *pdev)
1546 {
1547         struct usb_hcd *hcd = platform_get_drvdata(pdev);
1548         struct isp116x *isp116x;
1549         struct resource *res;
1550
1551         if (!hcd)
1552                 return 0;
1553         isp116x = hcd_to_isp116x(hcd);
1554         remove_debug_file(isp116x);
1555         usb_remove_hcd(hcd);
1556
1557         iounmap(isp116x->data_reg);
1558         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1559         release_mem_region(res->start, 2);
1560         iounmap(isp116x->addr_reg);
1561         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1562         release_mem_region(res->start, 2);
1563
1564         usb_put_hcd(hcd);
1565         return 0;
1566 }
1567
1568 #define resource_len(r) (((r)->end - (r)->start) + 1)
1569
1570 static int __devinit isp116x_probe(struct platform_device *pdev)
1571 {
1572         struct usb_hcd *hcd;
1573         struct isp116x *isp116x;
1574         struct resource *addr, *data;
1575         void __iomem *addr_reg;
1576         void __iomem *data_reg;
1577         int irq;
1578         int ret = 0;
1579
1580         if (pdev->num_resources < 3) {
1581                 ret = -ENODEV;
1582                 goto err1;
1583         }
1584
1585         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1586         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1587         irq = platform_get_irq(pdev, 0);
1588         if (!addr || !data || irq < 0) {
1589                 ret = -ENODEV;
1590                 goto err1;
1591         }
1592
1593         if (pdev->dev.dma_mask) {
1594                 DBG("DMA not supported\n");
1595                 ret = -EINVAL;
1596                 goto err1;
1597         }
1598
1599         if (!request_mem_region(addr->start, 2, hcd_name)) {
1600                 ret = -EBUSY;
1601                 goto err1;
1602         }
1603         addr_reg = ioremap(addr->start, resource_len(addr));
1604         if (addr_reg == NULL) {
1605                 ret = -ENOMEM;
1606                 goto err2;
1607         }
1608         if (!request_mem_region(data->start, 2, hcd_name)) {
1609                 ret = -EBUSY;
1610                 goto err3;
1611         }
1612         data_reg = ioremap(data->start, resource_len(data));
1613         if (data_reg == NULL) {
1614                 ret = -ENOMEM;
1615                 goto err4;
1616         }
1617
1618         /* allocate and initialize hcd */
1619         hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1620         if (!hcd) {
1621                 ret = -ENOMEM;
1622                 goto err5;
1623         }
1624         /* this rsrc_start is bogus */
1625         hcd->rsrc_start = addr->start;
1626         isp116x = hcd_to_isp116x(hcd);
1627         isp116x->data_reg = data_reg;
1628         isp116x->addr_reg = addr_reg;
1629         spin_lock_init(&isp116x->lock);
1630         INIT_LIST_HEAD(&isp116x->async);
1631         isp116x->board = pdev->dev.platform_data;
1632
1633         if (!isp116x->board) {
1634                 ERR("Platform data structure not initialized\n");
1635                 ret = -ENODEV;
1636                 goto err6;
1637         }
1638         if (isp116x_check_platform_delay(isp116x)) {
1639                 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1640                     "implemented.\n");
1641                 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1642                 ret = -ENODEV;
1643                 goto err6;
1644         }
1645
1646         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1647         if (ret)
1648                 goto err6;
1649
1650         ret = create_debug_file(isp116x);
1651         if (ret) {
1652                 ERR("Couldn't create debugfs entry\n");
1653                 goto err7;
1654         }
1655
1656         return 0;
1657
1658       err7:
1659         usb_remove_hcd(hcd);
1660       err6:
1661         usb_put_hcd(hcd);
1662       err5:
1663         iounmap(data_reg);
1664       err4:
1665         release_mem_region(data->start, 2);
1666       err3:
1667         iounmap(addr_reg);
1668       err2:
1669         release_mem_region(addr->start, 2);
1670       err1:
1671         ERR("init error, %d\n", ret);
1672         return ret;
1673 }
1674
1675 #ifdef  CONFIG_PM
1676 /*
1677   Suspend of platform device
1678 */
1679 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1680 {
1681         VDBG("%s: state %x\n", __func__, state.event);
1682         dev->dev.power.power_state = state;
1683         return 0;
1684 }
1685
1686 /*
1687   Resume platform device
1688 */
1689 static int isp116x_resume(struct platform_device *dev)
1690 {
1691         VDBG("%s:  state %x\n", __func__, dev->power.power_state.event);
1692         dev->dev.power.power_state = PMSG_ON;
1693         return 0;
1694 }
1695
1696 #else
1697
1698 #define isp116x_suspend    NULL
1699 #define isp116x_resume     NULL
1700
1701 #endif
1702
1703 static struct platform_driver isp116x_driver = {
1704         .probe = isp116x_probe,
1705         .remove = isp116x_remove,
1706         .suspend = isp116x_suspend,
1707         .resume = isp116x_resume,
1708         .driver = {
1709                    .name = (char *)hcd_name,
1710                    },
1711 };
1712
1713 /*-----------------------------------------------------------------*/
1714
1715 static int __init isp116x_init(void)
1716 {
1717         if (usb_disabled())
1718                 return -ENODEV;
1719
1720         INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1721         return platform_driver_register(&isp116x_driver);
1722 }
1723
1724 module_init(isp116x_init);
1725
1726 static void __exit isp116x_cleanup(void)
1727 {
1728         platform_driver_unregister(&isp116x_driver);
1729 }
1730
1731 module_exit(isp116x_cleanup);