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