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