Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sl811-hcd.c
Go to the documentation of this file.
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(inode)->data);
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 __devexit
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 __devinit
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_USB_SUSPEND 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 = __devexit_p(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);
Generated on Thu Jan 10 2013 14:37:16 for Linux Kernel by   doxygen 1.8.2