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