drivers/usb/host/sl811-hcd.c

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