git.oblomov.eu Git - linux-2.6/blob - drivers/usb/host/isp116x-hcd.c

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