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