drivers/usb/host/isp116x-hcd.c

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