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