err.no 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         u32 val;
1551         unsigned long flags;
1552
1553         spin_lock_irqsave(&isp116x->lock, flags);
1554
1555         /* clear interrupt status and disable all interrupt sources */
1556         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1557         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1558
1559         val = isp116x_read_reg16(isp116x, HCCHIPID);
1560         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1561                 ERR("Invalid chip ID %04x\n", val);
1562                 spin_unlock_irqrestore(&isp116x->lock, flags);
1563                 return -ENODEV;
1564         }
1565
1566         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1567         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1568
1569         /* ----- HW conf */
1570         val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1571         if (board->sel15Kres)
1572                 val |= HCHWCFG_15KRSEL;
1573         /* Remote wakeup won't work without working clock */
1574         if (board->clknotstop || board->remote_wakeup_enable)
1575                 val |= HCHWCFG_CLKNOTSTOP;
1576         if (board->oc_enable)
1577                 val |= HCHWCFG_ANALOG_OC;
1578         if (board->int_act_high)
1579                 val |= HCHWCFG_INT_POL;
1580         if (board->int_edge_triggered)
1581                 val |= HCHWCFG_INT_TRIGGER;
1582         isp116x_write_reg16(isp116x, HCHWCFG, val);
1583
1584         /* ----- Root hub conf */
1585         val = 0;
1586         /* AN10003_1.pdf recommends NPS to be always 1 */
1587         if (board->no_power_switching)
1588                 val |= RH_A_NPS;
1589         if (board->power_switching_mode)
1590                 val |= RH_A_PSM;
1591         if (board->potpg)
1592                 val |= (board->potpg << 24) & RH_A_POTPGT;
1593         else
1594                 val |= (25 << 24) & RH_A_POTPGT;
1595         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1596         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1597
1598         val = RH_B_PPCM;
1599         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1600         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1601
1602         val = 0;
1603         if (board->remote_wakeup_enable) {
1604                 hcd->can_wakeup = 1;
1605                 val |= RH_HS_DRWE;
1606         }
1607         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1608         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1609
1610         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1611
1612         hcd->state = HC_STATE_RUNNING;
1613
1614         /* Set up interrupts */
1615         isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1616         if (board->remote_wakeup_enable)
1617                 isp116x->intenb |= HCINT_RD;
1618         isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1619         isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1620         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1621
1622         /* Go operational */
1623         val = HCCONTROL_USB_OPER;
1624         /* Remote wakeup connected - NOT SUPPORTED */
1625         /*  if (board->remote_wakeup_connected)
1626            val |= HCCONTROL_RWC;  */
1627         if (board->remote_wakeup_enable)
1628                 val |= HCCONTROL_RWE;
1629         isp116x_write_reg32(isp116x, HCCONTROL, val);
1630
1631         /* Disable ports to avoid race in device enumeration */
1632         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1633         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1634
1635         isp116x_show_regs(isp116x);
1636         spin_unlock_irqrestore(&isp116x->lock, flags);
1637         return 0;
1638 }
1639
1640 /*-----------------------------------------------------------------*/
1641
1642 static struct hc_driver isp116x_hc_driver = {
1643         .description = hcd_name,
1644         .product_desc = "ISP116x Host Controller",
1645         .hcd_priv_size = sizeof(struct isp116x),
1646
1647         .irq = isp116x_irq,
1648         .flags = HCD_USB11,
1649
1650         .reset = isp116x_reset,
1651         .start = isp116x_start,
1652         .stop = isp116x_stop,
1653
1654         .urb_enqueue = isp116x_urb_enqueue,
1655         .urb_dequeue = isp116x_urb_dequeue,
1656         .endpoint_disable = isp116x_endpoint_disable,
1657
1658         .get_frame_number = isp116x_get_frame,
1659
1660         .hub_status_data = isp116x_hub_status_data,
1661         .hub_control = isp116x_hub_control,
1662         .hub_suspend = isp116x_hub_suspend,
1663         .hub_resume = isp116x_hub_resume,
1664 };
1665
1666 /*----------------------------------------------------------------*/
1667
1668 static int __init_or_module isp116x_remove(struct device *dev)
1669 {
1670         struct usb_hcd *hcd = dev_get_drvdata(dev);
1671         struct isp116x *isp116x;
1672         struct platform_device *pdev;
1673         struct resource *res;
1674
1675         if(!hcd)
1676                 return 0;
1677         isp116x = hcd_to_isp116x(hcd);
1678         pdev = container_of(dev, struct platform_device, dev);
1679         remove_debug_file(isp116x);
1680         usb_remove_hcd(hcd);
1681
1682         iounmap(isp116x->data_reg);
1683         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1684         release_mem_region(res->start, 2);
1685         iounmap(isp116x->addr_reg);
1686         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1687         release_mem_region(res->start, 2);
1688
1689         usb_put_hcd(hcd);
1690         return 0;
1691 }
1692
1693 #define resource_len(r) (((r)->end - (r)->start) + 1)
1694
1695 static int __init isp116x_probe(struct device *dev)
1696 {
1697         struct usb_hcd *hcd;
1698         struct isp116x *isp116x;
1699         struct platform_device *pdev;
1700         struct resource *addr, *data;
1701         void __iomem *addr_reg;
1702         void __iomem *data_reg;
1703         int irq;
1704         int ret = 0;
1705
1706         pdev = container_of(dev, struct platform_device, dev);
1707         if (pdev->num_resources < 3) {
1708                 ret = -ENODEV;
1709                 goto err1;
1710         }
1711
1712         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1713         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1714         irq = platform_get_irq(pdev, 0);
1715         if (!addr || !data || irq < 0) {
1716                 ret = -ENODEV;
1717                 goto err1;
1718         }
1719
1720         if (dev->dma_mask) {
1721                 DBG("DMA not supported\n");
1722                 ret = -EINVAL;
1723                 goto err1;
1724         }
1725
1726         if (!request_mem_region(addr->start, 2, hcd_name)) {
1727                 ret = -EBUSY;
1728                 goto err1;
1729         }
1730         addr_reg = ioremap(addr->start, resource_len(addr));
1731         if (addr_reg == NULL) {
1732                 ret = -ENOMEM;
1733                 goto err2;
1734         }
1735         if (!request_mem_region(data->start, 2, hcd_name)) {
1736                 ret = -EBUSY;
1737                 goto err3;
1738         }
1739         data_reg = ioremap(data->start, resource_len(data));
1740         if (data_reg == NULL) {
1741                 ret = -ENOMEM;
1742                 goto err4;
1743         }
1744
1745         /* allocate and initialize hcd */
1746         hcd = usb_create_hcd(&isp116x_hc_driver, dev, dev->bus_id);
1747         if (!hcd) {
1748                 ret = -ENOMEM;
1749                 goto err5;
1750         }
1751         /* this rsrc_start is bogus */
1752         hcd->rsrc_start = addr->start;
1753         isp116x = hcd_to_isp116x(hcd);
1754         isp116x->data_reg = data_reg;
1755         isp116x->addr_reg = addr_reg;
1756         spin_lock_init(&isp116x->lock);
1757         INIT_LIST_HEAD(&isp116x->async);
1758         INIT_WORK(&isp116x->rh_resume, isp116x_rh_resume, hcd);
1759         isp116x->board = dev->platform_data;
1760
1761         if (!isp116x->board) {
1762                 ERR("Platform data structure not initialized\n");
1763                 ret = -ENODEV;
1764                 goto err6;
1765         }
1766         if (isp116x_check_platform_delay(isp116x)) {
1767                 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1768                     "implemented.\n");
1769                 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1770                 ret = -ENODEV;
1771                 goto err6;
1772         }
1773
1774         ret = usb_add_hcd(hcd, irq, SA_INTERRUPT);
1775         if (ret != 0)
1776                 goto err6;
1777
1778         create_debug_file(isp116x);
1779         return 0;
1780
1781       err6:
1782         usb_put_hcd(hcd);
1783       err5:
1784         iounmap(data_reg);
1785       err4:
1786         release_mem_region(data->start, 2);
1787       err3:
1788         iounmap(addr_reg);
1789       err2:
1790         release_mem_region(addr->start, 2);
1791       err1:
1792         ERR("init error, %d\n", ret);
1793         return ret;
1794 }
1795
1796 #ifdef  CONFIG_PM
1797 /*
1798   Suspend of platform device
1799 */
1800 static int isp116x_suspend(struct device *dev, pm_message_t state, u32 phase)
1801 {
1802         int ret = 0;
1803         struct usb_hcd *hcd = dev_get_drvdata(dev);
1804
1805         VDBG("%s: state %x, phase %x\n", __func__, state, phase);
1806
1807         if (phase != SUSPEND_DISABLE && phase != SUSPEND_POWER_DOWN)
1808                 return 0;
1809
1810         ret = usb_suspend_device(hcd->self.root_hub, state);
1811         if (!ret) {
1812                 dev->power.power_state = state;
1813                 INFO("%s suspended\n", (char *)hcd_name);
1814         } else
1815                 ERR("%s suspend failed\n", (char *)hcd_name);
1816
1817         return ret;
1818 }
1819
1820 /*
1821   Resume platform device
1822 */
1823 static int isp116x_resume(struct device *dev, u32 phase)
1824 {
1825         int ret = 0;
1826         struct usb_hcd *hcd = dev_get_drvdata(dev);
1827
1828         VDBG("%s:  state %x, phase %x\n", __func__, dev->power.power_state,
1829              phase);
1830         if (phase != RESUME_POWER_ON)
1831                 return 0;
1832
1833         ret = usb_resume_device(hcd->self.root_hub);
1834         if (!ret) {
1835                 dev->power.power_state = PMSG_ON;
1836                 VDBG("%s resumed\n", (char *)hcd_name);
1837         }
1838         return ret;
1839 }
1840
1841 #else
1842
1843 #define isp116x_suspend    NULL
1844 #define isp116x_resume     NULL
1845
1846 #endif
1847
1848 static struct device_driver isp116x_driver = {
1849         .name = (char *)hcd_name,
1850         .bus = &platform_bus_type,
1851         .probe = isp116x_probe,
1852         .remove = isp116x_remove,
1853         .suspend = isp116x_suspend,
1854         .resume = isp116x_resume,
1855 };
1856
1857 /*-----------------------------------------------------------------*/
1858
1859 static int __init isp116x_init(void)
1860 {
1861         if (usb_disabled())
1862                 return -ENODEV;
1863
1864         INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1865         return driver_register(&isp116x_driver);
1866 }
1867
1868 module_init(isp116x_init);
1869
1870 static void __exit isp116x_cleanup(void)
1871 {
1872         driver_unregister(&isp116x_driver);
1873 }
1874
1875 module_exit(isp116x_cleanup);