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                 }
 922         }
 923         spin_unlock_irqrestore(&isp116x->lock, flags);
 924         return changed;
 925 }
 926
 927 static void isp116x_hub_descriptor(struct isp116x *isp116x,
 928                                    struct usb_hub_descriptor *desc)
 929 {
 930         u32 reg = isp116x->rhdesca;
 931
 932         desc->bDescriptorType = 0x29;
 933         desc->bDescLength = 9;
 934         desc->bHubContrCurrent = 0;
 935         desc->bNbrPorts = (u8) (reg & 0x3);
 936         /* Power switching, device type, overcurrent. */
 937         desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
 938         desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
 939         /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
 940         desc->bitmap[0] = 0;
 941         desc->bitmap[1] = ~0;
 942 }
 943
 944 /* Perform reset of a given port.
 945    It would be great to just start the reset and let the
 946    USB core to clear the reset in due time. However,
 947    root hub ports should be reset for at least 50 ms, while
 948    our chip stays in reset for about 10 ms. I.e., we must
 949    repeatedly reset it ourself here.
 950 */
 951 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
 952 {
 953         u32 tmp;
 954         unsigned long flags, t;
 955
 956         /* Root hub reset should be 50 ms, but some devices
 957            want it even longer. */
 958         t = jiffies + msecs_to_jiffies(100);
 959
 960         while (time_before(jiffies, t)) {
 961                 spin_lock_irqsave(&isp116x->lock, flags);
 962                 /* spin until any current reset finishes */
 963                 for (;;) {
 964                         tmp = isp116x_read_reg32(isp116x, port ?
 965                                                  HCRHPORT2 : HCRHPORT1);
 966                         if (!(tmp & RH_PS_PRS))
 967                                 break;
 968                         udelay(500);
 969                 }
 970                 /* Don't reset a disconnected port */
 971                 if (!(tmp & RH_PS_CCS)) {
 972                         spin_unlock_irqrestore(&isp116x->lock, flags);
 973                         break;
 974                 }
 975                 /* Reset lasts 10ms (claims datasheet) */
 976                 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
 977                                     HCRHPORT1, (RH_PS_PRS));
 978                 spin_unlock_irqrestore(&isp116x->lock, flags);
 979                 msleep(10);
 980         }
 981 }
 982
 983 /* Adapted from ohci-hub.c */
 984 static int isp116x_hub_control(struct usb_hcd *hcd,
 985                                u16 typeReq,
 986                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
 987 {
 988         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 989         int ret = 0;
 990         unsigned long flags;
 991         int ports = isp116x->rhdesca & RH_A_NDP;
 992         u32 tmp = 0;
 993
 994         switch (typeReq) {
 995         case ClearHubFeature:
 996                 DBG("ClearHubFeature: ");
 997                 switch (wValue) {
 998                 case C_HUB_OVER_CURRENT:
 999                         DBG("C_HUB_OVER_CURRENT\n");
1000                         spin_lock_irqsave(&isp116x->lock, flags);
1001                         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1002                         spin_unlock_irqrestore(&isp116x->lock, flags);
1003                 case C_HUB_LOCAL_POWER:
1004                         DBG("C_HUB_LOCAL_POWER\n");
1005                         break;
1006                 default:
1007                         goto error;
1008                 }
1009                 break;
1010         case SetHubFeature:
1011                 DBG("SetHubFeature: ");
1012                 switch (wValue) {
1013                 case C_HUB_OVER_CURRENT:
1014                 case C_HUB_LOCAL_POWER:
1015                         DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1016                         break;
1017                 default:
1018                         goto error;
1019                 }
1020                 break;
1021         case GetHubDescriptor:
1022                 DBG("GetHubDescriptor\n");
1023                 isp116x_hub_descriptor(isp116x,
1024                                        (struct usb_hub_descriptor *)buf);
1025                 break;
1026         case GetHubStatus:
1027                 DBG("GetHubStatus\n");
1028                 *(__le32 *) buf = 0;
1029                 break;
1030         case GetPortStatus:
1031                 DBG("GetPortStatus\n");
1032                 if (!wIndex || wIndex > ports)
1033                         goto error;
1034                 tmp = isp116x->rhport[--wIndex];
1035                 *(__le32 *) buf = cpu_to_le32(tmp);
1036                 DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1037                 break;
1038         case ClearPortFeature:
1039                 DBG("ClearPortFeature: ");
1040                 if (!wIndex || wIndex > ports)
1041                         goto error;
1042                 wIndex--;
1043
1044                 switch (wValue) {
1045                 case USB_PORT_FEAT_ENABLE:
1046                         DBG("USB_PORT_FEAT_ENABLE\n");
1047                         tmp = RH_PS_CCS;
1048                         break;
1049                 case USB_PORT_FEAT_C_ENABLE:
1050                         DBG("USB_PORT_FEAT_C_ENABLE\n");
1051                         tmp = RH_PS_PESC;
1052                         break;
1053                 case USB_PORT_FEAT_SUSPEND:
1054                         DBG("USB_PORT_FEAT_SUSPEND\n");
1055                         tmp = RH_PS_POCI;
1056                         break;
1057                 case USB_PORT_FEAT_C_SUSPEND:
1058                         DBG("USB_PORT_FEAT_C_SUSPEND\n");
1059                         tmp = RH_PS_PSSC;
1060                         break;
1061                 case USB_PORT_FEAT_POWER:
1062                         DBG("USB_PORT_FEAT_POWER\n");
1063                         tmp = RH_PS_LSDA;
1064                         break;
1065                 case USB_PORT_FEAT_C_CONNECTION:
1066                         DBG("USB_PORT_FEAT_C_CONNECTION\n");
1067                         tmp = RH_PS_CSC;
1068                         break;
1069                 case USB_PORT_FEAT_C_OVER_CURRENT:
1070                         DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1071                         tmp = RH_PS_OCIC;
1072                         break;
1073                 case USB_PORT_FEAT_C_RESET:
1074                         DBG("USB_PORT_FEAT_C_RESET\n");
1075                         tmp = RH_PS_PRSC;
1076                         break;
1077                 default:
1078                         goto error;
1079                 }
1080                 spin_lock_irqsave(&isp116x->lock, flags);
1081                 isp116x_write_reg32(isp116x, wIndex
1082                                     ? HCRHPORT2 : HCRHPORT1, tmp);
1083                 isp116x->rhport[wIndex] =
1084                     isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1085                 spin_unlock_irqrestore(&isp116x->lock, flags);
1086                 break;
1087         case SetPortFeature:
1088                 DBG("SetPortFeature: ");
1089                 if (!wIndex || wIndex > ports)
1090                         goto error;
1091                 wIndex--;
1092                 switch (wValue) {
1093                 case USB_PORT_FEAT_SUSPEND:
1094                         DBG("USB_PORT_FEAT_SUSPEND\n");
1095                         spin_lock_irqsave(&isp116x->lock, flags);
1096                         isp116x_write_reg32(isp116x, wIndex
1097                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1098                         break;
1099                 case USB_PORT_FEAT_POWER:
1100                         DBG("USB_PORT_FEAT_POWER\n");
1101                         spin_lock_irqsave(&isp116x->lock, flags);
1102                         isp116x_write_reg32(isp116x, wIndex
1103                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1104                         break;
1105                 case USB_PORT_FEAT_RESET:
1106                         DBG("USB_PORT_FEAT_RESET\n");
1107                         root_port_reset(isp116x, wIndex);
1108                         spin_lock_irqsave(&isp116x->lock, flags);
1109                         break;
1110                 default:
1111                         goto error;
1112                 }
1113                 isp116x->rhport[wIndex] =
1114                     isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1);
1115                 spin_unlock_irqrestore(&isp116x->lock, flags);
1116                 break;
1117
1118         default:
1119               error:
1120                 /* "protocol stall" on error */
1121                 DBG("PROTOCOL STALL\n");
1122                 ret = -EPIPE;
1123         }
1124         return ret;
1125 }
1126
1127 /*-----------------------------------------------------------------*/
1128
1129 #ifdef CONFIG_DEBUG_FS
1130
1131 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1132 {
1133         seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1134                    mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1135                    mask & HCuPINT_SUSP ? " susp" : "",
1136                    mask & HCuPINT_OPR ? " opr" : "",
1137                    mask & HCuPINT_AIIEOT ? " eot" : "",
1138                    mask & HCuPINT_ATL ? " atl" : "",
1139                    mask & HCuPINT_SOF ? " sof" : "");
1140 }
1141
1142 static void dump_int(struct seq_file *s, char *label, u32 mask)
1143 {
1144         seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1145                    mask & HCINT_MIE ? " MIE" : "",
1146                    mask & HCINT_RHSC ? " rhsc" : "",
1147                    mask & HCINT_FNO ? " fno" : "",
1148                    mask & HCINT_UE ? " ue" : "",
1149                    mask & HCINT_RD ? " rd" : "",
1150                    mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1151 }
1152
1153 static int isp116x_show_dbg(struct seq_file *s, void *unused)
1154 {
1155         struct isp116x *isp116x = s->private;
1156
1157         seq_printf(s, "%s\n%s version %s\n",
1158                    isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1159                    DRIVER_VERSION);
1160
1161         if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1162                 seq_printf(s, "HCD is suspended\n");
1163                 return 0;
1164         }
1165         if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1166                 seq_printf(s, "HCD not running\n");
1167                 return 0;
1168         }
1169
1170         spin_lock_irq(&isp116x->lock);
1171         dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1172         dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1173         dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1174         dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1175         isp116x_show_regs_seq(isp116x, s);
1176         spin_unlock_irq(&isp116x->lock);
1177         seq_printf(s, "\n");
1178
1179         return 0;
1180 }
1181
1182 static int isp116x_open_seq(struct inode *inode, struct file *file)
1183 {
1184         return single_open(file, isp116x_show_dbg, inode->i_private);
1185 }
1186
1187 static const struct file_operations isp116x_debug_fops = {
1188         .open = isp116x_open_seq,
1189         .read = seq_read,
1190         .llseek = seq_lseek,
1191         .release = single_release,
1192 };
1193
1194 static int create_debug_file(struct isp116x *isp116x)
1195 {
1196         isp116x->dentry = debugfs_create_file(hcd_name,
1197                                               S_IRUGO, NULL, isp116x,
1198                                               &isp116x_debug_fops);
1199         if (!isp116x->dentry)
1200                 return -ENOMEM;
1201         return 0;
1202 }
1203
1204 static void remove_debug_file(struct isp116x *isp116x)
1205 {
1206         debugfs_remove(isp116x->dentry);
1207 }
1208
1209 #else
1210
1211 #define create_debug_file(d)    0
1212 #define remove_debug_file(d)    do{}while(0)
1213
1214 #endif                          /* CONFIG_DEBUG_FS */
1215
1216 /*-----------------------------------------------------------------*/
1217
1218 /*
1219   Software reset - can be called from any contect.
1220 */
1221 static int isp116x_sw_reset(struct isp116x *isp116x)
1222 {
1223         int retries = 15;
1224         unsigned long flags;
1225         int ret = 0;
1226
1227         spin_lock_irqsave(&isp116x->lock, flags);
1228         isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1229         isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1230         while (--retries) {
1231                 /* It usually resets within 1 ms */
1232                 mdelay(1);
1233                 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1234                         break;
1235         }
1236         if (!retries) {
1237                 ERR("Software reset timeout\n");
1238                 ret = -ETIME;
1239         }
1240         spin_unlock_irqrestore(&isp116x->lock, flags);
1241         return ret;
1242 }
1243
1244 static int isp116x_reset(struct usb_hcd *hcd)
1245 {
1246         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1247         unsigned long t;
1248         u16 clkrdy = 0;
1249         int ret, timeout = 15 /* ms */ ;
1250
1251         ret = isp116x_sw_reset(isp116x);
1252         if (ret)
1253                 return ret;
1254
1255         t = jiffies + msecs_to_jiffies(timeout);
1256         while (time_before_eq(jiffies, t)) {
1257                 msleep(4);
1258                 spin_lock_irq(&isp116x->lock);
1259                 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1260                 spin_unlock_irq(&isp116x->lock);
1261                 if (clkrdy)
1262                         break;
1263         }
1264         if (!clkrdy) {
1265                 ERR("Clock not ready after %dms\n", timeout);
1266                 /* After sw_reset the clock won't report to be ready, if
1267                    H_WAKEUP pin is high. */
1268                 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1269                 ret = -ENODEV;
1270         }
1271         return ret;
1272 }
1273
1274 static void isp116x_stop(struct usb_hcd *hcd)
1275 {
1276         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1277         unsigned long flags;
1278         u32 val;
1279
1280         spin_lock_irqsave(&isp116x->lock, flags);
1281         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1282
1283         /* Switch off ports' power, some devices don't come up
1284            after next 'insmod' without this */
1285         val = isp116x_read_reg32(isp116x, HCRHDESCA);
1286         val &= ~(RH_A_NPS | RH_A_PSM);
1287         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1288         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1289         spin_unlock_irqrestore(&isp116x->lock, flags);
1290
1291         isp116x_sw_reset(isp116x);
1292 }
1293
1294 /*
1295   Configure the chip. The chip must be successfully reset by now.
1296 */
1297 static int isp116x_start(struct usb_hcd *hcd)
1298 {
1299         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1300         struct isp116x_platform_data *board = isp116x->board;
1301         u32 val;
1302         unsigned long flags;
1303
1304         spin_lock_irqsave(&isp116x->lock, flags);
1305
1306         /* clear interrupt status and disable all interrupt sources */
1307         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1308         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1309
1310         val = isp116x_read_reg16(isp116x, HCCHIPID);
1311         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1312                 ERR("Invalid chip ID %04x\n", val);
1313                 spin_unlock_irqrestore(&isp116x->lock, flags);
1314                 return -ENODEV;
1315         }
1316
1317         /* To be removed in future */
1318         hcd->uses_new_polling = 1;
1319
1320         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1321         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1322
1323         /* ----- HW conf */
1324         val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1325         if (board->sel15Kres)
1326                 val |= HCHWCFG_15KRSEL;
1327         /* Remote wakeup won't work without working clock */
1328         if (board->remote_wakeup_enable)
1329                 val |= HCHWCFG_CLKNOTSTOP;
1330         if (board->oc_enable)
1331                 val |= HCHWCFG_ANALOG_OC;
1332         if (board->int_act_high)
1333                 val |= HCHWCFG_INT_POL;
1334         if (board->int_edge_triggered)
1335                 val |= HCHWCFG_INT_TRIGGER;
1336         isp116x_write_reg16(isp116x, HCHWCFG, val);
1337
1338         /* ----- Root hub conf */
1339         val = (25 << 24) & RH_A_POTPGT;
1340         /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1341            be always set. Yet, instead, we request individual port
1342            power switching. */
1343         val |= RH_A_PSM;
1344         /* Report overcurrent per port */
1345         val |= RH_A_OCPM;
1346         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1347         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1348
1349         val = RH_B_PPCM;
1350         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1351         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1352
1353         val = 0;
1354         if (board->remote_wakeup_enable) {
1355                 if (!device_can_wakeup(hcd->self.controller))
1356                         device_init_wakeup(hcd->self.controller, 1);
1357                 val |= RH_HS_DRWE;
1358         }
1359         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1360         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1361
1362         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1363
1364         hcd->state = HC_STATE_RUNNING;
1365
1366         /* Set up interrupts */
1367         isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1368         if (board->remote_wakeup_enable)
1369                 isp116x->intenb |= HCINT_RD;
1370         isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1371         isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1372         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1373
1374         /* Go operational */
1375         val = HCCONTROL_USB_OPER;
1376         if (board->remote_wakeup_enable)
1377                 val |= HCCONTROL_RWE;
1378         isp116x_write_reg32(isp116x, HCCONTROL, val);
1379
1380         /* Disable ports to avoid race in device enumeration */
1381         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1382         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1383
1384         isp116x_show_regs_log(isp116x);
1385         spin_unlock_irqrestore(&isp116x->lock, flags);
1386         return 0;
1387 }
1388
1389 #ifdef  CONFIG_PM
1390
1391 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1392 {
1393         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1394         unsigned long flags;
1395         u32 val;
1396         int ret = 0;
1397
1398         spin_lock_irqsave(&isp116x->lock, flags);
1399         val = isp116x_read_reg32(isp116x, HCCONTROL);
1400
1401         switch (val & HCCONTROL_HCFS) {
1402         case HCCONTROL_USB_OPER:
1403                 spin_unlock_irqrestore(&isp116x->lock, flags);
1404                 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1405                 val |= HCCONTROL_USB_SUSPEND;
1406                 if (device_may_wakeup(&hcd->self.root_hub->dev))
1407                         val |= HCCONTROL_RWE;
1408                 /* Wait for usb transfers to finish */
1409                 msleep(2);
1410                 spin_lock_irqsave(&isp116x->lock, flags);
1411                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1412                 spin_unlock_irqrestore(&isp116x->lock, flags);
1413                 /* Wait for devices to suspend */
1414                 msleep(5);
1415                 break;
1416         case HCCONTROL_USB_RESUME:
1417                 isp116x_write_reg32(isp116x, HCCONTROL,
1418                                     (val & ~HCCONTROL_HCFS) |
1419                                     HCCONTROL_USB_RESET);
1420         case HCCONTROL_USB_RESET:
1421                 ret = -EBUSY;
1422         default:                /* HCCONTROL_USB_SUSPEND */
1423                 spin_unlock_irqrestore(&isp116x->lock, flags);
1424                 break;
1425         }
1426
1427         return ret;
1428 }
1429
1430 static int isp116x_bus_resume(struct usb_hcd *hcd)
1431 {
1432         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1433         u32 val;
1434
1435         msleep(5);
1436         spin_lock_irq(&isp116x->lock);
1437
1438         val = isp116x_read_reg32(isp116x, HCCONTROL);
1439         switch (val & HCCONTROL_HCFS) {
1440         case HCCONTROL_USB_SUSPEND:
1441                 val &= ~HCCONTROL_HCFS;
1442                 val |= HCCONTROL_USB_RESUME;
1443                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1444         case HCCONTROL_USB_RESUME:
1445                 break;
1446         case HCCONTROL_USB_OPER:
1447                 spin_unlock_irq(&isp116x->lock);
1448                 /* Without setting power_state here the
1449                    SUSPENDED state won't be removed from
1450                    sysfs/usbN/power.state as a response to remote
1451                    wakeup. Maybe in the future. */
1452                 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1453                 return 0;
1454         default:
1455                 /* HCCONTROL_USB_RESET: this may happen, when during
1456                    suspension the HC lost power. Reinitialize completely */
1457                 spin_unlock_irq(&isp116x->lock);
1458                 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1459                 isp116x_reset(hcd);
1460                 isp116x_start(hcd);
1461                 isp116x_hub_control(hcd, SetPortFeature,
1462                                     USB_PORT_FEAT_POWER, 1, NULL, 0);
1463                 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1464                         isp116x_hub_control(hcd, SetPortFeature,
1465                                             USB_PORT_FEAT_POWER, 2, NULL, 0);
1466                 hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1467                 return 0;
1468         }
1469
1470         val = isp116x->rhdesca & RH_A_NDP;
1471         while (val--) {
1472                 u32 stat =
1473                     isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1474                 /* force global, not selective, resume */
1475                 if (!(stat & RH_PS_PSS))
1476                         continue;
1477                 DBG("%s: Resuming port %d\n", __func__, val);
1478                 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1479                                     ? HCRHPORT2 : HCRHPORT1);
1480         }
1481         spin_unlock_irq(&isp116x->lock);
1482
1483         hcd->state = HC_STATE_RESUMING;
1484         msleep(20);
1485
1486         /* Go operational */
1487         spin_lock_irq(&isp116x->lock);
1488         val = isp116x_read_reg32(isp116x, HCCONTROL);
1489         isp116x_write_reg32(isp116x, HCCONTROL,
1490                             (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1491         spin_unlock_irq(&isp116x->lock);
1492         /* see analogous comment above */
1493         hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1494         hcd->state = HC_STATE_RUNNING;
1495
1496         return 0;
1497 }
1498
1499 #else
1500
1501 #define isp116x_bus_suspend     NULL
1502 #define isp116x_bus_resume      NULL
1503
1504 #endif
1505
1506 static struct hc_driver isp116x_hc_driver = {
1507         .description = hcd_name,
1508         .product_desc = "ISP116x Host Controller",
1509         .hcd_priv_size = sizeof(struct isp116x),
1510
1511         .irq = isp116x_irq,
1512         .flags = HCD_USB11,
1513
1514         .reset = isp116x_reset,
1515         .start = isp116x_start,
1516         .stop = isp116x_stop,
1517
1518         .urb_enqueue = isp116x_urb_enqueue,
1519         .urb_dequeue = isp116x_urb_dequeue,
1520         .endpoint_disable = isp116x_endpoint_disable,
1521
1522         .get_frame_number = isp116x_get_frame,
1523
1524         .hub_status_data = isp116x_hub_status_data,
1525         .hub_control = isp116x_hub_control,
1526         .bus_suspend = isp116x_bus_suspend,
1527         .bus_resume = isp116x_bus_resume,
1528 };
1529
1530 /*----------------------------------------------------------------*/
1531
1532 static int isp116x_remove(struct platform_device *pdev)
1533 {
1534         struct usb_hcd *hcd = platform_get_drvdata(pdev);
1535         struct isp116x *isp116x;
1536         struct resource *res;
1537
1538         if (!hcd)
1539                 return 0;
1540         isp116x = hcd_to_isp116x(hcd);
1541         remove_debug_file(isp116x);
1542         usb_remove_hcd(hcd);
1543
1544         iounmap(isp116x->data_reg);
1545         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1546         release_mem_region(res->start, 2);
1547         iounmap(isp116x->addr_reg);
1548         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1549         release_mem_region(res->start, 2);
1550
1551         usb_put_hcd(hcd);
1552         return 0;
1553 }
1554
1555 #define resource_len(r) (((r)->end - (r)->start) + 1)
1556
1557 static int __devinit isp116x_probe(struct platform_device *pdev)
1558 {
1559         struct usb_hcd *hcd;
1560         struct isp116x *isp116x;
1561         struct resource *addr, *data;
1562         void __iomem *addr_reg;
1563         void __iomem *data_reg;
1564         int irq;
1565         int ret = 0;
1566
1567         if (pdev->num_resources < 3) {
1568                 ret = -ENODEV;
1569                 goto err1;
1570         }
1571
1572         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1573         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1574         irq = platform_get_irq(pdev, 0);
1575         if (!addr || !data || irq < 0) {
1576                 ret = -ENODEV;
1577                 goto err1;
1578         }
1579
1580         if (pdev->dev.dma_mask) {
1581                 DBG("DMA not supported\n");
1582                 ret = -EINVAL;
1583                 goto err1;
1584         }
1585
1586         if (!request_mem_region(addr->start, 2, hcd_name)) {
1587                 ret = -EBUSY;
1588                 goto err1;
1589         }
1590         addr_reg = ioremap(addr->start, resource_len(addr));
1591         if (addr_reg == NULL) {
1592                 ret = -ENOMEM;
1593                 goto err2;
1594         }
1595         if (!request_mem_region(data->start, 2, hcd_name)) {
1596                 ret = -EBUSY;
1597                 goto err3;
1598         }
1599         data_reg = ioremap(data->start, resource_len(data));
1600         if (data_reg == NULL) {
1601                 ret = -ENOMEM;
1602                 goto err4;
1603         }
1604
1605         /* allocate and initialize hcd */
1606         hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
1607         if (!hcd) {
1608                 ret = -ENOMEM;
1609                 goto err5;
1610         }
1611         /* this rsrc_start is bogus */
1612         hcd->rsrc_start = addr->start;
1613         isp116x = hcd_to_isp116x(hcd);
1614         isp116x->data_reg = data_reg;
1615         isp116x->addr_reg = addr_reg;
1616         spin_lock_init(&isp116x->lock);
1617         INIT_LIST_HEAD(&isp116x->async);
1618         isp116x->board = pdev->dev.platform_data;
1619
1620         if (!isp116x->board) {
1621                 ERR("Platform data structure not initialized\n");
1622                 ret = -ENODEV;
1623                 goto err6;
1624         }
1625         if (isp116x_check_platform_delay(isp116x)) {
1626                 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1627                     "implemented.\n");
1628                 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1629                 ret = -ENODEV;
1630                 goto err6;
1631         }
1632
1633         ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
1634         if (ret)
1635                 goto err6;
1636
1637         ret = create_debug_file(isp116x);
1638         if (ret) {
1639                 ERR("Couldn't create debugfs entry\n");
1640                 goto err7;
1641         }
1642
1643         return 0;
1644
1645       err7:
1646         usb_remove_hcd(hcd);
1647       err6:
1648         usb_put_hcd(hcd);
1649       err5:
1650         iounmap(data_reg);
1651       err4:
1652         release_mem_region(data->start, 2);
1653       err3:
1654         iounmap(addr_reg);
1655       err2:
1656         release_mem_region(addr->start, 2);
1657       err1:
1658         ERR("init error, %d\n", ret);
1659         return ret;
1660 }
1661
1662 #ifdef  CONFIG_PM
1663 /*
1664   Suspend of platform device
1665 */
1666 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1667 {
1668         VDBG("%s: state %x\n", __func__, state.event);
1669         dev->dev.power.power_state = state;
1670         return 0;
1671 }
1672
1673 /*
1674   Resume platform device
1675 */
1676 static int isp116x_resume(struct platform_device *dev)
1677 {
1678         VDBG("%s:  state %x\n", __func__, dev->power.power_state.event);
1679         dev->dev.power.power_state = PMSG_ON;
1680         return 0;
1681 }
1682
1683 #else
1684
1685 #define isp116x_suspend    NULL
1686 #define isp116x_resume     NULL
1687
1688 #endif
1689
1690 static struct platform_driver isp116x_driver = {
1691         .probe = isp116x_probe,
1692         .remove = isp116x_remove,
1693         .suspend = isp116x_suspend,
1694         .resume = isp116x_resume,
1695         .driver = {
1696                    .name = (char *)hcd_name,
1697                    },
1698 };
1699
1700 /*-----------------------------------------------------------------*/
1701
1702 static int __init isp116x_init(void)
1703 {
1704         if (usb_disabled())
1705                 return -ENODEV;
1706
1707         INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
1708         return platform_driver_register(&isp116x_driver);
1709 }
1710
1711 module_init(isp116x_init);
1712
1713 static void __exit isp116x_cleanup(void)
1714 {
1715         platform_driver_unregister(&isp116x_driver);
1716 }
1717
1718 module_exit(isp116x_cleanup);