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