xhci: tegra: support HSIC ports
[linux-3.10.git] / 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 PM_RUNTIME)
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);