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