linux/drivers/usb/host/isp116x-hcd.c
<<
>>
Prefs
   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
  80MODULE_DESCRIPTION(DRIVER_DESC);
  81MODULE_LICENSE("GPL");
  82
  83static const char hcd_name[] = "isp116x-hcd";
  84
  85/*-----------------------------------------------------------------*/
  86
  87/*
  88  Write len bytes to fifo, pad till 32-bit boundary
  89 */
  90static 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 */
 127static 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*/
 166static 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*/
 198static 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*/
 231static 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*/
 294static 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*/
 348static 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 */
 480static 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*/
 577static 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
 591static 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
 652static 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
 681static 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*/
 837static 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
 874static 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
 893static 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*/
 908static 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
 943static 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*/
 970static 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 */
1003static 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
1149static 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
1160static 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
1171static 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}
1199DEFINE_SHOW_ATTRIBUTE(isp116x_debug);
1200
1201static 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
1207static void remove_debug_file(struct isp116x *isp116x)
1208{
1209        debugfs_remove(debugfs_lookup(hcd_name, usb_debug_root));
1210}
1211
1212#else
1213
1214static inline void create_debug_file(struct isp116x *isp116x) { }
1215static 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*/
1224static 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
1247static 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
1277static 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*/
1300static 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
1394static 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
1435static 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
1504static 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
1530static 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        release_mem_region(res->start, 2);
1545        iounmap(isp116x->addr_reg);
1546        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1547        release_mem_region(res->start, 2);
1548
1549        usb_put_hcd(hcd);
1550        return 0;
1551}
1552
1553static int isp116x_probe(struct platform_device *pdev)
1554{
1555        struct usb_hcd *hcd;
1556        struct isp116x *isp116x;
1557        struct resource *addr, *data, *ires;
1558        void __iomem *addr_reg;
1559        void __iomem *data_reg;
1560        int irq;
1561        int ret = 0;
1562        unsigned long irqflags;
1563
1564        if (usb_disabled())
1565                return -ENODEV;
1566
1567        if (pdev->num_resources < 3) {
1568                ret = -ENODEV;
1569                goto err1;
1570        }
1571
1572        data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1573        addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1574        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1575
1576        if (!addr || !data || !ires) {
1577                ret = -ENODEV;
1578                goto err1;
1579        }
1580
1581        irq = ires->start;
1582        irqflags = ires->flags & IRQF_TRIGGER_MASK;
1583
1584        if (!request_mem_region(addr->start, 2, hcd_name)) {
1585                ret = -EBUSY;
1586                goto err1;
1587        }
1588        addr_reg = ioremap(addr->start, resource_size(addr));
1589        if (addr_reg == NULL) {
1590                ret = -ENOMEM;
1591                goto err2;
1592        }
1593        if (!request_mem_region(data->start, 2, hcd_name)) {
1594                ret = -EBUSY;
1595                goto err3;
1596        }
1597        data_reg = ioremap(data->start, resource_size(data));
1598        if (data_reg == NULL) {
1599                ret = -ENOMEM;
1600                goto err4;
1601        }
1602
1603        /* allocate and initialize hcd */
1604        hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1605        if (!hcd) {
1606                ret = -ENOMEM;
1607                goto err5;
1608        }
1609        /* this rsrc_start is bogus */
1610        hcd->rsrc_start = addr->start;
1611        isp116x = hcd_to_isp116x(hcd);
1612        isp116x->data_reg = data_reg;
1613        isp116x->addr_reg = addr_reg;
1614        spin_lock_init(&isp116x->lock);
1615        INIT_LIST_HEAD(&isp116x->async);
1616        isp116x->board = dev_get_platdata(&pdev->dev);
1617
1618        if (!isp116x->board) {
1619                ERR("Platform data structure not initialized\n");
1620                ret = -ENODEV;
1621                goto err6;
1622        }
1623        if (isp116x_check_platform_delay(isp116x)) {
1624                ERR("USE_PLATFORM_DELAY defined, but delay function not "
1625                    "implemented.\n");
1626                ERR("See comments in drivers/usb/host/isp116x-hcd.c\n");
1627                ret = -ENODEV;
1628                goto err6;
1629        }
1630
1631        ret = usb_add_hcd(hcd, irq, irqflags);
1632        if (ret)
1633                goto err6;
1634
1635        device_wakeup_enable(hcd->self.controller);
1636
1637        create_debug_file(isp116x);
1638
1639        return 0;
1640
1641      err6:
1642        usb_put_hcd(hcd);
1643      err5:
1644        iounmap(data_reg);
1645      err4:
1646        release_mem_region(data->start, 2);
1647      err3:
1648        iounmap(addr_reg);
1649      err2:
1650        release_mem_region(addr->start, 2);
1651      err1:
1652        ERR("init error, %d\n", ret);
1653        return ret;
1654}
1655
1656#ifdef  CONFIG_PM
1657/*
1658  Suspend of platform device
1659*/
1660static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
1661{
1662        VDBG("%s: state %x\n", __func__, state.event);
1663        return 0;
1664}
1665
1666/*
1667  Resume platform device
1668*/
1669static int isp116x_resume(struct platform_device *dev)
1670{
1671        VDBG("%s\n", __func__);
1672        return 0;
1673}
1674
1675#else
1676
1677#define isp116x_suspend    NULL
1678#define isp116x_resume     NULL
1679
1680#endif
1681
1682/* work with hotplug and coldplug */
1683MODULE_ALIAS("platform:isp116x-hcd");
1684
1685static struct platform_driver isp116x_driver = {
1686        .probe = isp116x_probe,
1687        .remove = isp116x_remove,
1688        .suspend = isp116x_suspend,
1689        .resume = isp116x_resume,
1690        .driver = {
1691                .name = hcd_name,
1692        },
1693};
1694
1695module_platform_driver(isp116x_driver);
1696
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.