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