git.oblomov.eu Git - linux-2.6/blob - drivers/usb/host/isp116x-hcd.c

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