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 = 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                 ep->branch = ret = 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         kfree(ep);
 895         hep->hcpriv = NULL;
 896 }
 897
 898 static int isp116x_get_frame(struct usb_hcd *hcd)
 899 {
 900         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 901         u32 fmnum;
 902         unsigned long flags;
 903
 904         spin_lock_irqsave(&isp116x->lock, flags);
 905         fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
 906         spin_unlock_irqrestore(&isp116x->lock, flags);
 907         return (int)fmnum;
 908 }
 909
 910 /*
 911   Adapted from ohci-hub.c. Currently we don't support autosuspend.
 912 */
 913 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 914 {
 915         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 916         int ports, i, changed = 0;
 917         unsigned long flags;
 918
 919         if (!HC_IS_RUNNING(hcd->state))
 920                 return -ESHUTDOWN;
 921
 922         /* Report no status change now, if we are scheduled to be
 923            called later */
 924         if (timer_pending(&hcd->rh_timer))
 925                 return 0;
 926
 927         ports = isp116x->rhdesca & RH_A_NDP;
 928         spin_lock_irqsave(&isp116x->lock, flags);
 929         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
 930         if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
 931                 buf[0] = changed = 1;
 932         else
 933                 buf[0] = 0;
 934
 935         for (i = 0; i < ports; i++) {
 936                 u32 status = isp116x->rhport[i] =
 937                     isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
 938
 939                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
 940                               | RH_PS_OCIC | RH_PS_PRSC)) {
 941                         changed = 1;
 942                         buf[0] |= 1 << (i + 1);
 943                         continue;
 944                 }
 945         }
 946         spin_unlock_irqrestore(&isp116x->lock, flags);
 947         return changed;
 948 }
 949
 950 static void isp116x_hub_descriptor(struct isp116x *isp116x,
 951                                    struct usb_hub_descriptor *desc)
 952 {
 953         u32 reg = isp116x->rhdesca;
 954
 955         desc->bDescriptorType = 0x29;
 956         desc->bDescLength = 9;
 957         desc->bHubContrCurrent = 0;
 958         desc->bNbrPorts = (u8) (reg & 0x3);
 959         /* Power switching, device type, overcurrent. */
 960         desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
 961         desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
 962         /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
 963         desc->bitmap[0] = 0;
 964         desc->bitmap[1] = ~0;
 965 }
 966
 967 /* Perform reset of a given port.
 968    It would be great to just start the reset and let the
 969    USB core to clear the reset in due time. However,
 970    root hub ports should be reset for at least 50 ms, while
 971    our chip stays in reset for about 10 ms. I.e., we must
 972    repeatedly reset it ourself here.
 973 */
 974 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
 975 {
 976         u32 tmp;
 977         unsigned long flags, t;
 978
 979         /* Root hub reset should be 50 ms, but some devices
 980            want it even longer. */
 981         t = jiffies + msecs_to_jiffies(100);
 982
 983         while (time_before(jiffies, t)) {
 984                 spin_lock_irqsave(&isp116x->lock, flags);
 985                 /* spin until any current reset finishes */
 986                 for (;;) {
 987                         tmp = isp116x_read_reg32(isp116x, port ?
 988                                                  HCRHPORT2 : HCRHPORT1);
 989                         if (!(tmp & RH_PS_PRS))
 990                                 break;
 991                         udelay(500);
 992                 }
 993                 /* Don't reset a disconnected port */
 994                 if (!(tmp & RH_PS_CCS)) {
 995                         spin_unlock_irqrestore(&isp116x->lock, flags);
 996                         break;
 997                 }
 998                 /* Reset lasts 10ms (claims datasheet) */
 999                 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
1000                                     HCRHPORT1, (RH_PS_PRS));
1001                 spin_unlock_irqrestore(&isp116x->lock, flags);
1002                 msleep(10);
1003         }
1004 }
1005
1006 /* Adapted from ohci-hub.c */
1007 static int isp116x_hub_control(struct usb_hcd *hcd,
1008                                u16 typeReq,
1009                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
1010 {
1011         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1012         int ret = 0;
1013         unsigned long flags;
1014         int ports = isp116x->rhdesca & RH_A_NDP;
1015         u32 tmp = 0;
1016
1017         switch (typeReq) {
1018         case ClearHubFeature:
1019                 DBG("ClearHubFeature: ");
1020                 switch (wValue) {
1021                 case C_HUB_OVER_CURRENT:
1022                         DBG("C_HUB_OVER_CURRENT\n");
1023                         spin_lock_irqsave(&isp116x->lock, flags);
1024                         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1025                         spin_unlock_irqrestore(&isp116x->lock, flags);
1026                 case C_HUB_LOCAL_POWER:
1027                         DBG("C_HUB_LOCAL_POWER\n");
1028                         break;
1029                 default:
1030                         goto error;
1031                 }
1032                 break;
1033         case SetHubFeature:
1034                 DBG("SetHubFeature: ");
1035                 switch (wValue) {
1036                 case C_HUB_OVER_CURRENT:
1037                 case C_HUB_LOCAL_POWER:
1038                         DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1039                         break;
1040                 default:
1041                         goto error;
1042                 }
1043                 break;
1044         case GetHubDescriptor:
1045                 DBG("GetHubDescriptor\n");
1046                 isp116x_hub_descriptor(isp116x,
1047                                        (struct usb_hub_descriptor *)buf);
1048                 break;
1049         case GetHubStatus:
1050                 DBG("GetHubStatus\n");
1051                 *(__le32 *) buf = 0;
1052                 break;
1053         case GetPortStatus:
1054                 DBG("GetPortStatus\n");
1055                 if (!wIndex || wIndex > ports)
1056                         goto error;
1057                 tmp = isp116x->rhport[--wIndex];
1058                 *(__le32 *) buf = cpu_to_le32(tmp);
1059                 DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1060                 break;
1061         case ClearPortFeature:
1062                 DBG("ClearPortFeature: ");
1063                 if (!wIndex || wIndex > ports)
1064                         goto error;
1065                 wIndex--;
1066
1067                 switch (wValue) {
1068                 case USB_PORT_FEAT_ENABLE:
1069                         DBG("USB_PORT_FEAT_ENABLE\n");
1070                         tmp = RH_PS_CCS;
1071                         break;
1072                 case USB_PORT_FEAT_C_ENABLE:
1073                         DBG("USB_PORT_FEAT_C_ENABLE\n");
1074                         tmp = RH_PS_PESC;
1075                         break;
1076                 case USB_PORT_FEAT_SUSPEND:
1077                         DBG("USB_PORT_FEAT_SUSPEND\n");
1078                         tmp = RH_PS_POCI;
1079                         break;
1080                 case USB_PORT_FEAT_C_SUSPEND:
1081                         DBG("USB_PORT_FEAT_C_SUSPEND\n");
1082                         tmp = RH_PS_PSSC;
1083                         break;
1084                 case USB_PORT_FEAT_POWER:
1085                         DBG("USB_PORT_FEAT_POWER\n");
1086                         tmp = RH_PS_LSDA;
1087                         break;
1088                 case USB_PORT_FEAT_C_CONNECTION:
1089                         DBG("USB_PORT_FEAT_C_CONNECTION\n");
1090                         tmp = RH_PS_CSC;
1091                         break;
1092                 case USB_PORT_FEAT_C_OVER_CURRENT:
1093                         DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1094                         tmp = RH_PS_OCIC;
1095                         break;
1096                 case USB_PORT_FEAT_C_RESET:
1097                         DBG("USB_PORT_FEAT_C_RESET\n");
1098                         tmp = RH_PS_PRSC;
1099                         break;
1100                 default:
1101                         goto error;
1102                 }
1103                 spin_lock_irqsave(&isp116x->lock, flags);
1104                 isp116x_write_reg32(isp116x, wIndex
1105                                     ? HCRHPORT2 : HCRHPORT1, tmp);
1106                 isp116x->rhport[wIndex] =
1107                     isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1108                 spin_unlock_irqrestore(&isp116x->lock, flags);
1109                 break;
1110         case SetPortFeature:
1111                 DBG("SetPortFeature: ");
1112                 if (!wIndex || wIndex > ports)
1113                         goto error;
1114                 wIndex--;
1115                 switch (wValue) {
1116                 case USB_PORT_FEAT_SUSPEND:
1117                         DBG("USB_PORT_FEAT_SUSPEND\n");
1118                         spin_lock_irqsave(&isp116x->lock, flags);
1119                         isp116x_write_reg32(isp116x, wIndex
1120                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1121                         break;
1122                 case USB_PORT_FEAT_POWER:
1123                         DBG("USB_PORT_FEAT_POWER\n");
1124                         spin_lock_irqsave(&isp116x->lock, flags);
1125                         isp116x_write_reg32(isp116x, wIndex
1126                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1127                         break;
1128                 case USB_PORT_FEAT_RESET:
1129                         DBG("USB_PORT_FEAT_RESET\n");
1130                         root_port_reset(isp116x, wIndex);
1131                         spin_lock_irqsave(&isp116x->lock, flags);
1132                         break;
1133                 default:
1134                         goto error;
1135                 }
1136                 isp116x->rhport[wIndex] =
1137                     isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1138                 spin_unlock_irqrestore(&isp116x->lock, flags);
1139                 break;
1140
1141         default:
1142               error:
1143                 /* "protocol stall" on error */
1144                 DBG("PROTOCOL STALL\n");
1145                 ret = -EPIPE;
1146         }
1147         return ret;
1148 }
1149
1150 /*-----------------------------------------------------------------*/
1151
1152 #ifdef CONFIG_DEBUG_FS
1153
1154 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1155 {
1156         seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1157                    mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1158                    mask & HCuPINT_SUSP ? " susp" : "",
1159                    mask & HCuPINT_OPR ? " opr" : "",
1160                    mask & HCuPINT_AIIEOT ? " eot" : "",
1161                    mask & HCuPINT_ATL ? " atl" : "",
1162                    mask & HCuPINT_SOF ? " sof" : "");
1163 }
1164
1165 static void dump_int(struct seq_file *s, char *label, u32 mask)
1166 {
1167         seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1168                    mask & HCINT_MIE ? " MIE" : "",
1169                    mask & HCINT_RHSC ? " rhsc" : "",
1170                    mask & HCINT_FNO ? " fno" : "",
1171                    mask & HCINT_UE ? " ue" : "",
1172                    mask & HCINT_RD ? " rd" : "",
1173                    mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1174 }
1175
1176 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1177 {
1178         struct isp116x *isp116x = s->private;
1179
1180         seq_printf(s, "%s\n%s version %s\n",
1181                    isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1182                    DRIVER_VERSION);
1183
1184         if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1185                 seq_printf(s, "HCD is suspended\n");
1186                 return 0;
1187         }
1188         if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1189                 seq_printf(s, "HCD not running\n");
1190                 return 0;
1191         }
1192
1193         spin_lock_irq(&isp116x->lock);
1194         dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1195         dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1196         dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1197         dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1198         isp116x_show_regs_seq(isp116x, s);
1199         spin_unlock_irq(&isp116x->lock);
1200         seq_printf(s, "\n");
1201
1202         return 0;
1203 }
1204
1205 static int isp116x_open_seq(struct inode *inode, struct file *file)
1206 {
1207         return single_open(file, isp116x_show_dbg, inode->u.generic_ip);
1208 }
1209
1210 static struct file_operations isp116x_debug_fops = {
1211         .open = isp116x_open_seq,
1212         .read = seq_read,
1213         .llseek = seq_lseek,
1214         .release = single_release,
1215 };
1216
1217 static int create_debug_file(struct isp116x *isp116x)
1218 {
1219         isp116x->dentry = debugfs_create_file(hcd_name,
1220                                               S_IRUGO, NULL, isp116x,
1221                                               &isp116x_debug_fops);
1222         if (!isp116x->dentry)
1223                 return -ENOMEM;
1224         return 0;
1225 }
1226
1227 static void remove_debug_file(struct isp116x *isp116x)
1228 {
1229         debugfs_remove(isp116x->dentry);
1230 }
1231
1232 #else
1233
1234 #define create_debug_file(d)    0
1235 #define remove_debug_file(d)    do{}while(0)
1236
1237 #endif                          /* CONFIG_DEBUG_FS */
1238
1239 /*-----------------------------------------------------------------*/
1240
1241 /*
1242   Software reset - can be called from any contect.
1243 */
1244 static int isp116x_sw_reset(struct isp116x *isp116x)
1245 {
1246         int retries = 15;
1247         unsigned long flags;
1248         int ret = 0;
1249
1250         spin_lock_irqsave(&isp116x->lock, flags);
1251         isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1252         isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1253         while (--retries) {
1254                 /* It usually resets within 1 ms */
1255                 mdelay(1);
1256                 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1257                         break;
1258         }
1259         if (!retries) {
1260                 ERR("Software reset timeout\n");
1261                 ret = -ETIME;
1262         }
1263         spin_unlock_irqrestore(&isp116x->lock, flags);
1264         return ret;
1265 }
1266
1267 static int isp116x_reset(struct usb_hcd *hcd)
1268 {
1269         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1270         unsigned long t;
1271         u16 clkrdy = 0;
1272         int ret, timeout = 15 /* ms */ ;
1273
1274         ret = isp116x_sw_reset(isp116x);
1275         if (ret)
1276                 return ret;
1277
1278         t = jiffies + msecs_to_jiffies(timeout);
1279         while (time_before_eq(jiffies, t)) {
1280                 msleep(4);
1281                 spin_lock_irq(&isp116x->lock);
1282                 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1283                 spin_unlock_irq(&isp116x->lock);
1284                 if (clkrdy)
1285                         break;
1286         }
1287         if (!clkrdy) {
1288                 ERR("Clock not ready after %dms\n", timeout);
1289                 /* After sw_reset the clock won't report to be ready, if
1290                    H_WAKEUP pin is high. */
1291                 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1292                 ret = -ENODEV;
1293         }
1294         return ret;
1295 }
1296
1297 static void isp116x_stop(struct usb_hcd *hcd)
1298 {
1299         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1300         unsigned long flags;
1301         u32 val;
1302
1303         spin_lock_irqsave(&isp116x->lock, flags);
1304         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1305
1306         /* Switch off ports' power, some devices don't come up
1307            after next 'insmod' without this */
1308         val = isp116x_read_reg32(isp116x, HCRHDESCA);
1309         val &= ~(RH_A_NPS | RH_A_PSM);
1310         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1311         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1312         spin_unlock_irqrestore(&isp116x->lock, flags);
1313
1314         isp116x_sw_reset(isp116x);
1315 }
1316
1317 /*
1318   Configure the chip. The chip must be successfully reset by now.
1319 */
1320 static int isp116x_start(struct usb_hcd *hcd)
1321 {
1322         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1323         struct isp116x_platform_data *board = isp116x->board;
1324         u32 val;
1325         unsigned long flags;
1326
1327         spin_lock_irqsave(&isp116x->lock, flags);
1328
1329         /* clear interrupt status and disable all interrupt sources */
1330         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1331         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1332
1333         val = isp116x_read_reg16(isp116x, HCCHIPID);
1334         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1335                 ERR("Invalid chip ID %04x\n", val);
1336                 spin_unlock_irqrestore(&isp116x->lock, flags);
1337                 return -ENODEV;
1338         }
1339
1340         /* To be removed in future */
1341         hcd->uses_new_polling = 1;
1342
1343         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1344         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1345
1346         /* ----- HW conf */
1347         val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1348         if (board->sel15Kres)
1349                 val |= HCHWCFG_15KRSEL;
1350         /* Remote wakeup won't work without working clock */
1351         if (board->remote_wakeup_enable)
1352                 val |= HCHWCFG_CLKNOTSTOP;
1353         if (board->oc_enable)
1354                 val |= HCHWCFG_ANALOG_OC;
1355         if (board->int_act_high)
1356                 val |= HCHWCFG_INT_POL;
1357         if (board->int_edge_triggered)
1358                 val |= HCHWCFG_INT_TRIGGER;
1359         isp116x_write_reg16(isp116x, HCHWCFG, val);
1360
1361         /* ----- Root hub conf */
1362         val = (25 << 24) & RH_A_POTPGT;
1363         /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1364            be always set. Yet, instead, we request individual port
1365            power switching. */
1366         val |= RH_A_PSM;
1367         /* Report overcurrent per port */
1368         val |= RH_A_OCPM;
1369         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1370         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1371
1372         val = RH_B_PPCM;
1373         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1374         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1375
1376         val = 0;
1377         if (board->remote_wakeup_enable) {
1378                 if (!device_can_wakeup(hcd->self.controller))
1379                         device_init_wakeup(hcd->self.controller, 1);
1380                 val |= RH_HS_DRWE;
1381         }
1382         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1383         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1384
1385         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1386
1387         hcd->state = HC_STATE_RUNNING;
1388
1389         /* Set up interrupts */
1390         isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1391         if (board->remote_wakeup_enable)
1392                 isp116x->intenb |= HCINT_RD;
1393         isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1394         isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1395         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1396
1397         /* Go operational */
1398         val = HCCONTROL_USB_OPER;
1399         if (board->remote_wakeup_enable)
1400                 val |= HCCONTROL_RWE;
1401         isp116x_write_reg32(isp116x, HCCONTROL, val);
1402
1403         /* Disable ports to avoid race in device enumeration */
1404         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1405         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1406
1407         isp116x_show_regs_log(isp116x);
1408         spin_unlock_irqrestore(&isp116x->lock, flags);
1409         return 0;
1410 }
1411
1412 #ifdef  CONFIG_PM
1413
1414 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1415 {
1416         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1417         unsigned long flags;
1418         u32 val;
1419         int ret = 0;
1420
1421         spin_lock_irqsave(&isp116x->lock, flags);
1422         val = isp116x_read_reg32(isp116x, HCCONTROL);
1423
1424         switch (val & HCCONTROL_HCFS) {
1425         case HCCONTROL_USB_OPER:
1426                 spin_unlock_irqrestore(&isp116x->lock, flags);
1427                 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1428                 val |= HCCONTROL_USB_SUSPEND;
1429                 if (device_may_wakeup(&hcd->self.root_hub->dev))
1430                         val |= HCCONTROL_RWE;
1431                 /* Wait for usb transfers to finish */
1432                 msleep(2);
1433                 spin_lock_irqsave(&isp116x->lock, flags);
1434                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1435                 spin_unlock_irqrestore(&isp116x->lock, flags);
1436                 /* Wait for devices to suspend */
1437                 msleep(5);
1438                 break;
1439         case HCCONTROL_USB_RESUME:
1440                 isp116x_write_reg32(isp116x, HCCONTROL,
1441                                     (val & ~HCCONTROL_HCFS) |
1442                                     HCCONTROL_USB_RESET);
1443         case HCCONTROL_USB_RESET:
1444                 ret = -EBUSY;
1445         default:                /* HCCONTROL_USB_SUSPEND */
1446                 spin_unlock_irqrestore(&isp116x->lock, flags);
1447                 break;
1448         }
1449
1450         return ret;
1451 }
1452
1453 static int isp116x_bus_resume(struct usb_hcd *hcd)
1454 {
1455         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1456         u32 val;
1457
1458         msleep(5);
1459         spin_lock_irq(&isp116x->lock);
1460
1461         val = isp116x_read_reg32(isp116x, HCCONTROL);
1462         switch (val & HCCONTROL_HCFS) {
1463         case HCCONTROL_USB_SUSPEND:
1464                 val &= ~HCCONTROL_HCFS;
1465                 val |= HCCONTROL_USB_RESUME;
1466                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1467         case HCCONTROL_USB_RESUME:
1468                 break;
1469         case HCCONTROL_USB_OPER:
1470                 spin_unlock_irq(&isp116x->lock);
1471                 /* Without setting power_state here the
1472                    SUSPENDED state won't be removed from
1473                    sysfs/usbN/power.state as a response to remote
1474                    wakeup. Maybe in the future. */
1475                 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1476                 return 0;
1477         default:
1478                 /* HCCONTROL_USB_RESET: this may happen, when during
1479                    suspension the HC lost power. Reinitialize completely */
1480                 spin_unlock_irq(&isp116x->lock);
1481                 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1482                 isp116x_reset(hcd);
1483                 isp116x_start(hcd);
1484                 isp116x_hub_control(hcd, SetPortFeature,
1485                                     USB_PORT_FEAT_POWER, 1, NULL, 0);
1486                 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1487                         isp116x_hub_control(hcd, SetPortFeature,
1488                                             USB_PORT_FEAT_POWER, 2, NULL, 0);
1489                 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1490                 return 0;
1491         }
1492
1493         val = isp116x->rhdesca & RH_A_NDP;
1494         while (val--) {
1495                 u32 stat =
1496                     isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1497                 /* force global, not selective, resume */
1498                 if (!(stat & RH_PS_PSS))
1499                         continue;
1500                 DBG("%s: Resuming port %d\n", __func__, val);
1501                 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1502                                     ? HCRHPORT2 : HCRHPORT1);
1503         }
1504         spin_unlock_irq(&isp116x->lock);
1505
1506         hcd->state = HC_STATE_RESUMING;
1507         msleep(20);
1508
1509         /* Go operational */
1510         spin_lock_irq(&isp116x->lock);
1511         val = isp116x_read_reg32(isp116x, HCCONTROL);
1512         isp116x_write_reg32(isp116x, HCCONTROL,
1513                             (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1514         spin_unlock_irq(&isp116x->lock);
1515         /* see analogous comment above */
1516         hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1517         hcd->state = HC_STATE_RUNNING;
1518
1519         return 0;
1520 }
1521
1522 #else
1523
1524 #define isp116x_bus_suspend     NULL
1525 #define isp116x_bus_resume      NULL
1526
1527 #endif
1528
1529 static struct hc_driver isp116x_hc_driver = {
1530         .description = hcd_name,
1531         .product_desc = "ISP116x Host Controller",
1532         .hcd_priv_size = sizeof(struct isp116x),
1533
1534         .irq = isp116x_irq,
1535         .flags = HCD_USB11,
1536
1537         .reset = isp116x_reset,
1538         .start = isp116x_start,
1539         .stop = isp116x_stop,
1540
1541         .urb_enqueue = isp116x_urb_enqueue,
1542         .urb_dequeue = isp116x_urb_dequeue,
1543         .endpoint_disable = isp116x_endpoint_disable,
1544
1545         .get_frame_number = isp116x_get_frame,
1546
1547         .hub_status_data = isp116x_hub_status_data,
1548         .hub_control = isp116x_hub_control,
1549         .bus_suspend = isp116x_bus_suspend,
1550         .bus_resume = isp116x_bus_resume,
1551 };
1552
1553 /*----------------------------------------------------------------*/
1554
1555 static int isp116x_remove(struct platform_device *pdev)
1556 {
1557         struct usb_hcd *hcd = platform_get_drvdata(pdev);
1558         struct isp116x *isp116x;
1559         struct resource *res;
1560
1561         if (!hcd)
1562                 return 0;
1563         isp116x = hcd_to_isp116x(hcd);
1564         remove_debug_file(isp116x);
1565         usb_remove_hcd(hcd);
1566
1567         iounmap(isp116x->data_reg);
1568         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1569         release_mem_region(res->start, 2);
1570         iounmap(isp116x->addr_reg);
1571         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1572         release_mem_region(res->start, 2);
1573
1574         usb_put_hcd(hcd);
1575         return 0;
1576 }
1577
1578 #define resource_len(r) (((r)->end - (r)->start) + 1)
1579
1580 static int __init isp116x_probe(struct platform_device *pdev)
1581 {
1582         struct usb_hcd *hcd;
1583         struct isp116x *isp116x;
1584         struct resource *addr, *data;
1585         void __iomem *addr_reg;
1586         void __iomem *data_reg;
1587         int irq;
1588         int ret = 0;
1589
1590         if (pdev->num_resources < 3) {
1591                 ret = -ENODEV;
1592                 goto err1;
1593         }
1594
1595         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1596         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1597         irq = platform_get_irq(pdev, 0);
1598         if (!addr || !data || irq < 0) {
1599                 ret = -ENODEV;
1600                 goto err1;
1601         }
1602
1603         if (pdev->dev.dma_mask) {
1604                 DBG("DMA not supported\n");
1605                 ret = -EINVAL;
1606                 goto err1;
1607         }
1608
1609         if (!request_mem_region(addr->start, 2, hcd_name)) {
1610                 ret = -EBUSY;
1611                 goto err1;
1612         }
1613         addr_reg = ioremap(addr->start, resource_len(addr));
1614         if (addr_reg == NULL) {
1615                 ret = -ENOMEM;
1616                 goto err2;
1617         }
1618         if (!request_mem_region(data->start, 2, hcd_name)) {
1619                 ret = -EBUSY;
1620                 goto err3;
1621         }
1622         data_reg = ioremap(data->start, resource_len(data));
1623         if (data_reg == NULL) {
1624                 ret = -ENOMEM;
1625                 goto err4;
1626         }
1627
1628         /* allocate and initialize hcd */
1629         hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1630         if (!hcd) {
1631                 ret = -ENOMEM;
1632                 goto err5;
1633         }
1634         /* this rsrc_start is bogus */
1635         hcd->rsrc_start = addr->start;
1636         isp116x = hcd_to_isp116x(hcd);
1637         isp116x->data_reg = data_reg;
1638         isp116x->addr_reg = addr_reg;
1639         spin_lock_init(&isp116x->lock);
1640         INIT_LIST_HEAD(&isp116x->async);
1641         isp116x->board = pdev->dev.platform_data;
1642
1643         if (!isp116x->board) {
1644                 ERR("Platform data structure not initialized\n");
1645                 ret = -ENODEV;
1646                 goto err6;
1647         }
1648         if (isp116x_check_platform_delay(isp116x)) {
1649                 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1650                     "implemented.\n");
1651                 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1652                 ret = -ENODEV;
1653                 goto err6;
1654         }
1655
1656         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1657         if (ret)
1658                 goto err6;
1659
1660         ret = create_debug_file(isp116x);
1661         if (ret) {
1662                 ERR("Couldn't create debugfs entry\n");
1663                 goto err7;
1664         }
1665
1666         return 0;
1667
1668       err7:
1669         usb_remove_hcd(hcd);
1670       err6:
1671         usb_put_hcd(hcd);
1672       err5:
1673         iounmap(data_reg);
1674       err4:
1675         release_mem_region(data->start, 2);
1676       err3:
1677         iounmap(addr_reg);
1678       err2:
1679         release_mem_region(addr->start, 2);
1680       err1:
1681         ERR("init error, %d\n", ret);
1682         return ret;
1683 }
1684
1685 #ifdef  CONFIG_PM
1686 /*
1687   Suspend of platform device
1688 */
1689 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1690 {
1691         VDBG("%s: state %x\n", __func__, state.event);
1692         dev->dev.power.power_state = state;
1693         return 0;
1694 }
1695
1696 /*
1697   Resume platform device
1698 */
1699 static int isp116x_resume(struct platform_device *dev)
1700 {
1701         VDBG("%s:  state %x\n", __func__, dev->power.power_state.event);
1702         dev->dev.power.power_state = PMSG_ON;
1703         return 0;
1704 }
1705
1706 #else
1707
1708 #define isp116x_suspend    NULL
1709 #define isp116x_resume     NULL
1710
1711 #endif
1712
1713 static struct platform_driver isp116x_driver = {
1714         .probe = isp116x_probe,
1715         .remove = isp116x_remove,
1716         .suspend = isp116x_suspend,
1717         .resume = isp116x_resume,
1718         .driver = {
1719                    .name = (char *)hcd_name,
1720                    },
1721 };
1722
1723 /*-----------------------------------------------------------------*/
1724
1725 static int __init isp116x_init(void)
1726 {
1727         if (usb_disabled())
1728                 return -ENODEV;
1729
1730         INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1731         return platform_driver_register(&isp116x_driver);
1732 }
1733
1734 module_init(isp116x_init);
1735
1736 static void __exit isp116x_cleanup(void)
1737 {
1738         platform_driver_unregister(&isp116x_driver);
1739 }
1740
1741 module_exit(isp116x_cleanup);