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