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