linux/drivers/usb/host/sl811-hcd.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * SL811HS HCD (Host Controller Driver) for USB.
   4 *
   5 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
   6 * Copyright (C) 2004-2005 David Brownell
   7 *
   8 * Periodic scheduling is based on Roman's OHCI code
   9 *      Copyright (C) 1999 Roman Weissgaerber
  10 *
  11 * The SL811HS controller handles host side USB (like the SL11H, but with
  12 * another register set and SOF generation) as well as peripheral side USB
  13 * (like the SL811S).  This driver version doesn't implement the Gadget API
  14 * for the peripheral role; or OTG (that'd need much external circuitry).
  15 *
  16 * For documentation, see the SL811HS spec and the "SL811HS Embedded Host"
  17 * document (providing significant pieces missing from that spec); plus
  18 * the SL811S spec if you want peripheral side info.
  19 */
  20
  21/*
  22 * Status:  Passed basic stress testing, works with hubs, mice, keyboards,
  23 * and usb-storage.
  24 *
  25 * TODO:
  26 * - usb suspend/resume triggered by sl811
  27 * - various issues noted in the code
  28 * - performance work; use both register banks; ...
  29 * - use urb->iso_frame_desc[] with ISO transfers
  30 */
  31
  32#undef  VERBOSE
  33#undef  PACKET_TRACE
  34
  35#include <linux/module.h>
  36#include <linux/moduleparam.h>
  37#include <linux/kernel.h>
  38#include <linux/delay.h>
  39#include <linux/ioport.h>
  40#include <linux/sched.h>
  41#include <linux/slab.h>
  42#include <linux/errno.h>
  43#include <linux/timer.h>
  44#include <linux/list.h>
  45#include <linux/interrupt.h>
  46#include <linux/usb.h>
  47#include <linux/usb/sl811.h>
  48#include <linux/usb/hcd.h>
  49#include <linux/platform_device.h>
  50#include <linux/prefetch.h>
  51#include <linux/debugfs.h>
  52#include <linux/seq_file.h>
  53
  54#include <asm/io.h>
  55#include <asm/irq.h>
  56#include <asm/byteorder.h>
  57#include <asm/unaligned.h>
  58
  59#include "sl811.h"
  60
  61
  62MODULE_DESCRIPTION("SL811HS USB Host Controller Driver");
  63MODULE_LICENSE("GPL");
  64MODULE_ALIAS("platform:sl811-hcd");
  65
  66#define DRIVER_VERSION  "19 May 2005"
  67
  68/* for now, use only one transfer register bank */
  69#undef  USE_B
  70
  71// #define      QUIRK2
  72#define QUIRK3
  73
  74static const char hcd_name[] = "sl811-hcd";
  75
  76/*-------------------------------------------------------------------------*/
  77
  78static void port_power(struct sl811 *sl811, int is_on)
  79{
  80        struct usb_hcd  *hcd = sl811_to_hcd(sl811);
  81
  82        /* hub is inactive unless the port is powered */
  83        if (is_on) {
  84                if (sl811->port1 & USB_PORT_STAT_POWER)
  85                        return;
  86
  87                sl811->port1 = USB_PORT_STAT_POWER;
  88                sl811->irq_enable = SL11H_INTMASK_INSRMV;
  89        } else {
  90                sl811->port1 = 0;
  91                sl811->irq_enable = 0;
  92                hcd->state = HC_STATE_HALT;
  93        }
  94        sl811->ctrl1 = 0;
  95        sl811_write(sl811, SL11H_IRQ_ENABLE, 0);
  96        sl811_write(sl811, SL11H_IRQ_STATUS, ~0);
  97
  98        if (sl811->board && sl811->board->port_power) {
  99                /* switch VBUS, at 500mA unless hub power budget gets set */
 100                dev_dbg(hcd->self.controller, "power %s\n",
 101                        is_on ? "on" : "off");
 102                sl811->board->port_power(hcd->self.controller, is_on);
 103        }
 104
 105        /* reset as thoroughly as we can */
 106        if (sl811->board && sl811->board->reset)
 107                sl811->board->reset(hcd->self.controller);
 108        else {
 109                sl811_write(sl811, SL11H_CTLREG1, SL11H_CTL1MASK_SE0);
 110                mdelay(20);
 111        }
 112
 113        sl811_write(sl811, SL11H_IRQ_ENABLE, 0);
 114        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
 115        sl811_write(sl811, SL811HS_CTLREG2, SL811HS_CTL2_INIT);
 116        sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
 117
 118        // if !is_on, put into lowpower mode now
 119}
 120
 121/*-------------------------------------------------------------------------*/
 122
 123/* This is a PIO-only HCD.  Queueing appends URBs to the endpoint's queue,
 124 * and may start I/O.  Endpoint queues are scanned during completion irq
 125 * handlers (one per packet: ACK, NAK, faults, etc) and urb cancellation.
 126 *
 127 * Using an external DMA engine to copy a packet at a time could work,
 128 * though setup/teardown costs may be too big to make it worthwhile.
 129 */
 130
 131/* SETUP starts a new control request.  Devices are not allowed to
 132 * STALL or NAK these; they must cancel any pending control requests.
 133 */
 134static void setup_packet(
 135        struct sl811            *sl811,
 136        struct sl811h_ep        *ep,
 137        struct urb              *urb,
 138        u8                      bank,
 139        u8                      control
 140)
 141{
 142        u8                      addr;
 143        u8                      len;
 144        void __iomem            *data_reg;
 145
 146        addr = SL811HS_PACKET_BUF(bank == 0);
 147        len = sizeof(struct usb_ctrlrequest);
 148        data_reg = sl811->data_reg;
 149        sl811_write_buf(sl811, addr, urb->setup_packet, len);
 150
 151        /* autoincrementing */
 152        sl811_write(sl811, bank + SL11H_BUFADDRREG, addr);
 153        writeb(len, data_reg);
 154        writeb(SL_SETUP /* | ep->epnum */, data_reg);
 155        writeb(usb_pipedevice(urb->pipe), data_reg);
 156
 157        /* always OUT/data0 */
 158        sl811_write(sl811, bank + SL11H_HOSTCTLREG,
 159                        control | SL11H_HCTLMASK_OUT);
 160        ep->length = 0;
 161        PACKET("SETUP qh%p\n", ep);
 162}
 163
 164/* STATUS finishes control requests, often after IN or OUT data packets */
 165static void status_packet(
 166        struct sl811            *sl811,
 167        struct sl811h_ep        *ep,
 168        struct urb              *urb,
 169        u8                      bank,
 170        u8                      control
 171)
 172{
 173        int                     do_out;
 174        void __iomem            *data_reg;
 175
 176        do_out = urb->transfer_buffer_length && usb_pipein(urb->pipe);
 177        data_reg = sl811->data_reg;
 178
 179        /* autoincrementing */
 180        sl811_write(sl811, bank + SL11H_BUFADDRREG, 0);
 181        writeb(0, data_reg);
 182        writeb((do_out ? SL_OUT : SL_IN) /* | ep->epnum */, data_reg);
 183        writeb(usb_pipedevice(urb->pipe), data_reg);
 184
 185        /* always data1; sometimes IN */
 186        control |= SL11H_HCTLMASK_TOGGLE;
 187        if (do_out)
 188                control |= SL11H_HCTLMASK_OUT;
 189        sl811_write(sl811, bank + SL11H_HOSTCTLREG, control);
 190        ep->length = 0;
 191        PACKET("STATUS%s/%s qh%p\n", ep->nak_count ? "/retry" : "",
 192                        do_out ? "out" : "in", ep);
 193}
 194
 195/* IN packets can be used with any type of endpoint. here we just
 196 * start the transfer, data from the peripheral may arrive later.
 197 * urb->iso_frame_desc is currently ignored here...
 198 */
 199static void in_packet(
 200        struct sl811            *sl811,
 201        struct sl811h_ep        *ep,
 202        struct urb              *urb,
 203        u8                      bank,
 204        u8                      control
 205)
 206{
 207        u8                      addr;
 208        u8                      len;
 209        void __iomem            *data_reg;
 210
 211        /* avoid losing data on overflow */
 212        len = ep->maxpacket;
 213        addr = SL811HS_PACKET_BUF(bank == 0);
 214        if (!(control & SL11H_HCTLMASK_ISOCH)
 215                        && usb_gettoggle(urb->dev, ep->epnum, 0))
 216                control |= SL11H_HCTLMASK_TOGGLE;
 217        data_reg = sl811->data_reg;
 218
 219        /* autoincrementing */
 220        sl811_write(sl811, bank + SL11H_BUFADDRREG, addr);
 221        writeb(len, data_reg);
 222        writeb(SL_IN | ep->epnum, data_reg);
 223        writeb(usb_pipedevice(urb->pipe), data_reg);
 224
 225        sl811_write(sl811, bank + SL11H_HOSTCTLREG, control);
 226        ep->length = min_t(u32, len,
 227                        urb->transfer_buffer_length - urb->actual_length);
 228        PACKET("IN%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "",
 229                        !!usb_gettoggle(urb->dev, ep->epnum, 0), ep, len);
 230}
 231
 232/* OUT packets can be used with any type of endpoint.
 233 * urb->iso_frame_desc is currently ignored here...
 234 */
 235static void out_packet(
 236        struct sl811            *sl811,
 237        struct sl811h_ep        *ep,
 238        struct urb              *urb,
 239        u8                      bank,
 240        u8                      control
 241)
 242{
 243        void                    *buf;
 244        u8                      addr;
 245        u8                      len;
 246        void __iomem            *data_reg;
 247
 248        buf = urb->transfer_buffer + urb->actual_length;
 249        prefetch(buf);
 250
 251        len = min_t(u32, ep->maxpacket,
 252                        urb->transfer_buffer_length - urb->actual_length);
 253
 254        if (!(control & SL11H_HCTLMASK_ISOCH)
 255                        && usb_gettoggle(urb->dev, ep->epnum, 1))
 256                control |= SL11H_HCTLMASK_TOGGLE;
 257        addr = SL811HS_PACKET_BUF(bank == 0);
 258        data_reg = sl811->data_reg;
 259
 260        sl811_write_buf(sl811, addr, buf, len);
 261
 262        /* autoincrementing */
 263        sl811_write(sl811, bank + SL11H_BUFADDRREG, addr);
 264        writeb(len, data_reg);
 265        writeb(SL_OUT | ep->epnum, data_reg);
 266        writeb(usb_pipedevice(urb->pipe), data_reg);
 267
 268        sl811_write(sl811, bank + SL11H_HOSTCTLREG,
 269                        control | SL11H_HCTLMASK_OUT);
 270        ep->length = len;
 271        PACKET("OUT%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "",
 272                        !!usb_gettoggle(urb->dev, ep->epnum, 1), ep, len);
 273}
 274
 275/*-------------------------------------------------------------------------*/
 276
 277/* caller updates on-chip enables later */
 278
 279static inline void sofirq_on(struct sl811 *sl811)
 280{
 281        if (sl811->irq_enable & SL11H_INTMASK_SOFINTR)
 282                return;
 283        dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq on\n");
 284        sl811->irq_enable |= SL11H_INTMASK_SOFINTR;
 285}
 286
 287static inline void sofirq_off(struct sl811 *sl811)
 288{
 289        if (!(sl811->irq_enable & SL11H_INTMASK_SOFINTR))
 290                return;
 291        dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq off\n");
 292        sl811->irq_enable &= ~SL11H_INTMASK_SOFINTR;
 293}
 294
 295/*-------------------------------------------------------------------------*/
 296
 297/* pick the next endpoint for a transaction, and issue it.
 298 * frames start with periodic transfers (after whatever is pending
 299 * from the previous frame), and the rest of the time is async
 300 * transfers, scheduled round-robin.
 301 */
 302static struct sl811h_ep *start(struct sl811 *sl811, u8 bank)
 303{
 304        struct sl811h_ep        *ep;
 305        struct urb              *urb;
 306        int                     fclock;
 307        u8                      control;
 308
 309        /* use endpoint at schedule head */
 310        if (sl811->next_periodic) {
 311                ep = sl811->next_periodic;
 312                sl811->next_periodic = ep->next;
 313        } else {
 314                if (sl811->next_async)
 315                        ep = sl811->next_async;
 316                else if (!list_empty(&sl811->async))
 317                        ep = container_of(sl811->async.next,
 318                                        struct sl811h_ep, schedule);
 319                else {
 320                        /* could set up the first fullspeed periodic
 321                         * transfer for the next frame ...
 322                         */
 323                        return NULL;
 324                }
 325
 326#ifdef USE_B
 327                if ((bank && sl811->active_b == ep) || sl811->active_a == ep)
 328                        return NULL;
 329#endif
 330
 331                if (ep->schedule.next == &sl811->async)
 332                        sl811->next_async = NULL;
 333                else
 334                        sl811->next_async = container_of(ep->schedule.next,
 335                                        struct sl811h_ep, schedule);
 336        }
 337
 338        if (unlikely(list_empty(&ep->hep->urb_list))) {
 339                dev_dbg(sl811_to_hcd(sl811)->self.controller,
 340                        "empty %p queue?\n", ep);
 341                return NULL;
 342        }
 343
 344        urb = container_of(ep->hep->urb_list.next, struct urb, urb_list);
 345        control = ep->defctrl;
 346
 347        /* if this frame doesn't have enough time left to transfer this
 348         * packet, wait till the next frame.  too-simple algorithm...
 349         */
 350        fclock = sl811_read(sl811, SL11H_SOFTMRREG) << 6;
 351        fclock -= 100;          /* setup takes not much time */
 352        if (urb->dev->speed == USB_SPEED_LOW) {
 353                if (control & SL11H_HCTLMASK_PREAMBLE) {
 354                        /* also note erratum 1: some hubs won't work */
 355                        fclock -= 800;
 356                }
 357                fclock -= ep->maxpacket << 8;
 358
 359                /* erratum 2: AFTERSOF only works for fullspeed */
 360                if (fclock < 0) {
 361                        if (ep->period)
 362                                sl811->stat_overrun++;
 363                        sofirq_on(sl811);
 364                        return NULL;
 365                }
 366        } else {
 367                fclock -= 12000 / 19;   /* 19 64byte packets/msec */
 368                if (fclock < 0) {
 369                        if (ep->period)
 370                                sl811->stat_overrun++;
 371                        control |= SL11H_HCTLMASK_AFTERSOF;
 372
 373                /* throttle bulk/control irq noise */
 374                } else if (ep->nak_count)
 375                        control |= SL11H_HCTLMASK_AFTERSOF;
 376        }
 377
 378
 379        switch (ep->nextpid) {
 380        case USB_PID_IN:
 381                in_packet(sl811, ep, urb, bank, control);
 382                break;
 383        case USB_PID_OUT:
 384                out_packet(sl811, ep, urb, bank, control);
 385                break;
 386        case USB_PID_SETUP:
 387                setup_packet(sl811, ep, urb, bank, control);
 388                break;
 389        case USB_PID_ACK:               /* for control status */
 390                status_packet(sl811, ep, urb, bank, control);
 391                break;
 392        default:
 393                dev_dbg(sl811_to_hcd(sl811)->self.controller,
 394                        "bad ep%p pid %02x\n", ep, ep->nextpid);
 395                ep = NULL;
 396        }
 397        return ep;
 398}
 399
 400#define MIN_JIFFIES     ((msecs_to_jiffies(2) > 1) ? msecs_to_jiffies(2) : 2)
 401
 402static inline void start_transfer(struct sl811 *sl811)
 403{
 404        if (sl811->port1 & USB_PORT_STAT_SUSPEND)
 405                return;
 406        if (sl811->active_a == NULL) {
 407                sl811->active_a = start(sl811, SL811_EP_A(SL811_HOST_BUF));
 408                if (sl811->active_a != NULL)
 409                        sl811->jiffies_a = jiffies + MIN_JIFFIES;
 410        }
 411#ifdef USE_B
 412        if (sl811->active_b == NULL) {
 413                sl811->active_b = start(sl811, SL811_EP_B(SL811_HOST_BUF));
 414                if (sl811->active_b != NULL)
 415                        sl811->jiffies_b = jiffies + MIN_JIFFIES;
 416        }
 417#endif
 418}
 419
 420static void finish_request(
 421        struct sl811            *sl811,
 422        struct sl811h_ep        *ep,
 423        struct urb              *urb,
 424        int                     status
 425) __releases(sl811->lock) __acquires(sl811->lock)
 426{
 427        unsigned                i;
 428
 429        if (usb_pipecontrol(urb->pipe))
 430                ep->nextpid = USB_PID_SETUP;
 431
 432        usb_hcd_unlink_urb_from_ep(sl811_to_hcd(sl811), urb);
 433        spin_unlock(&sl811->lock);
 434        usb_hcd_giveback_urb(sl811_to_hcd(sl811), urb, status);
 435        spin_lock(&sl811->lock);
 436
 437        /* leave active endpoints in the schedule */
 438        if (!list_empty(&ep->hep->urb_list))
 439                return;
 440
 441        /* async deschedule? */
 442        if (!list_empty(&ep->schedule)) {
 443                list_del_init(&ep->schedule);
 444                if (ep == sl811->next_async)
 445                        sl811->next_async = NULL;
 446                return;
 447        }
 448
 449        /* periodic deschedule */
 450        dev_dbg(sl811_to_hcd(sl811)->self.controller,
 451                "deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
 452        for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
 453                struct sl811h_ep        *temp;
 454                struct sl811h_ep        **prev = &sl811->periodic[i];
 455
 456                while (*prev && ((temp = *prev) != ep))
 457                        prev = &temp->next;
 458                if (*prev)
 459                        *prev = ep->next;
 460                sl811->load[i] -= ep->load;
 461        }
 462        ep->branch = PERIODIC_SIZE;
 463        sl811->periodic_count--;
 464        sl811_to_hcd(sl811)->self.bandwidth_allocated
 465                -= ep->load / ep->period;
 466        if (ep == sl811->next_periodic)
 467                sl811->next_periodic = ep->next;
 468
 469        /* we might turn SOFs back on again for the async schedule */
 470        if (sl811->periodic_count == 0)
 471                sofirq_off(sl811);
 472}
 473
 474static void
 475done(struct sl811 *sl811, struct sl811h_ep *ep, u8 bank)
 476{
 477        u8                      status;
 478        struct urb              *urb;
 479        int                     urbstat = -EINPROGRESS;
 480
 481        if (unlikely(!ep))
 482                return;
 483
 484        status = sl811_read(sl811, bank + SL11H_PKTSTATREG);
 485
 486        urb = container_of(ep->hep->urb_list.next, struct urb, urb_list);
 487
 488        /* we can safely ignore NAKs */
 489        if (status & SL11H_STATMASK_NAK) {
 490                // PACKET("...NAK_%02x qh%p\n", bank, ep);
 491                if (!ep->period)
 492                        ep->nak_count++;
 493                ep->error_count = 0;
 494
 495        /* ACK advances transfer, toggle, and maybe queue */
 496        } else if (status & SL11H_STATMASK_ACK) {
 497                struct usb_device       *udev = urb->dev;
 498                int                     len;
 499                unsigned char           *buf;
 500
 501                /* urb->iso_frame_desc is currently ignored here... */
 502
 503                ep->nak_count = ep->error_count = 0;
 504                switch (ep->nextpid) {
 505                case USB_PID_OUT:
 506                        // PACKET("...ACK/out_%02x qh%p\n", bank, ep);
 507                        urb->actual_length += ep->length;
 508                        usb_dotoggle(udev, ep->epnum, 1);
 509                        if (urb->actual_length
 510                                        == urb->transfer_buffer_length) {
 511                                if (usb_pipecontrol(urb->pipe))
 512                                        ep->nextpid = USB_PID_ACK;
 513
 514                                /* some bulk protocols terminate OUT transfers
 515                                 * by a short packet, using ZLPs not padding.
 516                                 */
 517                                else if (ep->length < ep->maxpacket
 518                                                || !(urb->transfer_flags
 519                                                        & URB_ZERO_PACKET))
 520                                        urbstat = 0;
 521                        }
 522                        break;
 523                case USB_PID_IN:
 524                        // PACKET("...ACK/in_%02x qh%p\n", bank, ep);
 525                        buf = urb->transfer_buffer + urb->actual_length;
 526                        prefetchw(buf);
 527                        len = ep->maxpacket - sl811_read(sl811,
 528                                                bank + SL11H_XFERCNTREG);
 529                        if (len > ep->length) {
 530                                len = ep->length;
 531                                urbstat = -EOVERFLOW;
 532                        }
 533                        urb->actual_length += len;
 534                        sl811_read_buf(sl811, SL811HS_PACKET_BUF(bank == 0),
 535                                        buf, len);
 536                        usb_dotoggle(udev, ep->epnum, 0);
 537                        if (urbstat == -EINPROGRESS &&
 538                                        (len < ep->maxpacket ||
 539                                                urb->actual_length ==
 540                                                urb->transfer_buffer_length)) {
 541                                if (usb_pipecontrol(urb->pipe))
 542                                        ep->nextpid = USB_PID_ACK;
 543                                else
 544                                        urbstat = 0;
 545                        }
 546                        break;
 547                case USB_PID_SETUP:
 548                        // PACKET("...ACK/setup_%02x qh%p\n", bank, ep);
 549                        if (urb->transfer_buffer_length == urb->actual_length)
 550                                ep->nextpid = USB_PID_ACK;
 551                        else if (usb_pipeout(urb->pipe)) {
 552                                usb_settoggle(udev, 0, 1, 1);
 553                                ep->nextpid = USB_PID_OUT;
 554                        } else {
 555                                usb_settoggle(udev, 0, 0, 1);
 556                                ep->nextpid = USB_PID_IN;
 557                        }
 558                        break;
 559                case USB_PID_ACK:
 560                        // PACKET("...ACK/status_%02x qh%p\n", bank, ep);
 561                        urbstat = 0;
 562                        break;
 563                }
 564
 565        /* STALL stops all transfers */
 566        } else if (status & SL11H_STATMASK_STALL) {
 567                PACKET("...STALL_%02x qh%p\n", bank, ep);
 568                ep->nak_count = ep->error_count = 0;
 569                urbstat = -EPIPE;
 570
 571        /* error? retry, until "3 strikes" */
 572        } else if (++ep->error_count >= 3) {
 573                if (status & SL11H_STATMASK_TMOUT)
 574                        urbstat = -ETIME;
 575                else if (status & SL11H_STATMASK_OVF)
 576                        urbstat = -EOVERFLOW;
 577                else
 578                        urbstat = -EPROTO;
 579                ep->error_count = 0;
 580                PACKET("...3STRIKES_%02x %02x qh%p stat %d\n",
 581                                bank, status, ep, urbstat);
 582        }
 583
 584        if (urbstat != -EINPROGRESS || urb->unlinked)
 585                finish_request(sl811, ep, urb, urbstat);
 586}
 587
 588static inline u8 checkdone(struct sl811 *sl811)
 589{
 590        u8      ctl;
 591        u8      irqstat = 0;
 592
 593        if (sl811->active_a && time_before_eq(sl811->jiffies_a, jiffies)) {
 594                ctl = sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG));
 595                if (ctl & SL11H_HCTLMASK_ARM)
 596                        sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0);
 597                dev_dbg(sl811_to_hcd(sl811)->self.controller,
 598                        "%s DONE_A: ctrl %02x sts %02x\n",
 599                        (ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost",
 600                        ctl,
 601                        sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG)));
 602                irqstat |= SL11H_INTMASK_DONE_A;
 603        }
 604#ifdef  USE_B
 605        if (sl811->active_b && time_before_eq(sl811->jiffies_b, jiffies)) {
 606                ctl = sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG));
 607                if (ctl & SL11H_HCTLMASK_ARM)
 608                        sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0);
 609                dev_dbg(sl811_to_hcd(sl811)->self.controller,
 610                        "%s DONE_B: ctrl %02x sts %02x\n",
 611                        (ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost",
 612                        ctl,
 613                        sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG)));
 614                irqstat |= SL11H_INTMASK_DONE_A;
 615        }
 616#endif
 617        return irqstat;
 618}
 619
 620static irqreturn_t sl811h_irq(struct usb_hcd *hcd)
 621{
 622        struct sl811    *sl811 = hcd_to_sl811(hcd);
 623        u8              irqstat;
 624        irqreturn_t     ret = IRQ_NONE;
 625        unsigned        retries = 5;
 626
 627        spin_lock(&sl811->lock);
 628
 629retry:
 630        irqstat = sl811_read(sl811, SL11H_IRQ_STATUS) & ~SL11H_INTMASK_DP;
 631        if (irqstat) {
 632                sl811_write(sl811, SL11H_IRQ_STATUS, irqstat);
 633                irqstat &= sl811->irq_enable;
 634        }
 635
 636#ifdef  QUIRK2
 637        /* this may no longer be necessary ... */
 638        if (irqstat == 0) {
 639                irqstat = checkdone(sl811);
 640                if (irqstat)
 641                        sl811->stat_lost++;
 642        }
 643#endif
 644
 645        /* USB packets, not necessarily handled in the order they're
 646         * issued ... that's fine if they're different endpoints.
 647         */
 648        if (irqstat & SL11H_INTMASK_DONE_A) {
 649                done(sl811, sl811->active_a, SL811_EP_A(SL811_HOST_BUF));
 650                sl811->active_a = NULL;
 651                sl811->stat_a++;
 652        }
 653#ifdef USE_B
 654        if (irqstat & SL11H_INTMASK_DONE_B) {
 655                done(sl811, sl811->active_b, SL811_EP_B(SL811_HOST_BUF));
 656                sl811->active_b = NULL;
 657                sl811->stat_b++;
 658        }
 659#endif
 660        if (irqstat & SL11H_INTMASK_SOFINTR) {
 661                unsigned index;
 662
 663                index = sl811->frame++ % (PERIODIC_SIZE - 1);
 664                sl811->stat_sof++;
 665
 666                /* be graceful about almost-inevitable periodic schedule
 667                 * overruns:  continue the previous frame's transfers iff
 668                 * this one has nothing scheduled.
 669                 */
 670                if (sl811->next_periodic) {
 671                        // dev_err(hcd->self.controller, "overrun to slot %d\n", index);
 672                        sl811->stat_overrun++;
 673                }
 674                if (sl811->periodic[index])
 675                        sl811->next_periodic = sl811->periodic[index];
 676        }
 677
 678        /* hub_wq manages debouncing and wakeup */
 679        if (irqstat & SL11H_INTMASK_INSRMV) {
 680                sl811->stat_insrmv++;
 681
 682                /* most stats are reset for each VBUS session */
 683                sl811->stat_wake = 0;
 684                sl811->stat_sof = 0;
 685                sl811->stat_a = 0;
 686                sl811->stat_b = 0;
 687                sl811->stat_lost = 0;
 688
 689                sl811->ctrl1 = 0;
 690                sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
 691
 692                sl811->irq_enable = SL11H_INTMASK_INSRMV;
 693                sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
 694
 695                /* usbcore nukes other pending transactions on disconnect */
 696                if (sl811->active_a) {
 697                        sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0);
 698                        finish_request(sl811, sl811->active_a,
 699                                container_of(sl811->active_a
 700                                                ->hep->urb_list.next,
 701                                        struct urb, urb_list),
 702                                -ESHUTDOWN);
 703                        sl811->active_a = NULL;
 704                }
 705#ifdef  USE_B
 706                if (sl811->active_b) {
 707                        sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0);
 708                        finish_request(sl811, sl811->active_b,
 709                                container_of(sl811->active_b
 710                                                ->hep->urb_list.next,
 711                                        struct urb, urb_list),
 712                                NULL, -ESHUTDOWN);
 713                        sl811->active_b = NULL;
 714                }
 715#endif
 716
 717                /* port status seems weird until after reset, so
 718                 * force the reset and make hub_wq clean up later.
 719                 */
 720                if (irqstat & SL11H_INTMASK_RD)
 721                        sl811->port1 &= ~USB_PORT_STAT_CONNECTION;
 722                else
 723                        sl811->port1 |= USB_PORT_STAT_CONNECTION;
 724
 725                sl811->port1 |= USB_PORT_STAT_C_CONNECTION << 16;
 726
 727        } else if (irqstat & SL11H_INTMASK_RD) {
 728                if (sl811->port1 & USB_PORT_STAT_SUSPEND) {
 729                        dev_dbg(hcd->self.controller, "wakeup\n");
 730                        sl811->port1 |= USB_PORT_STAT_C_SUSPEND << 16;
 731                        sl811->stat_wake++;
 732                } else
 733                        irqstat &= ~SL11H_INTMASK_RD;
 734        }
 735
 736        if (irqstat) {
 737                if (sl811->port1 & USB_PORT_STAT_ENABLE)
 738                        start_transfer(sl811);
 739                ret = IRQ_HANDLED;
 740                if (retries--)
 741                        goto retry;
 742        }
 743
 744        if (sl811->periodic_count == 0 && list_empty(&sl811->async))
 745                sofirq_off(sl811);
 746        sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
 747
 748        spin_unlock(&sl811->lock);
 749
 750        return ret;
 751}
 752
 753/*-------------------------------------------------------------------------*/
 754
 755/* usb 1.1 says max 90% of a frame is available for periodic transfers.
 756 * this driver doesn't promise that much since it's got to handle an
 757 * IRQ per packet; irq handling latencies also use up that time.
 758 *
 759 * NOTE:  the periodic schedule is a sparse tree, with the load for
 760 * each branch minimized.  see fig 3.5 in the OHCI spec for example.
 761 */
 762#define MAX_PERIODIC_LOAD       500     /* out of 1000 usec */
 763
 764static int balance(struct sl811 *sl811, u16 period, u16 load)
 765{
 766        int     i, branch = -ENOSPC;
 767
 768        /* search for the least loaded schedule branch of that period
 769         * which has enough bandwidth left unreserved.
 770         */
 771        for (i = 0; i < period ; i++) {
 772                if (branch < 0 || sl811->load[branch] > sl811->load[i]) {
 773                        int     j;
 774
 775                        for (j = i; j < PERIODIC_SIZE; j += period) {
 776                                if ((sl811->load[j] + load)
 777                                                > MAX_PERIODIC_LOAD)
 778                                        break;
 779                        }
 780                        if (j < PERIODIC_SIZE)
 781                                continue;
 782                        branch = i;
 783                }
 784        }
 785        return branch;
 786}
 787
 788/*-------------------------------------------------------------------------*/
 789
 790static int sl811h_urb_enqueue(
 791        struct usb_hcd          *hcd,
 792        struct urb              *urb,
 793        gfp_t                   mem_flags
 794) {
 795        struct sl811            *sl811 = hcd_to_sl811(hcd);
 796        struct usb_device       *udev = urb->dev;
 797        unsigned int            pipe = urb->pipe;
 798        int                     is_out = !usb_pipein(pipe);
 799        int                     type = usb_pipetype(pipe);
 800        int                     epnum = usb_pipeendpoint(pipe);
 801        struct sl811h_ep        *ep = NULL;
 802        unsigned long           flags;
 803        int                     i;
 804        int                     retval;
 805        struct usb_host_endpoint        *hep = urb->ep;
 806
 807#ifndef CONFIG_USB_SL811_HCD_ISO
 808        if (type == PIPE_ISOCHRONOUS)
 809                return -ENOSPC;
 810#endif
 811
 812        /* avoid all allocations within spinlocks */
 813        if (!hep->hcpriv) {
 814                ep = kzalloc(sizeof *ep, mem_flags);
 815                if (ep == NULL)
 816                        return -ENOMEM;
 817        }
 818
 819        spin_lock_irqsave(&sl811->lock, flags);
 820
 821        /* don't submit to a dead or disabled port */
 822        if (!(sl811->port1 & USB_PORT_STAT_ENABLE)
 823                        || !HC_IS_RUNNING(hcd->state)) {
 824                retval = -ENODEV;
 825                kfree(ep);
 826                goto fail_not_linked;
 827        }
 828        retval = usb_hcd_link_urb_to_ep(hcd, urb);
 829        if (retval) {
 830                kfree(ep);
 831                goto fail_not_linked;
 832        }
 833
 834        if (hep->hcpriv) {
 835                kfree(ep);
 836                ep = hep->hcpriv;
 837        } else if (!ep) {
 838                retval = -ENOMEM;
 839                goto fail;
 840
 841        } else {
 842                INIT_LIST_HEAD(&ep->schedule);
 843                ep->udev = udev;
 844                ep->epnum = epnum;
 845                ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
 846                ep->defctrl = SL11H_HCTLMASK_ARM | SL11H_HCTLMASK_ENABLE;
 847                usb_settoggle(udev, epnum, is_out, 0);
 848
 849                if (type == PIPE_CONTROL)
 850                        ep->nextpid = USB_PID_SETUP;
 851                else if (is_out)
 852                        ep->nextpid = USB_PID_OUT;
 853                else
 854                        ep->nextpid = USB_PID_IN;
 855
 856                if (ep->maxpacket > H_MAXPACKET) {
 857                        /* iso packets up to 240 bytes could work... */
 858                        dev_dbg(hcd->self.controller,
 859                                "dev %d ep%d maxpacket %d\n", udev->devnum,
 860                                epnum, ep->maxpacket);
 861                        retval = -EINVAL;
 862                        kfree(ep);
 863                        goto fail;
 864                }
 865
 866                if (udev->speed == USB_SPEED_LOW) {
 867                        /* send preamble for external hub? */
 868                        if (!(sl811->ctrl1 & SL11H_CTL1MASK_LSPD))
 869                                ep->defctrl |= SL11H_HCTLMASK_PREAMBLE;
 870                }
 871                switch (type) {
 872                case PIPE_ISOCHRONOUS:
 873                case PIPE_INTERRUPT:
 874                        if (urb->interval > PERIODIC_SIZE)
 875                                urb->interval = PERIODIC_SIZE;
 876                        ep->period = urb->interval;
 877                        ep->branch = PERIODIC_SIZE;
 878                        if (type == PIPE_ISOCHRONOUS)
 879                                ep->defctrl |= SL11H_HCTLMASK_ISOCH;
 880                        ep->load = usb_calc_bus_time(udev->speed, !is_out,
 881                                (type == PIPE_ISOCHRONOUS),
 882                                usb_maxpacket(udev, pipe, is_out))
 883                                        / 1000;
 884                        break;
 885                }
 886
 887                ep->hep = hep;
 888                hep->hcpriv = ep;
 889        }
 890
 891        /* maybe put endpoint into schedule */
 892        switch (type) {
 893        case PIPE_CONTROL:
 894        case PIPE_BULK:
 895                if (list_empty(&ep->schedule))
 896                        list_add_tail(&ep->schedule, &sl811->async);
 897                break;
 898        case PIPE_ISOCHRONOUS:
 899        case PIPE_INTERRUPT:
 900                urb->interval = ep->period;
 901                if (ep->branch < PERIODIC_SIZE) {
 902                        /* NOTE:  the phase is correct here, but the value
 903                         * needs offsetting by the transfer queue depth.
 904                         * All current drivers ignore start_frame, so this
 905                         * is unlikely to ever matter...
 906                         */
 907                        urb->start_frame = (sl811->frame & (PERIODIC_SIZE - 1))
 908                                                + ep->branch;
 909                        break;
 910                }
 911
 912                retval = balance(sl811, ep->period, ep->load);
 913                if (retval < 0)
 914                        goto fail;
 915                ep->branch = retval;
 916                retval = 0;
 917                urb->start_frame = (sl811->frame & (PERIODIC_SIZE - 1))
 918                                        + ep->branch;
 919
 920                /* sort each schedule branch by period (slow before fast)
 921                 * to share the faster parts of the tree without needing
 922                 * dummy/placeholder nodes
 923                 */
 924                dev_dbg(hcd->self.controller, "schedule qh%d/%p branch %d\n",
 925                        ep->period, ep, ep->branch);
 926                for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
 927                        struct sl811h_ep        **prev = &sl811->periodic[i];
 928                        struct sl811h_ep        *here = *prev;
 929
 930                        while (here && ep != here) {
 931                                if (ep->period > here->period)
 932                                        break;
 933                                prev = &here->next;
 934                                here = *prev;
 935                        }
 936                        if (ep != here) {
 937                                ep->next = here;
 938                                *prev = ep;
 939                        }
 940                        sl811->load[i] += ep->load;
 941                }
 942                sl811->periodic_count++;
 943                hcd->self.bandwidth_allocated += ep->load / ep->period;
 944                sofirq_on(sl811);
 945        }
 946
 947        urb->hcpriv = hep;
 948        start_transfer(sl811);
 949        sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
 950fail:
 951        if (retval)
 952                usb_hcd_unlink_urb_from_ep(hcd, urb);
 953fail_not_linked:
 954        spin_unlock_irqrestore(&sl811->lock, flags);
 955        return retval;
 956}
 957
 958static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
 959{
 960        struct sl811            *sl811 = hcd_to_sl811(hcd);
 961        struct usb_host_endpoint *hep;
 962        unsigned long           flags;
 963        struct sl811h_ep        *ep;
 964        int                     retval;
 965
 966        spin_lock_irqsave(&sl811->lock, flags);
 967        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
 968        if (retval)
 969                goto fail;
 970
 971        hep = urb->hcpriv;
 972        ep = hep->hcpriv;
 973        if (ep) {
 974                /* finish right away if this urb can't be active ...
 975                 * note that some drivers wrongly expect delays
 976                 */
 977                if (ep->hep->urb_list.next != &urb->urb_list) {
 978                        /* not front of queue?  never active */
 979
 980                /* for active transfers, we expect an IRQ */
 981                } else if (sl811->active_a == ep) {
 982                        if (time_before_eq(sl811->jiffies_a, jiffies)) {
 983                                /* happens a lot with lowspeed?? */
 984                                dev_dbg(hcd->self.controller,
 985                                        "giveup on DONE_A: ctrl %02x sts %02x\n",
 986                                        sl811_read(sl811,
 987                                                SL811_EP_A(SL11H_HOSTCTLREG)),
 988                                        sl811_read(sl811,
 989                                                SL811_EP_A(SL11H_PKTSTATREG)));
 990                                sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG),
 991                                                0);
 992                                sl811->active_a = NULL;
 993                        } else
 994                                urb = NULL;
 995#ifdef  USE_B
 996                } else if (sl811->active_b == ep) {
 997                        if (time_before_eq(sl811->jiffies_a, jiffies)) {
 998                                /* happens a lot with lowspeed?? */
 999                                dev_dbg(hcd->self.controller,
1000                                        "giveup on DONE_B: ctrl %02x sts %02x\n",
1001                                        sl811_read(sl811,
1002                                                SL811_EP_B(SL11H_HOSTCTLREG)),
1003                                        sl811_read(sl811,
1004                                                SL811_EP_B(SL11H_PKTSTATREG)));
1005                                sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG),
1006                                                0);
1007                                sl811->active_b = NULL;
1008                        } else
1009                                urb = NULL;
1010#endif
1011                } else {
1012                        /* front of queue for inactive endpoint */
1013                }
1014
1015                if (urb)
1016                        finish_request(sl811, ep, urb, 0);
1017                else
1018                        dev_dbg(sl811_to_hcd(sl811)->self.controller,
1019                                "dequeue, urb %p active %s; wait4irq\n", urb,
1020                                (sl811->active_a == ep) ? "A" : "B");
1021        } else
1022                retval = -EINVAL;
1023 fail:
1024        spin_unlock_irqrestore(&sl811->lock, flags);
1025        return retval;
1026}
1027
1028static void
1029sl811h_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
1030{
1031        struct sl811h_ep        *ep = hep->hcpriv;
1032
1033        if (!ep)
1034                return;
1035
1036        /* assume we'd just wait for the irq */
1037        if (!list_empty(&hep->urb_list))
1038                msleep(3);
1039        if (!list_empty(&hep->urb_list))
1040                dev_warn(hcd->self.controller, "ep %p not empty?\n", ep);
1041
1042        kfree(ep);
1043        hep->hcpriv = NULL;
1044}
1045
1046static int
1047sl811h_get_frame(struct usb_hcd *hcd)
1048{
1049        struct sl811 *sl811 = hcd_to_sl811(hcd);
1050
1051        /* wrong except while periodic transfers are scheduled;
1052         * never matches the on-the-wire frame;
1053         * subject to overruns.
1054         */
1055        return sl811->frame;
1056}
1057
1058
1059/*-------------------------------------------------------------------------*/
1060
1061/* the virtual root hub timer IRQ checks for hub status */
1062static int
1063sl811h_hub_status_data(struct usb_hcd *hcd, char *buf)
1064{
1065        struct sl811 *sl811 = hcd_to_sl811(hcd);
1066#ifdef  QUIRK3
1067        unsigned long flags;
1068
1069        /* non-SMP HACK: use root hub timer as i/o watchdog
1070         * this seems essential when SOF IRQs aren't in use...
1071         */
1072        local_irq_save(flags);
1073        if (!timer_pending(&sl811->timer)) {
1074                if (sl811h_irq( /* ~0, */ hcd) != IRQ_NONE)
1075                        sl811->stat_lost++;
1076        }
1077        local_irq_restore(flags);
1078#endif
1079
1080        if (!(sl811->port1 & (0xffff << 16)))
1081                return 0;
1082
1083        /* tell hub_wq port 1 changed */
1084        *buf = (1 << 1);
1085        return 1;
1086}
1087
1088static void
1089sl811h_hub_descriptor (
1090        struct sl811                    *sl811,
1091        struct usb_hub_descriptor       *desc
1092) {
1093        u16             temp = 0;
1094
1095        desc->bDescriptorType = USB_DT_HUB;
1096        desc->bHubContrCurrent = 0;
1097
1098        desc->bNbrPorts = 1;
1099        desc->bDescLength = 9;
1100
1101        /* per-port power switching (gang of one!), or none */
1102        desc->bPwrOn2PwrGood = 0;
1103        if (sl811->board && sl811->board->port_power) {
1104                desc->bPwrOn2PwrGood = sl811->board->potpg;
1105                if (!desc->bPwrOn2PwrGood)
1106                        desc->bPwrOn2PwrGood = 10;
1107                temp = HUB_CHAR_INDV_PORT_LPSM;
1108        } else
1109                temp = HUB_CHAR_NO_LPSM;
1110
1111        /* no overcurrent errors detection/handling */
1112        temp |= HUB_CHAR_NO_OCPM;
1113
1114        desc->wHubCharacteristics = cpu_to_le16(temp);
1115
1116        /* ports removable, and legacy PortPwrCtrlMask */
1117        desc->u.hs.DeviceRemovable[0] = 0 << 1;
1118        desc->u.hs.DeviceRemovable[1] = ~0;
1119}
1120
1121static void
1122sl811h_timer(struct timer_list *t)
1123{
1124        struct sl811    *sl811 = from_timer(sl811, t, timer);
1125        unsigned long   flags;
1126        u8              irqstat;
1127        u8              signaling = sl811->ctrl1 & SL11H_CTL1MASK_FORCE;
1128        const u32       mask = USB_PORT_STAT_CONNECTION
1129                                | USB_PORT_STAT_ENABLE
1130                                | USB_PORT_STAT_LOW_SPEED;
1131
1132        spin_lock_irqsave(&sl811->lock, flags);
1133
1134        /* stop special signaling */
1135        sl811->ctrl1 &= ~SL11H_CTL1MASK_FORCE;
1136        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
1137        udelay(3);
1138
1139        irqstat = sl811_read(sl811, SL11H_IRQ_STATUS);
1140
1141        switch (signaling) {
1142        case SL11H_CTL1MASK_SE0:
1143                dev_dbg(sl811_to_hcd(sl811)->self.controller, "end reset\n");
1144                sl811->port1 = (USB_PORT_STAT_C_RESET << 16)
1145                                 | USB_PORT_STAT_POWER;
1146                sl811->ctrl1 = 0;
1147                /* don't wrongly ack RD */
1148                if (irqstat & SL11H_INTMASK_INSRMV)
1149                        irqstat &= ~SL11H_INTMASK_RD;
1150                break;
1151        case SL11H_CTL1MASK_K:
1152                dev_dbg(sl811_to_hcd(sl811)->self.controller, "end resume\n");
1153                sl811->port1 &= ~USB_PORT_STAT_SUSPEND;
1154                break;
1155        default:
1156                dev_dbg(sl811_to_hcd(sl811)->self.controller,
1157                        "odd timer signaling: %02x\n", signaling);
1158                break;
1159        }
1160        sl811_write(sl811, SL11H_IRQ_STATUS, irqstat);
1161
1162        if (irqstat & SL11H_INTMASK_RD) {
1163                /* usbcore nukes all pending transactions on disconnect */
1164                if (sl811->port1 & USB_PORT_STAT_CONNECTION)
1165                        sl811->port1 |= (USB_PORT_STAT_C_CONNECTION << 16)
1166                                        | (USB_PORT_STAT_C_ENABLE << 16);
1167                sl811->port1 &= ~mask;
1168                sl811->irq_enable = SL11H_INTMASK_INSRMV;
1169        } else {
1170                sl811->port1 |= mask;
1171                if (irqstat & SL11H_INTMASK_DP)
1172                        sl811->port1 &= ~USB_PORT_STAT_LOW_SPEED;
1173                sl811->irq_enable = SL11H_INTMASK_INSRMV | SL11H_INTMASK_RD;
1174        }
1175
1176        if (sl811->port1 & USB_PORT_STAT_CONNECTION) {
1177                u8      ctrl2 = SL811HS_CTL2_INIT;
1178
1179                sl811->irq_enable |= SL11H_INTMASK_DONE_A;
1180#ifdef USE_B
1181                sl811->irq_enable |= SL11H_INTMASK_DONE_B;
1182#endif
1183                if (sl811->port1 & USB_PORT_STAT_LOW_SPEED) {
1184                        sl811->ctrl1 |= SL11H_CTL1MASK_LSPD;
1185                        ctrl2 |= SL811HS_CTL2MASK_DSWAP;
1186                }
1187
1188                /* start SOFs flowing, kickstarting with A registers */
1189                sl811->ctrl1 |= SL11H_CTL1MASK_SOF_ENA;
1190                sl811_write(sl811, SL11H_SOFLOWREG, 0xe0);
1191                sl811_write(sl811, SL811HS_CTLREG2, ctrl2);
1192
1193                /* autoincrementing */
1194                sl811_write(sl811, SL811_EP_A(SL11H_BUFLNTHREG), 0);
1195                writeb(SL_SOF, sl811->data_reg);
1196                writeb(0, sl811->data_reg);
1197                sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG),
1198                                SL11H_HCTLMASK_ARM);
1199
1200                /* hub_wq provides debounce delay */
1201        } else {
1202                sl811->ctrl1 = 0;
1203        }
1204        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
1205
1206        /* reenable irqs */
1207        sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
1208        spin_unlock_irqrestore(&sl811->lock, flags);
1209}
1210
1211static int
1212sl811h_hub_control(
1213        struct usb_hcd  *hcd,
1214        u16             typeReq,
1215        u16             wValue,
1216        u16             wIndex,
1217        char            *buf,
1218        u16             wLength
1219) {
1220        struct sl811    *sl811 = hcd_to_sl811(hcd);
1221        int             retval = 0;
1222        unsigned long   flags;
1223
1224        spin_lock_irqsave(&sl811->lock, flags);
1225
1226        switch (typeReq) {
1227        case ClearHubFeature:
1228        case SetHubFeature:
1229                switch (wValue) {
1230                case C_HUB_OVER_CURRENT:
1231                case C_HUB_LOCAL_POWER:
1232                        break;
1233                default:
1234                        goto error;
1235                }
1236                break;
1237        case ClearPortFeature:
1238                if (wIndex != 1 || wLength != 0)
1239                        goto error;
1240
1241                switch (wValue) {
1242                case USB_PORT_FEAT_ENABLE:
1243                        sl811->port1 &= USB_PORT_STAT_POWER;
1244                        sl811->ctrl1 = 0;
1245                        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
1246                        sl811->irq_enable = SL11H_INTMASK_INSRMV;
1247                        sl811_write(sl811, SL11H_IRQ_ENABLE,
1248                                                sl811->irq_enable);
1249                        break;
1250                case USB_PORT_FEAT_SUSPEND:
1251                        if (!(sl811->port1 & USB_PORT_STAT_SUSPEND))
1252                                break;
1253
1254                        /* 20 msec of resume/K signaling, other irqs blocked */
1255                        dev_dbg(hcd->self.controller, "start resume...\n");
1256                        sl811->irq_enable = 0;
1257                        sl811_write(sl811, SL11H_IRQ_ENABLE,
1258                                                sl811->irq_enable);
1259                        sl811->ctrl1 |= SL11H_CTL1MASK_K;
1260                        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
1261
1262                        mod_timer(&sl811->timer, jiffies
1263                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT));
1264                        break;
1265                case USB_PORT_FEAT_POWER:
1266                        port_power(sl811, 0);
1267                        break;
1268                case USB_PORT_FEAT_C_ENABLE:
1269                case USB_PORT_FEAT_C_SUSPEND:
1270                case USB_PORT_FEAT_C_CONNECTION:
1271                case USB_PORT_FEAT_C_OVER_CURRENT:
1272                case USB_PORT_FEAT_C_RESET:
1273                        break;
1274                default:
1275                        goto error;
1276                }
1277                sl811->port1 &= ~(1 << wValue);
1278                break;
1279        case GetHubDescriptor:
1280                sl811h_hub_descriptor(sl811, (struct usb_hub_descriptor *) buf);
1281                break;
1282        case GetHubStatus:
1283                put_unaligned_le32(0, buf);
1284                break;
1285        case GetPortStatus:
1286                if (wIndex != 1)
1287                        goto error;
1288                put_unaligned_le32(sl811->port1, buf);
1289
1290                if (__is_defined(VERBOSE) ||
1291                    *(u16*)(buf+2)) /* only if wPortChange is interesting */
1292                        dev_dbg(hcd->self.controller, "GetPortStatus %08x\n",
1293                                sl811->port1);
1294                break;
1295        case SetPortFeature:
1296                if (wIndex != 1 || wLength != 0)
1297                        goto error;
1298                switch (wValue) {
1299                case USB_PORT_FEAT_SUSPEND:
1300                        if (sl811->port1 & USB_PORT_STAT_RESET)
1301                                goto error;
1302                        if (!(sl811->port1 & USB_PORT_STAT_ENABLE))
1303                                goto error;
1304
1305                        dev_dbg(hcd->self.controller,"suspend...\n");
1306                        sl811->ctrl1 &= ~SL11H_CTL1MASK_SOF_ENA;
1307                        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
1308                        break;
1309                case USB_PORT_FEAT_POWER:
1310                        port_power(sl811, 1);
1311                        break;
1312                case USB_PORT_FEAT_RESET:
1313                        if (sl811->port1 & USB_PORT_STAT_SUSPEND)
1314                                goto error;
1315                        if (!(sl811->port1 & USB_PORT_STAT_POWER))
1316                                break;
1317
1318                        /* 50 msec of reset/SE0 signaling, irqs blocked */
1319                        sl811->irq_enable = 0;
1320                        sl811_write(sl811, SL11H_IRQ_ENABLE,
1321                                                sl811->irq_enable);
1322                        sl811->ctrl1 = SL11H_CTL1MASK_SE0;
1323                        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
1324                        sl811->port1 |= USB_PORT_STAT_RESET;
1325                        mod_timer(&sl811->timer, jiffies
1326                                        + msecs_to_jiffies(50));
1327                        break;
1328                default:
1329                        goto error;
1330                }
1331                sl811->port1 |= 1 << wValue;
1332                break;
1333
1334        default:
1335error:
1336                /* "protocol stall" on error */
1337                retval = -EPIPE;
1338        }
1339
1340        spin_unlock_irqrestore(&sl811->lock, flags);
1341        return retval;
1342}
1343
1344#ifdef  CONFIG_PM
1345
1346static int
1347sl811h_bus_suspend(struct usb_hcd *hcd)
1348{
1349        // SOFs off
1350        dev_dbg(hcd->self.controller, "%s\n", __func__);
1351        return 0;
1352}
1353
1354static int
1355sl811h_bus_resume(struct usb_hcd *hcd)
1356{
1357        // SOFs on
1358        dev_dbg(hcd->self.controller, "%s\n", __func__);
1359        return 0;
1360}
1361
1362#else
1363
1364#define sl811h_bus_suspend      NULL
1365#define sl811h_bus_resume       NULL
1366
1367#endif
1368
1369
1370/*-------------------------------------------------------------------------*/
1371
1372static void dump_irq(struct seq_file *s, char *label, u8 mask)
1373{
1374        seq_printf(s, "%s %02x%s%s%s%s%s%s\n", label, mask,
1375                (mask & SL11H_INTMASK_DONE_A) ? " done_a" : "",
1376                (mask & SL11H_INTMASK_DONE_B) ? " done_b" : "",
1377                (mask & SL11H_INTMASK_SOFINTR) ? " sof" : "",
1378                (mask & SL11H_INTMASK_INSRMV) ? " ins/rmv" : "",
1379                (mask & SL11H_INTMASK_RD) ? " rd" : "",
1380                (mask & SL11H_INTMASK_DP) ? " dp" : "");
1381}
1382
1383static int sl811h_debug_show(struct seq_file *s, void *unused)
1384{
1385        struct sl811            *sl811 = s->private;
1386        struct sl811h_ep        *ep;
1387        unsigned                i;
1388
1389        seq_printf(s, "%s\n%s version %s\nportstatus[1] = %08x\n",
1390                sl811_to_hcd(sl811)->product_desc,
1391                hcd_name, DRIVER_VERSION,
1392                sl811->port1);
1393
1394        seq_printf(s, "insert/remove: %ld\n", sl811->stat_insrmv);
1395        seq_printf(s, "current session:  done_a %ld done_b %ld "
1396                        "wake %ld sof %ld overrun %ld lost %ld\n\n",
1397                sl811->stat_a, sl811->stat_b,
1398                sl811->stat_wake, sl811->stat_sof,
1399                sl811->stat_overrun, sl811->stat_lost);
1400
1401        spin_lock_irq(&sl811->lock);
1402
1403        if (sl811->ctrl1 & SL11H_CTL1MASK_SUSPEND)
1404                seq_printf(s, "(suspended)\n\n");
1405        else {
1406                u8      t = sl811_read(sl811, SL11H_CTLREG1);
1407
1408                seq_printf(s, "ctrl1 %02x%s%s%s%s\n", t,
1409                        (t & SL11H_CTL1MASK_SOF_ENA) ? " sofgen" : "",
1410                        ({char *s; switch (t & SL11H_CTL1MASK_FORCE) {
1411                        case SL11H_CTL1MASK_NORMAL: s = ""; break;
1412                        case SL11H_CTL1MASK_SE0: s = " se0/reset"; break;
1413                        case SL11H_CTL1MASK_K: s = " k/resume"; break;
1414                        default: s = "j"; break;
1415                        } s; }),
1416                        (t & SL11H_CTL1MASK_LSPD) ? " lowspeed" : "",
1417                        (t & SL11H_CTL1MASK_SUSPEND) ? " suspend" : "");
1418
1419                dump_irq(s, "irq_enable",
1420                                sl811_read(sl811, SL11H_IRQ_ENABLE));
1421                dump_irq(s, "irq_status",
1422                                sl811_read(sl811, SL11H_IRQ_STATUS));
1423                seq_printf(s, "frame clocks remaining:  %d\n",
1424                                sl811_read(sl811, SL11H_SOFTMRREG) << 6);
1425        }
1426
1427        seq_printf(s, "A: qh%p ctl %02x sts %02x\n", sl811->active_a,
1428                sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG)),
1429                sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG)));
1430        seq_printf(s, "B: qh%p ctl %02x sts %02x\n", sl811->active_b,
1431                sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG)),
1432                sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG)));
1433        seq_printf(s, "\n");
1434        list_for_each_entry (ep, &sl811->async, schedule) {
1435                struct urb              *urb;
1436
1437                seq_printf(s, "%s%sqh%p, ep%d%s, maxpacket %d"
1438                                        " nak %d err %d\n",
1439                        (ep == sl811->active_a) ? "(A) " : "",
1440                        (ep == sl811->active_b) ? "(B) " : "",
1441                        ep, ep->epnum,
1442                        ({ char *s; switch (ep->nextpid) {
1443                        case USB_PID_IN: s = "in"; break;
1444                        case USB_PID_OUT: s = "out"; break;
1445                        case USB_PID_SETUP: s = "setup"; break;
1446                        case USB_PID_ACK: s = "status"; break;
1447                        default: s = "?"; break;
1448                        } s;}),
1449                        ep->maxpacket,
1450                        ep->nak_count, ep->error_count);
1451                list_for_each_entry (urb, &ep->hep->urb_list, urb_list) {
1452                        seq_printf(s, "  urb%p, %d/%d\n", urb,
1453                                urb->actual_length,
1454                                urb->transfer_buffer_length);
1455                }
1456        }
1457        if (!list_empty(&sl811->async))
1458                seq_printf(s, "\n");
1459
1460        seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
1461
1462        for (i = 0; i < PERIODIC_SIZE; i++) {
1463                ep = sl811->periodic[i];
1464                if (!ep)
1465                        continue;
1466                seq_printf(s, "%2d [%3d]:\n", i, sl811->load[i]);
1467
1468                /* DUMB: prints shared entries multiple times */
1469                do {
1470                        seq_printf(s,
1471                                "   %s%sqh%d/%p (%sdev%d ep%d%s max %d) "
1472                                        "err %d\n",
1473                                (ep == sl811->active_a) ? "(A) " : "",
1474                                (ep == sl811->active_b) ? "(B) " : "",
1475                                ep->period, ep,
1476                                (ep->udev->speed == USB_SPEED_FULL)
1477                                        ? "" : "ls ",
1478                                ep->udev->devnum, ep->epnum,
1479                                (ep->epnum == 0) ? ""
1480                                        : ((ep->nextpid == USB_PID_IN)
1481                                                ? "in"
1482                                                : "out"),
1483                                ep->maxpacket, ep->error_count);
1484                        ep = ep->next;
1485                } while (ep);
1486        }
1487
1488        spin_unlock_irq(&sl811->lock);
1489        seq_printf(s, "\n");
1490
1491        return 0;
1492}
1493DEFINE_SHOW_ATTRIBUTE(sl811h_debug);
1494
1495/* expect just one sl811 per system */
1496static void create_debug_file(struct sl811 *sl811)
1497{
1498        debugfs_create_file("sl811h", S_IRUGO, usb_debug_root, sl811,
1499                            &sl811h_debug_fops);
1500}
1501
1502static void remove_debug_file(struct sl811 *sl811)
1503{
1504        debugfs_remove(debugfs_lookup("sl811h", usb_debug_root));
1505}
1506
1507/*-------------------------------------------------------------------------*/
1508
1509static void
1510sl811h_stop(struct usb_hcd *hcd)
1511{
1512        struct sl811    *sl811 = hcd_to_sl811(hcd);
1513        unsigned long   flags;
1514
1515        del_timer_sync(&hcd->rh_timer);
1516
1517        spin_lock_irqsave(&sl811->lock, flags);
1518        port_power(sl811, 0);
1519        spin_unlock_irqrestore(&sl811->lock, flags);
1520}
1521
1522static int
1523sl811h_start(struct usb_hcd *hcd)
1524{
1525        struct sl811            *sl811 = hcd_to_sl811(hcd);
1526
1527        /* chip has been reset, VBUS power is off */
1528        hcd->state = HC_STATE_RUNNING;
1529
1530        if (sl811->board) {
1531                if (!device_can_wakeup(hcd->self.controller))
1532                        device_init_wakeup(hcd->self.controller,
1533                                sl811->board->can_wakeup);
1534                hcd->power_budget = sl811->board->power * 2;
1535        }
1536
1537        /* enable power and interrupts */
1538        port_power(sl811, 1);
1539
1540        return 0;
1541}
1542
1543/*-------------------------------------------------------------------------*/
1544
1545static const struct hc_driver sl811h_hc_driver = {
1546        .description =          hcd_name,
1547        .hcd_priv_size =        sizeof(struct sl811),
1548
1549        /*
1550         * generic hardware linkage
1551         */
1552        .irq =                  sl811h_irq,
1553        .flags =                HCD_USB11 | HCD_MEMORY,
1554
1555        /* Basic lifecycle operations */
1556        .start =                sl811h_start,
1557        .stop =                 sl811h_stop,
1558
1559        /*
1560         * managing i/o requests and associated device resources
1561         */
1562        .urb_enqueue =          sl811h_urb_enqueue,
1563        .urb_dequeue =          sl811h_urb_dequeue,
1564        .endpoint_disable =     sl811h_endpoint_disable,
1565
1566        /*
1567         * periodic schedule support
1568         */
1569        .get_frame_number =     sl811h_get_frame,
1570
1571        /*
1572         * root hub support
1573         */
1574        .hub_status_data =      sl811h_hub_status_data,
1575        .hub_control =          sl811h_hub_control,
1576        .bus_suspend =          sl811h_bus_suspend,
1577        .bus_resume =           sl811h_bus_resume,
1578};
1579
1580/*-------------------------------------------------------------------------*/
1581
1582static int
1583sl811h_remove(struct platform_device *dev)
1584{
1585        struct usb_hcd          *hcd = platform_get_drvdata(dev);
1586        struct sl811            *sl811 = hcd_to_sl811(hcd);
1587        struct resource         *res;
1588
1589        remove_debug_file(sl811);
1590        usb_remove_hcd(hcd);
1591
1592        /* some platforms may use IORESOURCE_IO */
1593        res = platform_get_resource(dev, IORESOURCE_MEM, 1);
1594        if (res)
1595                iounmap(sl811->data_reg);
1596
1597        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
1598        if (res)
1599                iounmap(sl811->addr_reg);
1600
1601        usb_put_hcd(hcd);
1602        return 0;
1603}
1604
1605static int
1606sl811h_probe(struct platform_device *dev)
1607{
1608        struct usb_hcd          *hcd;
1609        struct sl811            *sl811;
1610        struct resource         *addr, *data, *ires;
1611        int                     irq;
1612        void __iomem            *addr_reg;
1613        void __iomem            *data_reg;
1614        int                     retval;
1615        u8                      tmp, ioaddr;
1616        unsigned long           irqflags;
1617
1618        if (usb_disabled())
1619                return -ENODEV;
1620
1621        /* the chip may be wired for either kind of addressing */
1622        addr = platform_get_mem_or_io(dev, 0);
1623        data = platform_get_mem_or_io(dev, 1);
1624        if (!addr || !data || resource_type(addr) != resource_type(data))
1625                return -ENODEV;
1626
1627        /* basic sanity checks first.  board-specific init logic should
1628         * have initialized these three resources and probably board
1629         * specific platform_data.  we don't probe for IRQs, and do only
1630         * minimal sanity checking.
1631         */
1632        ires = platform_get_resource(dev, IORESOURCE_IRQ, 0);
1633        if (dev->num_resources < 3 || !ires)
1634                return -ENODEV;
1635
1636        irq = ires->start;
1637        irqflags = ires->flags & IRQF_TRIGGER_MASK;
1638
1639        ioaddr = resource_type(addr) == IORESOURCE_IO;
1640        if (ioaddr) {
1641                /*
1642                 * NOTE: 64-bit resource->start is getting truncated
1643                 * to avoid compiler warning, assuming that ->start
1644                 * is always 32-bit for this case
1645                 */
1646                addr_reg = (void __iomem *) (unsigned long) addr->start;
1647                data_reg = (void __iomem *) (unsigned long) data->start;
1648        } else {
1649                addr_reg = ioremap(addr->start, 1);
1650                if (addr_reg == NULL) {
1651                        retval = -ENOMEM;
1652                        goto err2;
1653                }
1654
1655                data_reg = ioremap(data->start, 1);
1656                if (data_reg == NULL) {
1657                        retval = -ENOMEM;
1658                        goto err4;
1659                }
1660        }
1661
1662        /* allocate and initialize hcd */
1663        hcd = usb_create_hcd(&sl811h_hc_driver, &dev->dev, dev_name(&dev->dev));
1664        if (!hcd) {
1665                retval = -ENOMEM;
1666                goto err5;
1667        }
1668        hcd->rsrc_start = addr->start;
1669        sl811 = hcd_to_sl811(hcd);
1670
1671        spin_lock_init(&sl811->lock);
1672        INIT_LIST_HEAD(&sl811->async);
1673        sl811->board = dev_get_platdata(&dev->dev);
1674        timer_setup(&sl811->timer, sl811h_timer, 0);
1675        sl811->addr_reg = addr_reg;
1676        sl811->data_reg = data_reg;
1677
1678        spin_lock_irq(&sl811->lock);
1679        port_power(sl811, 0);
1680        spin_unlock_irq(&sl811->lock);
1681        msleep(200);
1682
1683        tmp = sl811_read(sl811, SL11H_HWREVREG);
1684        switch (tmp >> 4) {
1685        case 1:
1686                hcd->product_desc = "SL811HS v1.2";
1687                break;
1688        case 2:
1689                hcd->product_desc = "SL811HS v1.5";
1690                break;
1691        default:
1692                /* reject case 0, SL11S is less functional */
1693                dev_dbg(&dev->dev, "chiprev %02x\n", tmp);
1694                retval = -ENXIO;
1695                goto err6;
1696        }
1697
1698        /* The chip's IRQ is level triggered, active high.  A requirement
1699         * for platform device setup is to cope with things like signal
1700         * inverters (e.g. CF is active low) or working only with edge
1701         * triggers (e.g. most ARM CPUs).  Initial driver stress testing
1702         * was on a system with single edge triggering, so most sorts of
1703         * triggering arrangement should work.
1704         *
1705         * Use resource IRQ flags if set by platform device setup.
1706         */
1707        irqflags |= IRQF_SHARED;
1708        retval = usb_add_hcd(hcd, irq, irqflags);
1709        if (retval != 0)
1710                goto err6;
1711
1712        device_wakeup_enable(hcd->self.controller);
1713
1714        create_debug_file(sl811);
1715        return retval;
1716
1717 err6:
1718        usb_put_hcd(hcd);
1719 err5:
1720        if (!ioaddr)
1721                iounmap(data_reg);
1722 err4:
1723        if (!ioaddr)
1724                iounmap(addr_reg);
1725 err2:
1726        dev_dbg(&dev->dev, "init error, %d\n", retval);
1727        return retval;
1728}
1729
1730#ifdef  CONFIG_PM
1731
1732/* for this device there's no useful distinction between the controller
1733 * and its root hub.
1734 */
1735
1736static int
1737sl811h_suspend(struct platform_device *dev, pm_message_t state)
1738{
1739        struct usb_hcd  *hcd = platform_get_drvdata(dev);
1740        struct sl811    *sl811 = hcd_to_sl811(hcd);
1741        int             retval = 0;
1742
1743        switch (state.event) {
1744        case PM_EVENT_FREEZE:
1745                retval = sl811h_bus_suspend(hcd);
1746                break;
1747        case PM_EVENT_SUSPEND:
1748        case PM_EVENT_HIBERNATE:
1749        case PM_EVENT_PRETHAW:          /* explicitly discard hw state */
1750                port_power(sl811, 0);
1751                break;
1752        }
1753        return retval;
1754}
1755
1756static int
1757sl811h_resume(struct platform_device *dev)
1758{
1759        struct usb_hcd  *hcd = platform_get_drvdata(dev);
1760        struct sl811    *sl811 = hcd_to_sl811(hcd);
1761
1762        /* with no "check to see if VBUS is still powered" board hook,
1763         * let's assume it'd only be powered to enable remote wakeup.
1764         */
1765        if (!sl811->port1 || !device_can_wakeup(&hcd->self.root_hub->dev)) {
1766                sl811->port1 = 0;
1767                port_power(sl811, 1);
1768                usb_root_hub_lost_power(hcd->self.root_hub);
1769                return 0;
1770        }
1771
1772        return sl811h_bus_resume(hcd);
1773}
1774
1775#else
1776
1777#define sl811h_suspend  NULL
1778#define sl811h_resume   NULL
1779
1780#endif
1781
1782
1783/* this driver is exported so sl811_cs can depend on it */
1784struct platform_driver sl811h_driver = {
1785        .probe =        sl811h_probe,
1786        .remove =       sl811h_remove,
1787
1788        .suspend =      sl811h_suspend,
1789        .resume =       sl811h_resume,
1790        .driver = {
1791                .name = hcd_name,
1792        },
1793};
1794EXPORT_SYMBOL(sl811h_driver);
1795
1796module_platform_driver(sl811h_driver);
1797
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.