drivers/usb/host/isp116x-hcd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ISP116x HCD (Host Controller Driver) for USB.
   4  *
   5  * Derived from the SL811 HCD, rewritten for ISP116x.
   6  * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
   7  *
   8  * Portions:
   9  * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
  10  * Copyright (C) 2004 David Brownell
  11  *
  12  * Periodic scheduling is based on Roman's OHCI code
  13  * Copyright (C) 1999 Roman Weissgaerber
  14  *
  15  */
  16
  17 /*
  18  * The driver basically works. A number of people have used it with a range
  19  * of devices.
  20  *
  21  * The driver passes all usbtests 1-14.
  22  *
  23  * Suspending/resuming of root hub via sysfs works. Remote wakeup works too.
  24  * And suspending/resuming of platform device works too. Suspend/resume
  25  * via HCD operations vector is not implemented.
  26  *
  27  * Iso transfer support is not implemented. Adding this would include
  28  * implementing recovery from the failure to service the processed ITL
  29  * fifo ram in time, which will involve chip reset.
  30  *
  31  * TODO:
  32  + More testing of suspend/resume.
  33 */
  34
  35 /*
  36   ISP116x chips require certain delays between accesses to its
  37   registers. The following timing options exist.
  38
  39   1. Configure your memory controller (the best)
  40   2. Implement platform-specific delay function possibly
  41   combined with configuring the memory controller; see
  42   include/linux/usb-isp116x.h for more info. Some broken
  43   memory controllers line LH7A400 SMC need this. Also,
  44   uncomment for that to work the following
  45   USE_PLATFORM_DELAY macro.
  46   3. Use ndelay (easiest, poorest). For that, uncomment
  47   the following USE_NDELAY macro.
  48 */
  49 #define USE_PLATFORM_DELAY
  50 //#define USE_NDELAY
  51
  52 //#define DEBUG
  53 //#define VERBOSE
  54 /* Transfer descriptors. See dump_ptd() for printout format  */
  55 //#define PTD_TRACE
  56 /* enqueuing/finishing log of urbs */
  57 //#define URB_TRACE
  58
  59 #include <linux/module.h>
  60 #include <linux/delay.h>
  61 #include <linux/debugfs.h>
  62 #include <linux/seq_file.h>
  63 #include <linux/errno.h>
  64 #include <linux/list.h>
  65 #include <linux/slab.h>
  66 #include <linux/usb.h>
  67 #include <linux/usb/isp116x.h>
  68 #include <linux/usb/hcd.h>
  69 #include <linux/platform_device.h>
  70
  71 #include <asm/io.h>
  72 #include <asm/irq.h>
  73 #include <asm/byteorder.h>
  74
  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                 load = isp116x->load[index];
 505                 if (load) {
 506                         /* Bring all int transfers for this frame
 507                            into the active queue */
 508                         isp116x->atl_active = last_ep =
 509                             isp116x->periodic[index];
 510                         while (last_ep->next)
 511                                 last_ep = (last_ep->active = last_ep->next);
 512                         last_ep->active = NULL;
 513                 }
 514         }
 515
 516         /* Schedule control/bulk transfers */
 517         list_for_each_entry(ep, &isp116x->async, schedule) {
 518                 urb = container_of(ep->hep->urb_list.next,
 519                                    struct urb, urb_list);
 520                 speed = urb->dev->speed;
 521                 byte_time = speed == USB_SPEED_LOW
 522                     ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED;
 523
 524                 if (ep->nextpid == USB_PID_SETUP) {
 525                         len = sizeof(struct usb_ctrlrequest);
 526                 } else if (ep->nextpid == USB_PID_ACK) {
 527                         len = 0;
 528                 } else {
 529                         /* Find current free length ... */
 530                         len = (MAX_LOAD_LIMIT - load) / byte_time;
 531
 532                         /* ... then limit it to configured max size ... */
 533                         len = min(len, speed == USB_SPEED_LOW ?
 534                                   MAX_TRANSFER_SIZE_LOWSPEED :
 535                                   MAX_TRANSFER_SIZE_FULLSPEED);
 536
 537                         /* ... and finally cut to the multiple of MaxPacketSize,
 538                            or to the real length if there's enough room. */
 539                         if (len <
 540                             (urb->transfer_buffer_length -
 541                              urb->actual_length)) {
 542                                 len -= len % ep->maxpacket;
 543                                 if (!len)
 544                                         continue;
 545                         } else
 546                                 len = urb->transfer_buffer_length -
 547                                     urb->actual_length;
 548                         BUG_ON(len < 0);
 549                 }
 550
 551                 load += len * byte_time;
 552                 if (load > MAX_LOAD_LIMIT)
 553                         break;
 554
 555                 ep->active = NULL;
 556                 ep->length = len;
 557                 if (last_ep)
 558                         last_ep->active = ep;
 559                 else
 560                         isp116x->atl_active = ep;
 561                 last_ep = ep;
 562         }
 563
 564         /* Avoid starving of endpoints */
 565         if ((&isp116x->async)->next != (&isp116x->async)->prev)
 566                 list_move(&isp116x->async, (&isp116x->async)->next);
 567
 568         if (isp116x->atl_active) {
 569                 preproc_atl_queue(isp116x);
 570                 pack_fifo(isp116x);
 571         }
 572 }
 573
 574 /*
 575   Finish the processed transfers
 576 */
 577 static void finish_atl_transfers(struct isp116x *isp116x)
 578 {
 579         if (!isp116x->atl_active)
 580                 return;
 581         /* Fifo not ready? */
 582         if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE))
 583                 return;
 584
 585         atomic_inc(&isp116x->atl_finishing);
 586         unpack_fifo(isp116x);
 587         postproc_atl_queue(isp116x);
 588         atomic_dec(&isp116x->atl_finishing);
 589 }
 590
 591 static irqreturn_t isp116x_irq(struct usb_hcd *hcd)
 592 {
 593         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 594         u16 irqstat;
 595         irqreturn_t ret = IRQ_NONE;
 596
 597         spin_lock(&isp116x->lock);
 598         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
 599         irqstat = isp116x_read_reg16(isp116x, HCuPINT);
 600         isp116x_write_reg16(isp116x, HCuPINT, irqstat);
 601
 602         if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
 603                 ret = IRQ_HANDLED;
 604                 finish_atl_transfers(isp116x);
 605         }
 606
 607         if (irqstat & HCuPINT_OPR) {
 608                 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
 609                 isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
 610                 if (intstat & HCINT_UE) {
 611                         ERR("Unrecoverable error, HC is dead!\n");
 612                         /* IRQ's are off, we do no DMA,
 613                            perfectly ready to die ... */
 614                         hcd->state = HC_STATE_HALT;
 615                         usb_hc_died(hcd);
 616                         ret = IRQ_HANDLED;
 617                         goto done;
 618                 }
 619                 if (intstat & HCINT_RHSC)
 620                         /* When root hub or any of its ports is going
 621                            to come out of suspend, it may take more
 622                            than 10ms for status bits to stabilize. */
 623                         mod_timer(&hcd->rh_timer, jiffies
 624                                   + msecs_to_jiffies(20) + 1);
 625                 if (intstat & HCINT_RD) {
 626                         DBG("---- remote wakeup\n");
 627                         usb_hcd_resume_root_hub(hcd);
 628                 }
 629                 irqstat &= ~HCuPINT_OPR;
 630                 ret = IRQ_HANDLED;
 631         }
 632
 633         if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) {
 634                 start_atl_transfers(isp116x);
 635         }
 636
 637         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
 638       done:
 639         spin_unlock(&isp116x->lock);
 640         return ret;
 641 }
 642
 643 /*-----------------------------------------------------------------*/
 644
 645 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
 646  * this driver doesn't promise that much since it's got to handle an
 647  * IRQ per packet; irq handling latencies also use up that time.
 648  */
 649
 650 /* out of 1000 us */
 651 #define MAX_PERIODIC_LOAD       600
 652 static int balance(struct isp116x *isp116x, u16 period, u16 load)
 653 {
 654         int i, branch = -ENOSPC;
 655
 656         /* search for the least loaded schedule branch of that period
 657            which has enough bandwidth left unreserved. */
 658         for (i = 0; i < period; i++) {
 659                 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) {
 660                         int j;
 661
 662                         for (j = i; j < PERIODIC_SIZE; j += period) {
 663                                 if ((isp116x->load[j] + load)
 664                                     > MAX_PERIODIC_LOAD)
 665                                         break;
 666                         }
 667                         if (j < PERIODIC_SIZE)
 668                                 continue;
 669                         branch = i;
 670                 }
 671         }
 672         return branch;
 673 }
 674
 675 /* NB! ALL the code above this point runs with isp116x->lock
 676    held, irqs off
 677 */
 678
 679 /*-----------------------------------------------------------------*/
 680
 681 static int isp116x_urb_enqueue(struct usb_hcd *hcd,
 682                                struct urb *urb,
 683                                gfp_t mem_flags)
 684 {
 685         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 686         struct usb_device *udev = urb->dev;
 687         unsigned int pipe = urb->pipe;
 688         int is_out = !usb_pipein(pipe);
 689         int type = usb_pipetype(pipe);
 690         int epnum = usb_pipeendpoint(pipe);
 691         struct usb_host_endpoint *hep = urb->ep;
 692         struct isp116x_ep *ep = NULL;
 693         unsigned long flags;
 694         int i;
 695         int ret = 0;
 696
 697         urb_dbg(urb, "Enqueue");
 698
 699         if (type == PIPE_ISOCHRONOUS) {
 700                 ERR("Isochronous transfers not supported\n");
 701                 urb_dbg(urb, "Refused to enqueue");
 702                 return -ENXIO;
 703         }
 704         /* avoid all allocations within spinlocks: request or endpoint */
 705         if (!hep->hcpriv) {
 706                 ep = kzalloc(sizeof *ep, mem_flags);
 707                 if (!ep)
 708                         return -ENOMEM;
 709         }
 710
 711         spin_lock_irqsave(&isp116x->lock, flags);
 712         if (!HC_IS_RUNNING(hcd->state)) {
 713                 kfree(ep);
 714                 ret = -ENODEV;
 715                 goto fail_not_linked;
 716         }
 717         ret = usb_hcd_link_urb_to_ep(hcd, urb);
 718         if (ret) {
 719                 kfree(ep);
 720                 goto fail_not_linked;
 721         }
 722
 723         if (hep->hcpriv)
 724                 ep = hep->hcpriv;
 725         else {
 726                 INIT_LIST_HEAD(&ep->schedule);
 727                 ep->udev = udev;
 728                 ep->epnum = epnum;
 729                 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
 730                 usb_settoggle(udev, epnum, is_out, 0);
 731
 732                 if (type == PIPE_CONTROL) {
 733                         ep->nextpid = USB_PID_SETUP;
 734                 } else if (is_out) {
 735                         ep->nextpid = USB_PID_OUT;
 736                 } else {
 737                         ep->nextpid = USB_PID_IN;
 738                 }
 739
 740                 if (urb->interval) {
 741                         /*
 742                            With INT URBs submitted, the driver works with SOF
 743                            interrupt enabled and ATL interrupt disabled. After
 744                            the PTDs are written to fifo ram, the chip starts
 745                            fifo processing and usb transfers after the next
 746                            SOF and continues until the transfers are finished
 747                            (succeeded or failed) or the frame ends. Therefore,
 748                            the transfers occur only in every second frame,
 749                            while fifo reading/writing and data processing
 750                            occur in every other second frame. */
 751                         if (urb->interval < 2)
 752                                 urb->interval = 2;
 753                         if (urb->interval > 2 * PERIODIC_SIZE)
 754                                 urb->interval = 2 * PERIODIC_SIZE;
 755                         ep->period = urb->interval >> 1;
 756                         ep->branch = PERIODIC_SIZE;
 757                         ep->load = usb_calc_bus_time(udev->speed,
 758                                                      !is_out,
 759                                                      (type == PIPE_ISOCHRONOUS),
 760                                                      usb_maxpacket(udev, pipe,
 761                                                                    is_out)) /
 762                             1000;
 763                 }
 764                 hep->hcpriv = ep;
 765                 ep->hep = hep;
 766         }
 767
 768         /* maybe put endpoint into schedule */
 769         switch (type) {
 770         case PIPE_CONTROL:
 771         case PIPE_BULK:
 772                 if (list_empty(&ep->schedule))
 773                         list_add_tail(&ep->schedule, &isp116x->async);
 774                 break;
 775         case PIPE_INTERRUPT:
 776                 urb->interval = ep->period;
 777                 ep->length = min_t(u32, ep->maxpacket,
 778                                  urb->transfer_buffer_length);
 779
 780                 /* urb submitted for already existing endpoint */
 781                 if (ep->branch < PERIODIC_SIZE)
 782                         break;
 783
 784                 ep->branch = ret = balance(isp116x, ep->period, ep->load);
 785                 if (ret < 0)
 786                         goto fail;
 787                 ret = 0;
 788
 789                 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1))
 790                     + ep->branch;
 791
 792                 /* sort each schedule branch by period (slow before fast)
 793                    to share the faster parts of the tree without needing
 794                    dummy/placeholder nodes */
 795                 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
 796                 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
 797                         struct isp116x_ep **prev = &isp116x->periodic[i];
 798                         struct isp116x_ep *here = *prev;
 799
 800                         while (here && ep != here) {
 801                                 if (ep->period > here->period)
 802                                         break;
 803                                 prev = &here->next;
 804                                 here = *prev;
 805                         }
 806                         if (ep != here) {
 807                                 ep->next = here;
 808                                 *prev = ep;
 809                         }
 810                         isp116x->load[i] += ep->load;
 811                 }
 812                 hcd->self.bandwidth_allocated += ep->load / ep->period;
 813
 814                 /* switch over to SOFint */
 815                 if (!isp116x->periodic_count++) {
 816                         isp116x->irqenb &= ~HCuPINT_ATL;
 817                         isp116x->irqenb |= HCuPINT_SOF;
 818                         isp116x_write_reg16(isp116x, HCuPINTENB,
 819                                             isp116x->irqenb);
 820                 }
 821         }
 822
 823         urb->hcpriv = hep;
 824         start_atl_transfers(isp116x);
 825
 826       fail:
 827         if (ret)
 828                 usb_hcd_unlink_urb_from_ep(hcd, urb);
 829       fail_not_linked:
 830         spin_unlock_irqrestore(&isp116x->lock, flags);
 831         return ret;
 832 }
 833
 834 /*
 835    Dequeue URBs.
 836 */
 837 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
 838                 int status)
 839 {
 840         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 841         struct usb_host_endpoint *hep;
 842         struct isp116x_ep *ep, *ep_act;
 843         unsigned long flags;
 844         int rc;
 845
 846         spin_lock_irqsave(&isp116x->lock, flags);
 847         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
 848         if (rc)
 849                 goto done;
 850
 851         hep = urb->hcpriv;
 852         ep = hep->hcpriv;
 853         WARN_ON(hep != ep->hep);
 854
 855         /* In front of queue? */
 856         if (ep->hep->urb_list.next == &urb->urb_list)
 857                 /* active? */
 858                 for (ep_act = isp116x->atl_active; ep_act;
 859                      ep_act = ep_act->active)
 860                         if (ep_act == ep) {
 861                                 VDBG("dequeue, urb %p active; wait for irq\n",
 862                                      urb);
 863                                 urb = NULL;
 864                                 break;
 865                         }
 866
 867         if (urb)
 868                 finish_request(isp116x, ep, urb, status);
 869  done:
 870         spin_unlock_irqrestore(&isp116x->lock, flags);
 871         return rc;
 872 }
 873
 874 static void isp116x_endpoint_disable(struct usb_hcd *hcd,
 875                                      struct usb_host_endpoint *hep)
 876 {
 877         int i;
 878         struct isp116x_ep *ep = hep->hcpriv;
 879
 880         if (!ep)
 881                 return;
 882
 883         /* assume we'd just wait for the irq */
 884         for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++)
 885                 msleep(3);
 886         if (!list_empty(&hep->urb_list))
 887                 WARNING("ep %p not empty?\n", ep);
 888
 889         kfree(ep);
 890         hep->hcpriv = NULL;
 891 }
 892
 893 static int isp116x_get_frame(struct usb_hcd *hcd)
 894 {
 895         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 896         u32 fmnum;
 897         unsigned long flags;
 898
 899         spin_lock_irqsave(&isp116x->lock, flags);
 900         fmnum = isp116x_read_reg32(isp116x, HCFMNUM);
 901         spin_unlock_irqrestore(&isp116x->lock, flags);
 902         return (int)fmnum;
 903 }
 904
 905 /*
 906   Adapted from ohci-hub.c. Currently we don't support autosuspend.
 907 */
 908 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 909 {
 910         struct isp116x *isp116x = hcd_to_isp116x(hcd);
 911         int ports, i, changed = 0;
 912         unsigned long flags;
 913
 914         if (!HC_IS_RUNNING(hcd->state))
 915                 return -ESHUTDOWN;
 916
 917         /* Report no status change now, if we are scheduled to be
 918            called later */
 919         if (timer_pending(&hcd->rh_timer))
 920                 return 0;
 921
 922         ports = isp116x->rhdesca & RH_A_NDP;
 923         spin_lock_irqsave(&isp116x->lock, flags);
 924         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
 925         if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
 926                 buf[0] = changed = 1;
 927         else
 928                 buf[0] = 0;
 929
 930         for (i = 0; i < ports; i++) {
 931                 u32 status = isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
 932
 933                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
 934                               | RH_PS_OCIC | RH_PS_PRSC)) {
 935                         changed = 1;
 936                         buf[0] |= 1 << (i + 1);
 937                 }
 938         }
 939         spin_unlock_irqrestore(&isp116x->lock, flags);
 940         return changed;
 941 }
 942
 943 static void isp116x_hub_descriptor(struct isp116x *isp116x,
 944                                    struct usb_hub_descriptor *desc)
 945 {
 946         u32 reg = isp116x->rhdesca;
 947
 948         desc->bDescriptorType = USB_DT_HUB;
 949         desc->bDescLength = 9;
 950         desc->bHubContrCurrent = 0;
 951         desc->bNbrPorts = (u8) (reg & 0x3);
 952         /* Power switching, device type, overcurrent. */
 953         desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) &
 954                                                        (HUB_CHAR_LPSM |
 955                                                         HUB_CHAR_COMPOUND |
 956                                                         HUB_CHAR_OCPM)));
 957         desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
 958         /* ports removable, and legacy PortPwrCtrlMask */
 959         desc->u.hs.DeviceRemovable[0] = 0;
 960         desc->u.hs.DeviceRemovable[1] = ~0;
 961 }
 962
 963 /* Perform reset of a given port.
 964    It would be great to just start the reset and let the
 965    USB core to clear the reset in due time. However,
 966    root hub ports should be reset for at least 50 ms, while
 967    our chip stays in reset for about 10 ms. I.e., we must
 968    repeatedly reset it ourself here.
 969 */
 970 static inline void root_port_reset(struct isp116x *isp116x, unsigned port)
 971 {
 972         u32 tmp;
 973         unsigned long flags, t;
 974
 975         /* Root hub reset should be 50 ms, but some devices
 976            want it even longer. */
 977         t = jiffies + msecs_to_jiffies(100);
 978
 979         while (time_before(jiffies, t)) {
 980                 spin_lock_irqsave(&isp116x->lock, flags);
 981                 /* spin until any current reset finishes */
 982                 for (;;) {
 983                         tmp = isp116x_read_reg32(isp116x, port ?
 984                                                  HCRHPORT2 : HCRHPORT1);
 985                         if (!(tmp & RH_PS_PRS))
 986                                 break;
 987                         udelay(500);
 988                 }
 989                 /* Don't reset a disconnected port */
 990                 if (!(tmp & RH_PS_CCS)) {
 991                         spin_unlock_irqrestore(&isp116x->lock, flags);
 992                         break;
 993                 }
 994                 /* Reset lasts 10ms (claims datasheet) */
 995                 isp116x_write_reg32(isp116x, port ? HCRHPORT2 :
 996                                     HCRHPORT1, (RH_PS_PRS));
 997                 spin_unlock_irqrestore(&isp116x->lock, flags);
 998                 msleep(10);
 999         }
1000 }
1001
1002 /* Adapted from ohci-hub.c */
1003 static int isp116x_hub_control(struct usb_hcd *hcd,
1004                                u16 typeReq,
1005                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
1006 {
1007         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1008         int ret = 0;
1009         unsigned long flags;
1010         int ports = isp116x->rhdesca & RH_A_NDP;
1011         u32 tmp = 0;
1012
1013         switch (typeReq) {
1014         case ClearHubFeature:
1015                 DBG("ClearHubFeature: ");
1016                 switch (wValue) {
1017                 case C_HUB_OVER_CURRENT:
1018                         DBG("C_HUB_OVER_CURRENT\n");
1019                         spin_lock_irqsave(&isp116x->lock, flags);
1020                         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
1021                         spin_unlock_irqrestore(&isp116x->lock, flags);
1022                         fallthrough;
1023                 case C_HUB_LOCAL_POWER:
1024                         DBG("C_HUB_LOCAL_POWER\n");
1025                         break;
1026                 default:
1027                         goto error;
1028                 }
1029                 break;
1030         case SetHubFeature:
1031                 DBG("SetHubFeature: ");
1032                 switch (wValue) {
1033                 case C_HUB_OVER_CURRENT:
1034                 case C_HUB_LOCAL_POWER:
1035                         DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1036                         break;
1037                 default:
1038                         goto error;
1039                 }
1040                 break;
1041         case GetHubDescriptor:
1042                 DBG("GetHubDescriptor\n");
1043                 isp116x_hub_descriptor(isp116x,
1044                                        (struct usb_hub_descriptor *)buf);
1045                 break;
1046         case GetHubStatus:
1047                 DBG("GetHubStatus\n");
1048                 *(__le32 *) buf = 0;
1049                 break;
1050         case GetPortStatus:
1051                 DBG("GetPortStatus\n");
1052                 if (!wIndex || wIndex > ports)
1053                         goto error;
1054                 spin_lock_irqsave(&isp116x->lock, flags);
1055                 tmp = isp116x_read_reg32(isp116x, (--wIndex) ? HCRHPORT2 : HCRHPORT1);
1056                 spin_unlock_irqrestore(&isp116x->lock, flags);
1057                 *(__le32 *) buf = cpu_to_le32(tmp);
1058                 DBG("GetPortStatus: port[%d]  %08x\n", wIndex + 1, tmp);
1059                 break;
1060         case ClearPortFeature:
1061                 DBG("ClearPortFeature: ");
1062                 if (!wIndex || wIndex > ports)
1063                         goto error;
1064                 wIndex--;
1065
1066                 switch (wValue) {
1067                 case USB_PORT_FEAT_ENABLE:
1068                         DBG("USB_PORT_FEAT_ENABLE\n");
1069                         tmp = RH_PS_CCS;
1070                         break;
1071                 case USB_PORT_FEAT_C_ENABLE:
1072                         DBG("USB_PORT_FEAT_C_ENABLE\n");
1073                         tmp = RH_PS_PESC;
1074                         break;
1075                 case USB_PORT_FEAT_SUSPEND:
1076                         DBG("USB_PORT_FEAT_SUSPEND\n");
1077                         tmp = RH_PS_POCI;
1078                         break;
1079                 case USB_PORT_FEAT_C_SUSPEND:
1080                         DBG("USB_PORT_FEAT_C_SUSPEND\n");
1081                         tmp = RH_PS_PSSC;
1082                         break;
1083                 case USB_PORT_FEAT_POWER:
1084                         DBG("USB_PORT_FEAT_POWER\n");
1085                         tmp = RH_PS_LSDA;
1086                         break;
1087                 case USB_PORT_FEAT_C_CONNECTION:
1088                         DBG("USB_PORT_FEAT_C_CONNECTION\n");
1089                         tmp = RH_PS_CSC;
1090                         break;
1091                 case USB_PORT_FEAT_C_OVER_CURRENT:
1092                         DBG("USB_PORT_FEAT_C_OVER_CURRENT\n");
1093                         tmp = RH_PS_OCIC;
1094                         break;
1095                 case USB_PORT_FEAT_C_RESET:
1096                         DBG("USB_PORT_FEAT_C_RESET\n");
1097                         tmp = RH_PS_PRSC;
1098                         break;
1099                 default:
1100                         goto error;
1101                 }
1102                 spin_lock_irqsave(&isp116x->lock, flags);
1103                 isp116x_write_reg32(isp116x, wIndex
1104                                     ? HCRHPORT2 : HCRHPORT1, tmp);
1105                 spin_unlock_irqrestore(&isp116x->lock, flags);
1106                 break;
1107         case SetPortFeature:
1108                 DBG("SetPortFeature: ");
1109                 if (!wIndex || wIndex > ports)
1110                         goto error;
1111                 wIndex--;
1112                 switch (wValue) {
1113                 case USB_PORT_FEAT_SUSPEND:
1114                         DBG("USB_PORT_FEAT_SUSPEND\n");
1115                         spin_lock_irqsave(&isp116x->lock, flags);
1116                         isp116x_write_reg32(isp116x, wIndex
1117                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS);
1118                         spin_unlock_irqrestore(&isp116x->lock, flags);
1119                         break;
1120                 case USB_PORT_FEAT_POWER:
1121                         DBG("USB_PORT_FEAT_POWER\n");
1122                         spin_lock_irqsave(&isp116x->lock, flags);
1123                         isp116x_write_reg32(isp116x, wIndex
1124                                             ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS);
1125                         spin_unlock_irqrestore(&isp116x->lock, flags);
1126                         break;
1127                 case USB_PORT_FEAT_RESET:
1128                         DBG("USB_PORT_FEAT_RESET\n");
1129                         root_port_reset(isp116x, wIndex);
1130                         break;
1131                 default:
1132                         goto error;
1133                 }
1134                 break;
1135
1136         default:
1137               error:
1138                 /* "protocol stall" on error */
1139                 DBG("PROTOCOL STALL\n");
1140                 ret = -EPIPE;
1141         }
1142         return ret;
1143 }
1144
1145 /*-----------------------------------------------------------------*/
1146
1147 #ifdef CONFIG_DEBUG_FS
1148
1149 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1150 {
1151         seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask,
1152                    mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1153                    mask & HCuPINT_SUSP ? " susp" : "",
1154                    mask & HCuPINT_OPR ? " opr" : "",
1155                    mask & HCuPINT_AIIEOT ? " eot" : "",
1156                    mask & HCuPINT_ATL ? " atl" : "",
1157                    mask & HCuPINT_SOF ? " sof" : "");
1158 }
1159
1160 static void dump_int(struct seq_file *s, char *label, u32 mask)
1161 {
1162         seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask,
1163                    mask & HCINT_MIE ? " MIE" : "",
1164                    mask & HCINT_RHSC ? " rhsc" : "",
1165                    mask & HCINT_FNO ? " fno" : "",
1166                    mask & HCINT_UE ? " ue" : "",
1167                    mask & HCINT_RD ? " rd" : "",
1168                    mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
1169 }
1170
1171 static int isp116x_debug_show(struct seq_file *s, void *unused)
1172 {
1173         struct isp116x *isp116x = s->private;
1174
1175         seq_printf(s, "%s\n%s version %s\n",
1176                    isp116x_to_hcd(isp116x)->product_desc, hcd_name,
1177                    DRIVER_VERSION);
1178
1179         if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) {
1180                 seq_printf(s, "HCD is suspended\n");
1181                 return 0;
1182         }
1183         if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) {
1184                 seq_printf(s, "HCD not running\n");
1185                 return 0;
1186         }
1187
1188         spin_lock_irq(&isp116x->lock);
1189         dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
1190         dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
1191         dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
1192         dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
1193         isp116x_show_regs_seq(isp116x, s);
1194         spin_unlock_irq(&isp116x->lock);
1195         seq_printf(s, "\n");
1196
1197         return 0;
1198 }
1199 DEFINE_SHOW_ATTRIBUTE(isp116x_debug);
1200
1201 static void create_debug_file(struct isp116x *isp116x)
1202 {
1203         debugfs_create_file(hcd_name, S_IRUGO, usb_debug_root, isp116x,
1204                             &isp116x_debug_fops);
1205 }
1206
1207 static void remove_debug_file(struct isp116x *isp116x)
1208 {
1209         debugfs_remove(debugfs_lookup(hcd_name, usb_debug_root));
1210 }
1211
1212 #else
1213
1214 static inline void create_debug_file(struct isp116x *isp116x) { }
1215 static inline void remove_debug_file(struct isp116x *isp116x) { }
1216
1217 #endif                          /* CONFIG_DEBUG_FS */
1218
1219 /*-----------------------------------------------------------------*/
1220
1221 /*
1222   Software reset - can be called from any contect.
1223 */
1224 static int isp116x_sw_reset(struct isp116x *isp116x)
1225 {
1226         int retries = 15;
1227         unsigned long flags;
1228         int ret = 0;
1229
1230         spin_lock_irqsave(&isp116x->lock, flags);
1231         isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
1232         isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
1233         while (--retries) {
1234                 /* It usually resets within 1 ms */
1235                 mdelay(1);
1236                 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
1237                         break;
1238         }
1239         if (!retries) {
1240                 ERR("Software reset timeout\n");
1241                 ret = -ETIME;
1242         }
1243         spin_unlock_irqrestore(&isp116x->lock, flags);
1244         return ret;
1245 }
1246
1247 static int isp116x_reset(struct usb_hcd *hcd)
1248 {
1249         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1250         unsigned long t;
1251         u16 clkrdy = 0;
1252         int ret, timeout = 15 /* ms */ ;
1253
1254         ret = isp116x_sw_reset(isp116x);
1255         if (ret)
1256                 return ret;
1257
1258         t = jiffies + msecs_to_jiffies(timeout);
1259         while (time_before_eq(jiffies, t)) {
1260                 msleep(4);
1261                 spin_lock_irq(&isp116x->lock);
1262                 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
1263                 spin_unlock_irq(&isp116x->lock);
1264                 if (clkrdy)
1265                         break;
1266         }
1267         if (!clkrdy) {
1268                 ERR("Clock not ready after %dms\n", timeout);
1269                 /* After sw_reset the clock won't report to be ready, if
1270                    H_WAKEUP pin is high. */
1271                 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
1272                 ret = -ENODEV;
1273         }
1274         return ret;
1275 }
1276
1277 static void isp116x_stop(struct usb_hcd *hcd)
1278 {
1279         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1280         unsigned long flags;
1281         u32 val;
1282
1283         spin_lock_irqsave(&isp116x->lock, flags);
1284         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1285
1286         /* Switch off ports' power, some devices don't come up
1287            after next 'insmod' without this */
1288         val = isp116x_read_reg32(isp116x, HCRHDESCA);
1289         val &= ~(RH_A_NPS | RH_A_PSM);
1290         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1291         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
1292         spin_unlock_irqrestore(&isp116x->lock, flags);
1293
1294         isp116x_sw_reset(isp116x);
1295 }
1296
1297 /*
1298   Configure the chip. The chip must be successfully reset by now.
1299 */
1300 static int isp116x_start(struct usb_hcd *hcd)
1301 {
1302         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1303         struct isp116x_platform_data *board = isp116x->board;
1304         u32 val;
1305         unsigned long flags;
1306
1307         spin_lock_irqsave(&isp116x->lock, flags);
1308
1309         /* clear interrupt status and disable all interrupt sources */
1310         isp116x_write_reg16(isp116x, HCuPINT, 0xff);
1311         isp116x_write_reg16(isp116x, HCuPINTENB, 0);
1312
1313         val = isp116x_read_reg16(isp116x, HCCHIPID);
1314         if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
1315                 ERR("Invalid chip ID %04x\n", val);
1316                 spin_unlock_irqrestore(&isp116x->lock, flags);
1317                 return -ENODEV;
1318         }
1319
1320         /* To be removed in future */
1321         hcd->uses_new_polling = 1;
1322
1323         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
1324         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
1325
1326         /* ----- HW conf */
1327         val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
1328         if (board->sel15Kres)
1329                 val |= HCHWCFG_15KRSEL;
1330         /* Remote wakeup won't work without working clock */
1331         if (board->remote_wakeup_enable)
1332                 val |= HCHWCFG_CLKNOTSTOP;
1333         if (board->oc_enable)
1334                 val |= HCHWCFG_ANALOG_OC;
1335         if (board->int_act_high)
1336                 val |= HCHWCFG_INT_POL;
1337         if (board->int_edge_triggered)
1338                 val |= HCHWCFG_INT_TRIGGER;
1339         isp116x_write_reg16(isp116x, HCHWCFG, val);
1340
1341         /* ----- Root hub conf */
1342         val = (25 << 24) & RH_A_POTPGT;
1343         /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
1344            be always set. Yet, instead, we request individual port
1345            power switching. */
1346         val |= RH_A_PSM;
1347         /* Report overcurrent per port */
1348         val |= RH_A_OCPM;
1349         isp116x_write_reg32(isp116x, HCRHDESCA, val);
1350         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
1351
1352         val = RH_B_PPCM;
1353         isp116x_write_reg32(isp116x, HCRHDESCB, val);
1354         isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
1355
1356         val = 0;
1357         if (board->remote_wakeup_enable) {
1358                 if (!device_can_wakeup(hcd->self.controller))
1359                         device_init_wakeup(hcd->self.controller, 1);
1360                 val |= RH_HS_DRWE;
1361         }
1362         isp116x_write_reg32(isp116x, HCRHSTATUS, val);
1363         isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
1364
1365         isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
1366
1367         hcd->state = HC_STATE_RUNNING;
1368
1369         /* Set up interrupts */
1370         isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE;
1371         if (board->remote_wakeup_enable)
1372                 isp116x->intenb |= HCINT_RD;
1373         isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR;    /* | HCuPINT_SUSP; */
1374         isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb);
1375         isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
1376
1377         /* Go operational */
1378         val = HCCONTROL_USB_OPER;
1379         if (board->remote_wakeup_enable)
1380                 val |= HCCONTROL_RWE;
1381         isp116x_write_reg32(isp116x, HCCONTROL, val);
1382
1383         /* Disable ports to avoid race in device enumeration */
1384         isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
1385         isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
1386
1387         isp116x_show_regs_log(isp116x);
1388         spin_unlock_irqrestore(&isp116x->lock, flags);
1389         return 0;
1390 }
1391
1392 #ifdef  CONFIG_PM
1393
1394 static int isp116x_bus_suspend(struct usb_hcd *hcd)
1395 {
1396         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1397         unsigned long flags;
1398         u32 val;
1399         int ret = 0;
1400
1401         spin_lock_irqsave(&isp116x->lock, flags);
1402         val = isp116x_read_reg32(isp116x, HCCONTROL);
1403
1404         switch (val & HCCONTROL_HCFS) {
1405         case HCCONTROL_USB_OPER:
1406                 spin_unlock_irqrestore(&isp116x->lock, flags);
1407                 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
1408                 val |= HCCONTROL_USB_SUSPEND;
1409                 if (hcd->self.root_hub->do_remote_wakeup)
1410                         val |= HCCONTROL_RWE;
1411                 /* Wait for usb transfers to finish */
1412                 msleep(2);
1413                 spin_lock_irqsave(&isp116x->lock, flags);
1414                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1415                 spin_unlock_irqrestore(&isp116x->lock, flags);
1416                 /* Wait for devices to suspend */
1417                 msleep(5);
1418                 break;
1419         case HCCONTROL_USB_RESUME:
1420                 isp116x_write_reg32(isp116x, HCCONTROL,
1421                                     (val & ~HCCONTROL_HCFS) |
1422                                     HCCONTROL_USB_RESET);
1423                 fallthrough;
1424         case HCCONTROL_USB_RESET:
1425                 ret = -EBUSY;
1426                 fallthrough;
1427         default:                /* HCCONTROL_USB_SUSPEND */
1428                 spin_unlock_irqrestore(&isp116x->lock, flags);
1429                 break;
1430         }
1431
1432         return ret;
1433 }
1434
1435 static int isp116x_bus_resume(struct usb_hcd *hcd)
1436 {
1437         struct isp116x *isp116x = hcd_to_isp116x(hcd);
1438         u32 val;
1439
1440         msleep(5);
1441         spin_lock_irq(&isp116x->lock);
1442
1443         val = isp116x_read_reg32(isp116x, HCCONTROL);
1444         switch (val & HCCONTROL_HCFS) {
1445         case HCCONTROL_USB_SUSPEND:
1446                 val &= ~HCCONTROL_HCFS;
1447                 val |= HCCONTROL_USB_RESUME;
1448                 isp116x_write_reg32(isp116x, HCCONTROL, val);
1449                 break;
1450         case HCCONTROL_USB_RESUME:
1451                 break;
1452         case HCCONTROL_USB_OPER:
1453                 spin_unlock_irq(&isp116x->lock);
1454                 return 0;
1455         default:
1456                 /* HCCONTROL_USB_RESET: this may happen, when during
1457                    suspension the HC lost power. Reinitialize completely */
1458                 spin_unlock_irq(&isp116x->lock);
1459                 DBG("Chip has been reset while suspended. Reinit from scratch.\n");
1460                 isp116x_reset(hcd);
1461                 isp116x_start(hcd);
1462                 isp116x_hub_control(hcd, SetPortFeature,
1463                                     USB_PORT_FEAT_POWER, 1, NULL, 0);
1464                 if ((isp116x->rhdesca & RH_A_NDP) == 2)
1465                         isp116x_hub_control(hcd, SetPortFeature,
1466                                             USB_PORT_FEAT_POWER, 2, NULL, 0);
1467                 return 0;
1468         }
1469
1470         val = isp116x->rhdesca & RH_A_NDP;
1471         while (val--) {
1472                 u32 stat =
1473                     isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
1474                 /* force global, not selective, resume */
1475                 if (!(stat & RH_PS_PSS))
1476                         continue;
1477                 DBG("%s: Resuming port %d\n", __func__, val);
1478                 isp116x_write_reg32(isp116x, RH_PS_POCI, val
1479                                     ? HCRHPORT2 : HCRHPORT1);
1480         }
1481         spin_unlock_irq(&isp116x->lock);
1482
1483         hcd->state = HC_STATE_RESUMING;
1484         msleep(USB_RESUME_TIMEOUT);
1485
1486         /* Go operational */
1487         spin_lock_irq(&isp116x->lock);
1488         val = isp116x_read_reg32(isp116x, HCCONTROL);
1489         isp116x_write_reg32(isp116x, HCCONTROL,
1490                             (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
1491         spin_unlock_irq(&isp116x->lock);
1492         hcd->state = HC_STATE_RUNNING;
1493
1494         return 0;
1495 }
1496
1497 #else
1498
1499 #define isp116x_bus_suspend     NULL
1500 #define isp116x_bus_resume      NULL
1501
1502 #endif
1503
1504 static const struct hc_driver isp116x_hc_driver = {
1505         .description = hcd_name,
1506         .product_desc = "ISP116x Host Controller",
1507         .hcd_priv_size = sizeof(struct isp116x),
1508
1509         .irq = isp116x_irq,
1510         .flags = HCD_USB11,
1511
1512         .reset = isp116x_reset,
1513         .start = isp116x_start,
1514         .stop = isp116x_stop,
1515
1516         .urb_enqueue = isp116x_urb_enqueue,
1517         .urb_dequeue = isp116x_urb_dequeue,
1518         .endpoint_disable = isp116x_endpoint_disable,
1519
1520         .get_frame_number = isp116x_get_frame,
1521
1522         .hub_status_data = isp116x_hub_status_data,
1523         .hub_control = isp116x_hub_control,
1524         .bus_suspend = isp116x_bus_suspend,
1525         .bus_resume = isp116x_bus_resume,
1526 };
1527
1528 /*----------------------------------------------------------------*/
1529
1530 static int isp116x_remove(struct platform_device *pdev)
1531 {
1532         struct usb_hcd *hcd = platform_get_drvdata(pdev);
1533         struct isp116x *isp116x;
1534         struct resource *res;
1535
1536         if (!hcd)
1537                 return 0;
1538         isp116x = hcd_to_isp116x(hcd);
1539         remove_debug_file(isp116x);
1540         usb_remove_hcd(hcd);
1541
1542         iounmap(isp116x->data_reg);
1543         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1544         if (res)
1545                 release_mem_region(res->start, 2);
1546         iounmap(isp116x->addr_reg);
1547         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1548         if (res)
1549                 release_mem_region(res->start, 2);
1550
1551         usb_put_hcd(hcd);
1552         return 0;
1553 }
1554
1555 static int isp116x_probe(struct platform_device *pdev)
1556 {
1557         struct usb_hcd *hcd;
1558         struct isp116x *isp116x;
1559         struct resource *addr, *data, *ires;
1560         void __iomem *addr_reg;
1561         void __iomem *data_reg;
1562         int irq;
1563         int ret = 0;
1564         unsigned long irqflags;
1565
1566         if (usb_disabled())
1567                 return -ENODEV;
1568
1569         if (pdev->num_resources < 3) {
1570                 ret = -ENODEV;
1571                 goto err1;
1572         }
1573
1574         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1575         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1576         ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1577
1578         if (!addr || !data || !ires) {
1579                 ret = -ENODEV;
1580                 goto err1;
1581         }
1582
1583         irq = ires->start;
1584         irqflags = ires->flags & IRQF_TRIGGER_MASK;
1585
1586         if (!request_mem_region(addr->start, 2, hcd_name)) {
1587                 ret = -EBUSY;
1588                 goto err1;
1589         }
1590         addr_reg = ioremap(addr->start, resource_size(addr));
1591         if (addr_reg == NULL) {
1592                 ret = -ENOMEM;
1593                 goto err2;
1594         }
1595         if (!request_mem_region(data->start, 2, hcd_name)) {
1596                 ret = -EBUSY;
1597                 goto err3;
1598         }
1599         data_reg = ioremap(data->start, resource_size(data));
1600         if (data_reg == NULL) {
1601                 ret = -ENOMEM;
1602                 goto err4;
1603         }
1604
1605         /* allocate and initialize hcd */
1606         hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1607         if (!hcd) {
1608                 ret = -ENOMEM;
1609                 goto err5;
1610         }
1611         /* this rsrc_start is bogus */
1612         hcd->rsrc_start = addr->start;
1613         isp116x = hcd_to_isp116x(hcd);
1614         isp116x->data_reg = data_reg;
1615         isp116x->addr_reg = addr_reg;
1616         spin_lock_init(&isp116x->lock);
1617         INIT_LIST_HEAD(&isp116x->async);
1618         isp116x->board = dev_get_platdata(&pdev->dev);
1619
1620         if (!isp116x->board) {
1621                 ERR("Platform data structure not initialized\n");
1622                 ret = -ENODEV;
1623                 goto err6;
1624         }
1625         if (isp116x_check_platform_delay(isp116x)) {
1626                 ERR("USE_PLATFORM_DELAY defined, but delay function not "
1627                     "implemented.\n");
1628                 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1629                 ret = -ENODEV;
1630                 goto err6;
1631         }
1632
1633         ret = usb_add_hcd(hcd, irq, irqflags);
1634         if (ret)
1635                 goto err6;
1636
1637         device_wakeup_enable(hcd->self.controller);
1638
1639         create_debug_file(isp116x);
1640
1641         return 0;
1642
1643       err6:
1644         usb_put_hcd(hcd);
1645       err5:
1646         iounmap(data_reg);
1647       err4:
1648         release_mem_region(data->start, 2);
1649       err3:
1650         iounmap(addr_reg);
1651       err2:
1652         release_mem_region(addr->start, 2);
1653       err1:
1654         ERR("init error, %d\n", ret);
1655         return ret;
1656 }
1657
1658 #ifdef  CONFIG_PM
1659 /*
1660   Suspend of platform device
1661 */
1662 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1663 {
1664         VDBG("%s: state %x\n", __func__, state.event);
1665         return 0;
1666 }
1667
1668 /*
1669   Resume platform device
1670 */
1671 static int isp116x_resume(struct platform_device *dev)
1672 {
1673         VDBG("%s\n", __func__);
1674         return 0;
1675 }
1676
1677 #else
1678
1679 #define isp116x_suspend    NULL
1680 #define isp116x_resume     NULL
1681
1682 #endif
1683
1684 /* work with hotplug and coldplug */
1685 MODULE_ALIAS("platform:isp116x-hcd");
1686
1687 static struct platform_driver isp116x_driver = {
1688         .probe = isp116x_probe,
1689         .remove = isp116x_remove,
1690         .suspend = isp116x_suspend,
1691         .resume = isp116x_resume,
1692         .driver = {
1693                 .name = hcd_name,
1694         },
1695 };
1696
1697 module_platform_driver(isp116x_driver);