2 * SL811HS HCD (Host Controller Driver) for USB.
4 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
5 * Copyright (C) 2004-2005 David Brownell
7 * Periodic scheduling is based on Roman's OHCI code
8 * Copyright (C) 1999 Roman Weissgaerber
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).
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.
21 * Status: Passed basic stress testing, works with hubs, mice, keyboards,
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
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>
54 #include <asm/system.h>
55 #include <asm/byteorder.h>
56 #include <asm/unaligned.h>
61 MODULE_DESCRIPTION("SL811HS USB Host Controller Driver");
62 MODULE_LICENSE("GPL");
63 MODULE_ALIAS("platform:sl811-hcd");
65 #define DRIVER_VERSION "19 May 2005"
69 # define STUB_DEBUG_FILE
72 /* for now, use only one transfer register bank */
75 /* this doesn't understand urb->iso_frame_desc[], but if you had a driver
76 * that just queued one ISO frame per URB then iso transfers "should" work
77 * using the normal urb status fields.
84 static const char hcd_name
[] = "sl811-hcd";
86 /*-------------------------------------------------------------------------*/
88 static void port_power(struct sl811
*sl811
, int is_on
)
90 struct usb_hcd
*hcd
= sl811_to_hcd(sl811
);
92 /* hub is inactive unless the port is powered */
94 if (sl811
->port1
& USB_PORT_STAT_POWER
)
97 sl811
->port1
= USB_PORT_STAT_POWER
;
98 sl811
->irq_enable
= SL11H_INTMASK_INSRMV
;
101 sl811
->irq_enable
= 0;
102 hcd
->state
= HC_STATE_HALT
;
105 sl811_write(sl811
, SL11H_IRQ_ENABLE
, 0);
106 sl811_write(sl811
, SL11H_IRQ_STATUS
, ~0);
108 if (sl811
->board
&& sl811
->board
->port_power
) {
109 /* switch VBUS, at 500mA unless hub power budget gets set */
110 DBG("power %s\n", is_on
? "on" : "off");
111 sl811
->board
->port_power(hcd
->self
.controller
, is_on
);
114 /* reset as thoroughly as we can */
115 if (sl811
->board
&& sl811
->board
->reset
)
116 sl811
->board
->reset(hcd
->self
.controller
);
118 sl811_write(sl811
, SL11H_CTLREG1
, SL11H_CTL1MASK_SE0
);
122 sl811_write(sl811
, SL11H_IRQ_ENABLE
, 0);
123 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
124 sl811_write(sl811
, SL811HS_CTLREG2
, SL811HS_CTL2_INIT
);
125 sl811_write(sl811
, SL11H_IRQ_ENABLE
, sl811
->irq_enable
);
127 // if !is_on, put into lowpower mode now
130 /*-------------------------------------------------------------------------*/
132 /* This is a PIO-only HCD. Queueing appends URBs to the endpoint's queue,
133 * and may start I/O. Endpoint queues are scanned during completion irq
134 * handlers (one per packet: ACK, NAK, faults, etc) and urb cancellation.
136 * Using an external DMA engine to copy a packet at a time could work,
137 * though setup/teardown costs may be too big to make it worthwhile.
140 /* SETUP starts a new control request. Devices are not allowed to
141 * STALL or NAK these; they must cancel any pending control requests.
143 static void setup_packet(
145 struct sl811h_ep
*ep
,
153 void __iomem
*data_reg
;
155 addr
= SL811HS_PACKET_BUF(bank
== 0);
156 len
= sizeof(struct usb_ctrlrequest
);
157 data_reg
= sl811
->data_reg
;
158 sl811_write_buf(sl811
, addr
, urb
->setup_packet
, len
);
160 /* autoincrementing */
161 sl811_write(sl811
, bank
+ SL11H_BUFADDRREG
, addr
);
162 writeb(len
, data_reg
);
163 writeb(SL_SETUP
/* | ep->epnum */, data_reg
);
164 writeb(usb_pipedevice(urb
->pipe
), data_reg
);
166 /* always OUT/data0 */ ;
167 sl811_write(sl811
, bank
+ SL11H_HOSTCTLREG
,
168 control
| SL11H_HCTLMASK_OUT
);
170 PACKET("SETUP qh%p\n", ep
);
173 /* STATUS finishes control requests, often after IN or OUT data packets */
174 static void status_packet(
176 struct sl811h_ep
*ep
,
183 void __iomem
*data_reg
;
185 do_out
= urb
->transfer_buffer_length
&& usb_pipein(urb
->pipe
);
186 data_reg
= sl811
->data_reg
;
188 /* autoincrementing */
189 sl811_write(sl811
, bank
+ SL11H_BUFADDRREG
, 0);
191 writeb((do_out
? SL_OUT
: SL_IN
) /* | ep->epnum */, data_reg
);
192 writeb(usb_pipedevice(urb
->pipe
), data_reg
);
194 /* always data1; sometimes IN */
195 control
|= SL11H_HCTLMASK_TOGGLE
;
197 control
|= SL11H_HCTLMASK_OUT
;
198 sl811_write(sl811
, bank
+ SL11H_HOSTCTLREG
, control
);
200 PACKET("STATUS%s/%s qh%p\n", ep
->nak_count
? "/retry" : "",
201 do_out
? "out" : "in", ep
);
204 /* IN packets can be used with any type of endpoint. here we just
205 * start the transfer, data from the peripheral may arrive later.
206 * urb->iso_frame_desc is currently ignored here...
208 static void in_packet(
210 struct sl811h_ep
*ep
,
218 void __iomem
*data_reg
;
220 /* avoid losing data on overflow */
222 addr
= SL811HS_PACKET_BUF(bank
== 0);
223 if (!(control
& SL11H_HCTLMASK_ISOCH
)
224 && usb_gettoggle(urb
->dev
, ep
->epnum
, 0))
225 control
|= SL11H_HCTLMASK_TOGGLE
;
226 data_reg
= sl811
->data_reg
;
228 /* autoincrementing */
229 sl811_write(sl811
, bank
+ SL11H_BUFADDRREG
, addr
);
230 writeb(len
, data_reg
);
231 writeb(SL_IN
| ep
->epnum
, data_reg
);
232 writeb(usb_pipedevice(urb
->pipe
), data_reg
);
234 sl811_write(sl811
, bank
+ SL11H_HOSTCTLREG
, control
);
235 ep
->length
= min_t(u32
, len
,
236 urb
->transfer_buffer_length
- urb
->actual_length
);
237 PACKET("IN%s/%d qh%p len%d\n", ep
->nak_count
? "/retry" : "",
238 !!usb_gettoggle(urb
->dev
, ep
->epnum
, 0), ep
, len
);
241 /* OUT packets can be used with any type of endpoint.
242 * urb->iso_frame_desc is currently ignored here...
244 static void out_packet(
246 struct sl811h_ep
*ep
,
255 void __iomem
*data_reg
;
257 buf
= urb
->transfer_buffer
+ urb
->actual_length
;
260 len
= min_t(u32
, ep
->maxpacket
,
261 urb
->transfer_buffer_length
- urb
->actual_length
);
263 if (!(control
& SL11H_HCTLMASK_ISOCH
)
264 && usb_gettoggle(urb
->dev
, ep
->epnum
, 1))
265 control
|= SL11H_HCTLMASK_TOGGLE
;
266 addr
= SL811HS_PACKET_BUF(bank
== 0);
267 data_reg
= sl811
->data_reg
;
269 sl811_write_buf(sl811
, addr
, buf
, len
);
271 /* autoincrementing */
272 sl811_write(sl811
, bank
+ SL11H_BUFADDRREG
, addr
);
273 writeb(len
, data_reg
);
274 writeb(SL_OUT
| ep
->epnum
, data_reg
);
275 writeb(usb_pipedevice(urb
->pipe
), data_reg
);
277 sl811_write(sl811
, bank
+ SL11H_HOSTCTLREG
,
278 control
| SL11H_HCTLMASK_OUT
);
280 PACKET("OUT%s/%d qh%p len%d\n", ep
->nak_count
? "/retry" : "",
281 !!usb_gettoggle(urb
->dev
, ep
->epnum
, 1), ep
, len
);
284 /*-------------------------------------------------------------------------*/
286 /* caller updates on-chip enables later */
288 static inline void sofirq_on(struct sl811
*sl811
)
290 if (sl811
->irq_enable
& SL11H_INTMASK_SOFINTR
)
292 VDBG("sof irq on\n");
293 sl811
->irq_enable
|= SL11H_INTMASK_SOFINTR
;
296 static inline void sofirq_off(struct sl811
*sl811
)
298 if (!(sl811
->irq_enable
& SL11H_INTMASK_SOFINTR
))
300 VDBG("sof irq off\n");
301 sl811
->irq_enable
&= ~SL11H_INTMASK_SOFINTR
;
304 /*-------------------------------------------------------------------------*/
306 /* pick the next endpoint for a transaction, and issue it.
307 * frames start with periodic transfers (after whatever is pending
308 * from the previous frame), and the rest of the time is async
309 * transfers, scheduled round-robin.
311 static struct sl811h_ep
*start(struct sl811
*sl811
, u8 bank
)
313 struct sl811h_ep
*ep
;
318 /* use endpoint at schedule head */
319 if (sl811
->next_periodic
) {
320 ep
= sl811
->next_periodic
;
321 sl811
->next_periodic
= ep
->next
;
323 if (sl811
->next_async
)
324 ep
= sl811
->next_async
;
325 else if (!list_empty(&sl811
->async
))
326 ep
= container_of(sl811
->async
.next
,
327 struct sl811h_ep
, schedule
);
329 /* could set up the first fullspeed periodic
330 * transfer for the next frame ...
336 if ((bank
&& sl811
->active_b
== ep
) || sl811
->active_a
== ep
)
340 if (ep
->schedule
.next
== &sl811
->async
)
341 sl811
->next_async
= NULL
;
343 sl811
->next_async
= container_of(ep
->schedule
.next
,
344 struct sl811h_ep
, schedule
);
347 if (unlikely(list_empty(&ep
->hep
->urb_list
))) {
348 DBG("empty %p queue?\n", ep
);
352 urb
= container_of(ep
->hep
->urb_list
.next
, struct urb
, urb_list
);
353 control
= ep
->defctrl
;
355 /* if this frame doesn't have enough time left to transfer this
356 * packet, wait till the next frame. too-simple algorithm...
358 fclock
= sl811_read(sl811
, SL11H_SOFTMRREG
) << 6;
359 fclock
-= 100; /* setup takes not much time */
360 if (urb
->dev
->speed
== USB_SPEED_LOW
) {
361 if (control
& SL11H_HCTLMASK_PREAMBLE
) {
362 /* also note erratum 1: some hubs won't work */
365 fclock
-= ep
->maxpacket
<< 8;
367 /* erratum 2: AFTERSOF only works for fullspeed */
370 sl811
->stat_overrun
++;
375 fclock
-= 12000 / 19; /* 19 64byte packets/msec */
378 sl811
->stat_overrun
++;
379 control
|= SL11H_HCTLMASK_AFTERSOF
;
381 /* throttle bulk/control irq noise */
382 } else if (ep
->nak_count
)
383 control
|= SL11H_HCTLMASK_AFTERSOF
;
387 switch (ep
->nextpid
) {
389 in_packet(sl811
, ep
, urb
, bank
, control
);
392 out_packet(sl811
, ep
, urb
, bank
, control
);
395 setup_packet(sl811
, ep
, urb
, bank
, control
);
397 case USB_PID_ACK
: /* for control status */
398 status_packet(sl811
, ep
, urb
, bank
, control
);
401 DBG("bad ep%p pid %02x\n", ep
, ep
->nextpid
);
407 #define MIN_JIFFIES ((msecs_to_jiffies(2) > 1) ? msecs_to_jiffies(2) : 2)
409 static inline void start_transfer(struct sl811
*sl811
)
411 if (sl811
->port1
& USB_PORT_STAT_SUSPEND
)
413 if (sl811
->active_a
== NULL
) {
414 sl811
->active_a
= start(sl811
, SL811_EP_A(SL811_HOST_BUF
));
415 if (sl811
->active_a
!= NULL
)
416 sl811
->jiffies_a
= jiffies
+ MIN_JIFFIES
;
419 if (sl811
->active_b
== NULL
) {
420 sl811
->active_b
= start(sl811
, SL811_EP_B(SL811_HOST_BUF
));
421 if (sl811
->active_b
!= NULL
)
422 sl811
->jiffies_b
= jiffies
+ MIN_JIFFIES
;
427 static void finish_request(
429 struct sl811h_ep
*ep
,
432 ) __releases(sl811
->lock
) __acquires(sl811
->lock
)
436 if (usb_pipecontrol(urb
->pipe
))
437 ep
->nextpid
= USB_PID_SETUP
;
439 usb_hcd_unlink_urb_from_ep(sl811_to_hcd(sl811
), urb
);
440 spin_unlock(&sl811
->lock
);
441 usb_hcd_giveback_urb(sl811_to_hcd(sl811
), urb
, status
);
442 spin_lock(&sl811
->lock
);
444 /* leave active endpoints in the schedule */
445 if (!list_empty(&ep
->hep
->urb_list
))
448 /* async deschedule? */
449 if (!list_empty(&ep
->schedule
)) {
450 list_del_init(&ep
->schedule
);
451 if (ep
== sl811
->next_async
)
452 sl811
->next_async
= NULL
;
456 /* periodic deschedule */
457 DBG("deschedule qh%d/%p branch %d\n", ep
->period
, ep
, ep
->branch
);
458 for (i
= ep
->branch
; i
< PERIODIC_SIZE
; i
+= ep
->period
) {
459 struct sl811h_ep
*temp
;
460 struct sl811h_ep
**prev
= &sl811
->periodic
[i
];
462 while (*prev
&& ((temp
= *prev
) != ep
))
466 sl811
->load
[i
] -= ep
->load
;
468 ep
->branch
= PERIODIC_SIZE
;
469 sl811
->periodic_count
--;
470 sl811_to_hcd(sl811
)->self
.bandwidth_allocated
471 -= ep
->load
/ ep
->period
;
472 if (ep
== sl811
->next_periodic
)
473 sl811
->next_periodic
= ep
->next
;
475 /* we might turn SOFs back on again for the async schedule */
476 if (sl811
->periodic_count
== 0)
481 done(struct sl811
*sl811
, struct sl811h_ep
*ep
, u8 bank
)
485 int urbstat
= -EINPROGRESS
;
490 status
= sl811_read(sl811
, bank
+ SL11H_PKTSTATREG
);
492 urb
= container_of(ep
->hep
->urb_list
.next
, struct urb
, urb_list
);
494 /* we can safely ignore NAKs */
495 if (status
& SL11H_STATMASK_NAK
) {
496 // PACKET("...NAK_%02x qh%p\n", bank, ep);
501 /* ACK advances transfer, toggle, and maybe queue */
502 } else if (status
& SL11H_STATMASK_ACK
) {
503 struct usb_device
*udev
= urb
->dev
;
507 /* urb->iso_frame_desc is currently ignored here... */
509 ep
->nak_count
= ep
->error_count
= 0;
510 switch (ep
->nextpid
) {
512 // PACKET("...ACK/out_%02x qh%p\n", bank, ep);
513 urb
->actual_length
+= ep
->length
;
514 usb_dotoggle(udev
, ep
->epnum
, 1);
515 if (urb
->actual_length
516 == urb
->transfer_buffer_length
) {
517 if (usb_pipecontrol(urb
->pipe
))
518 ep
->nextpid
= USB_PID_ACK
;
520 /* some bulk protocols terminate OUT transfers
521 * by a short packet, using ZLPs not padding.
523 else if (ep
->length
< ep
->maxpacket
524 || !(urb
->transfer_flags
530 // PACKET("...ACK/in_%02x qh%p\n", bank, ep);
531 buf
= urb
->transfer_buffer
+ urb
->actual_length
;
533 len
= ep
->maxpacket
- sl811_read(sl811
,
534 bank
+ SL11H_XFERCNTREG
);
535 if (len
> ep
->length
) {
537 urbstat
= -EOVERFLOW
;
539 urb
->actual_length
+= len
;
540 sl811_read_buf(sl811
, SL811HS_PACKET_BUF(bank
== 0),
542 usb_dotoggle(udev
, ep
->epnum
, 0);
543 if (urbstat
== -EINPROGRESS
&&
544 (len
< ep
->maxpacket
||
545 urb
->actual_length
==
546 urb
->transfer_buffer_length
)) {
547 if (usb_pipecontrol(urb
->pipe
))
548 ep
->nextpid
= USB_PID_ACK
;
554 // PACKET("...ACK/setup_%02x qh%p\n", bank, ep);
555 if (urb
->transfer_buffer_length
== urb
->actual_length
)
556 ep
->nextpid
= USB_PID_ACK
;
557 else if (usb_pipeout(urb
->pipe
)) {
558 usb_settoggle(udev
, 0, 1, 1);
559 ep
->nextpid
= USB_PID_OUT
;
561 usb_settoggle(udev
, 0, 0, 1);
562 ep
->nextpid
= USB_PID_IN
;
566 // PACKET("...ACK/status_%02x qh%p\n", bank, ep);
571 /* STALL stops all transfers */
572 } else if (status
& SL11H_STATMASK_STALL
) {
573 PACKET("...STALL_%02x qh%p\n", bank
, ep
);
574 ep
->nak_count
= ep
->error_count
= 0;
577 /* error? retry, until "3 strikes" */
578 } else if (++ep
->error_count
>= 3) {
579 if (status
& SL11H_STATMASK_TMOUT
)
581 else if (status
& SL11H_STATMASK_OVF
)
582 urbstat
= -EOVERFLOW
;
586 PACKET("...3STRIKES_%02x %02x qh%p stat %d\n",
587 bank
, status
, ep
, urbstat
);
590 if (urbstat
!= -EINPROGRESS
|| urb
->unlinked
)
591 finish_request(sl811
, ep
, urb
, urbstat
);
594 static inline u8
checkdone(struct sl811
*sl811
)
599 if (sl811
->active_a
&& time_before_eq(sl811
->jiffies_a
, jiffies
)) {
600 ctl
= sl811_read(sl811
, SL811_EP_A(SL11H_HOSTCTLREG
));
601 if (ctl
& SL11H_HCTLMASK_ARM
)
602 sl811_write(sl811
, SL811_EP_A(SL11H_HOSTCTLREG
), 0);
603 DBG("%s DONE_A: ctrl %02x sts %02x\n",
604 (ctl
& SL11H_HCTLMASK_ARM
) ? "timeout" : "lost",
606 sl811_read(sl811
, SL811_EP_A(SL11H_PKTSTATREG
)));
607 irqstat
|= SL11H_INTMASK_DONE_A
;
610 if (sl811
->active_b
&& time_before_eq(sl811
->jiffies_b
, jiffies
)) {
611 ctl
= sl811_read(sl811
, SL811_EP_B(SL11H_HOSTCTLREG
));
612 if (ctl
& SL11H_HCTLMASK_ARM
)
613 sl811_write(sl811
, SL811_EP_B(SL11H_HOSTCTLREG
), 0);
614 DBG("%s DONE_B: ctrl %02x sts %02x\n",
615 (ctl
& SL11H_HCTLMASK_ARM
) ? "timeout" : "lost",
617 sl811_read(sl811
, SL811_EP_B(SL11H_PKTSTATREG
)));
618 irqstat
|= SL11H_INTMASK_DONE_A
;
624 static irqreturn_t
sl811h_irq(struct usb_hcd
*hcd
)
626 struct sl811
*sl811
= hcd_to_sl811(hcd
);
628 irqreturn_t ret
= IRQ_NONE
;
629 unsigned retries
= 5;
631 spin_lock(&sl811
->lock
);
634 irqstat
= sl811_read(sl811
, SL11H_IRQ_STATUS
) & ~SL11H_INTMASK_DP
;
636 sl811_write(sl811
, SL11H_IRQ_STATUS
, irqstat
);
637 irqstat
&= sl811
->irq_enable
;
641 /* this may no longer be necessary ... */
643 irqstat
= checkdone(sl811
);
649 /* USB packets, not necessarily handled in the order they're
650 * issued ... that's fine if they're different endpoints.
652 if (irqstat
& SL11H_INTMASK_DONE_A
) {
653 done(sl811
, sl811
->active_a
, SL811_EP_A(SL811_HOST_BUF
));
654 sl811
->active_a
= NULL
;
658 if (irqstat
& SL11H_INTMASK_DONE_B
) {
659 done(sl811
, sl811
->active_b
, SL811_EP_B(SL811_HOST_BUF
));
660 sl811
->active_b
= NULL
;
664 if (irqstat
& SL11H_INTMASK_SOFINTR
) {
667 index
= sl811
->frame
++ % (PERIODIC_SIZE
- 1);
670 /* be graceful about almost-inevitable periodic schedule
671 * overruns: continue the previous frame's transfers iff
672 * this one has nothing scheduled.
674 if (sl811
->next_periodic
) {
675 // ERR("overrun to slot %d\n", index);
676 sl811
->stat_overrun
++;
678 if (sl811
->periodic
[index
])
679 sl811
->next_periodic
= sl811
->periodic
[index
];
682 /* khubd manages debouncing and wakeup */
683 if (irqstat
& SL11H_INTMASK_INSRMV
) {
684 sl811
->stat_insrmv
++;
686 /* most stats are reset for each VBUS session */
687 sl811
->stat_wake
= 0;
691 sl811
->stat_lost
= 0;
694 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
696 sl811
->irq_enable
= SL11H_INTMASK_INSRMV
;
697 sl811_write(sl811
, SL11H_IRQ_ENABLE
, sl811
->irq_enable
);
699 /* usbcore nukes other pending transactions on disconnect */
700 if (sl811
->active_a
) {
701 sl811_write(sl811
, SL811_EP_A(SL11H_HOSTCTLREG
), 0);
702 finish_request(sl811
, sl811
->active_a
,
703 container_of(sl811
->active_a
704 ->hep
->urb_list
.next
,
705 struct urb
, urb_list
),
707 sl811
->active_a
= NULL
;
710 if (sl811
->active_b
) {
711 sl811_write(sl811
, SL811_EP_B(SL11H_HOSTCTLREG
), 0);
712 finish_request(sl811
, sl811
->active_b
,
713 container_of(sl811
->active_b
714 ->hep
->urb_list
.next
,
715 struct urb
, urb_list
),
717 sl811
->active_b
= NULL
;
721 /* port status seems weird until after reset, so
722 * force the reset and make khubd clean up later.
724 if (irqstat
& SL11H_INTMASK_RD
)
725 sl811
->port1
&= ~USB_PORT_STAT_CONNECTION
;
727 sl811
->port1
|= USB_PORT_STAT_CONNECTION
;
729 sl811
->port1
|= USB_PORT_STAT_C_CONNECTION
<< 16;
731 } else if (irqstat
& SL11H_INTMASK_RD
) {
732 if (sl811
->port1
& USB_PORT_STAT_SUSPEND
) {
734 sl811
->port1
|= USB_PORT_STAT_C_SUSPEND
<< 16;
737 irqstat
&= ~SL11H_INTMASK_RD
;
741 if (sl811
->port1
& USB_PORT_STAT_ENABLE
)
742 start_transfer(sl811
);
748 if (sl811
->periodic_count
== 0 && list_empty(&sl811
->async
))
750 sl811_write(sl811
, SL11H_IRQ_ENABLE
, sl811
->irq_enable
);
752 spin_unlock(&sl811
->lock
);
757 /*-------------------------------------------------------------------------*/
759 /* usb 1.1 says max 90% of a frame is available for periodic transfers.
760 * this driver doesn't promise that much since it's got to handle an
761 * IRQ per packet; irq handling latencies also use up that time.
763 * NOTE: the periodic schedule is a sparse tree, with the load for
764 * each branch minimized. see fig 3.5 in the OHCI spec for example.
766 #define MAX_PERIODIC_LOAD 500 /* out of 1000 usec */
768 static int balance(struct sl811
*sl811
, u16 period
, u16 load
)
770 int i
, branch
= -ENOSPC
;
772 /* search for the least loaded schedule branch of that period
773 * which has enough bandwidth left unreserved.
775 for (i
= 0; i
< period
; i
++) {
776 if (branch
< 0 || sl811
->load
[branch
] > sl811
->load
[i
]) {
779 for (j
= i
; j
< PERIODIC_SIZE
; j
+= period
) {
780 if ((sl811
->load
[j
] + load
)
784 if (j
< PERIODIC_SIZE
)
792 /*-------------------------------------------------------------------------*/
794 static int sl811h_urb_enqueue(
799 struct sl811
*sl811
= hcd_to_sl811(hcd
);
800 struct usb_device
*udev
= urb
->dev
;
801 unsigned int pipe
= urb
->pipe
;
802 int is_out
= !usb_pipein(pipe
);
803 int type
= usb_pipetype(pipe
);
804 int epnum
= usb_pipeendpoint(pipe
);
805 struct sl811h_ep
*ep
= NULL
;
809 struct usb_host_endpoint
*hep
= urb
->ep
;
812 if (type
== PIPE_ISOCHRONOUS
)
816 /* avoid all allocations within spinlocks */
818 ep
= kzalloc(sizeof *ep
, mem_flags
);
823 spin_lock_irqsave(&sl811
->lock
, flags
);
825 /* don't submit to a dead or disabled port */
826 if (!(sl811
->port1
& USB_PORT_STAT_ENABLE
)
827 || !HC_IS_RUNNING(hcd
->state
)) {
830 goto fail_not_linked
;
832 retval
= usb_hcd_link_urb_to_ep(hcd
, urb
);
835 goto fail_not_linked
;
846 INIT_LIST_HEAD(&ep
->schedule
);
849 ep
->maxpacket
= usb_maxpacket(udev
, urb
->pipe
, is_out
);
850 ep
->defctrl
= SL11H_HCTLMASK_ARM
| SL11H_HCTLMASK_ENABLE
;
851 usb_settoggle(udev
, epnum
, is_out
, 0);
853 if (type
== PIPE_CONTROL
)
854 ep
->nextpid
= USB_PID_SETUP
;
856 ep
->nextpid
= USB_PID_OUT
;
858 ep
->nextpid
= USB_PID_IN
;
860 if (ep
->maxpacket
> H_MAXPACKET
) {
861 /* iso packets up to 240 bytes could work... */
862 DBG("dev %d ep%d maxpacket %d\n",
863 udev
->devnum
, epnum
, ep
->maxpacket
);
869 if (udev
->speed
== USB_SPEED_LOW
) {
870 /* send preamble for external hub? */
871 if (!(sl811
->ctrl1
& SL11H_CTL1MASK_LSPD
))
872 ep
->defctrl
|= SL11H_HCTLMASK_PREAMBLE
;
875 case PIPE_ISOCHRONOUS
:
877 if (urb
->interval
> PERIODIC_SIZE
)
878 urb
->interval
= PERIODIC_SIZE
;
879 ep
->period
= urb
->interval
;
880 ep
->branch
= PERIODIC_SIZE
;
881 if (type
== PIPE_ISOCHRONOUS
)
882 ep
->defctrl
|= SL11H_HCTLMASK_ISOCH
;
883 ep
->load
= usb_calc_bus_time(udev
->speed
, !is_out
,
884 (type
== PIPE_ISOCHRONOUS
),
885 usb_maxpacket(udev
, pipe
, is_out
))
894 /* maybe put endpoint into schedule */
898 if (list_empty(&ep
->schedule
))
899 list_add_tail(&ep
->schedule
, &sl811
->async
);
901 case PIPE_ISOCHRONOUS
:
903 urb
->interval
= ep
->period
;
904 if (ep
->branch
< PERIODIC_SIZE
) {
905 /* NOTE: the phase is correct here, but the value
906 * needs offsetting by the transfer queue depth.
907 * All current drivers ignore start_frame, so this
908 * is unlikely to ever matter...
910 urb
->start_frame
= (sl811
->frame
& (PERIODIC_SIZE
- 1))
915 retval
= balance(sl811
, ep
->period
, ep
->load
);
920 urb
->start_frame
= (sl811
->frame
& (PERIODIC_SIZE
- 1))
923 /* sort each schedule branch by period (slow before fast)
924 * to share the faster parts of the tree without needing
925 * dummy/placeholder nodes
927 DBG("schedule qh%d/%p branch %d\n", ep
->period
, ep
, ep
->branch
);
928 for (i
= ep
->branch
; i
< PERIODIC_SIZE
; i
+= ep
->period
) {
929 struct sl811h_ep
**prev
= &sl811
->periodic
[i
];
930 struct sl811h_ep
*here
= *prev
;
932 while (here
&& ep
!= here
) {
933 if (ep
->period
> here
->period
)
942 sl811
->load
[i
] += ep
->load
;
944 sl811
->periodic_count
++;
945 hcd
->self
.bandwidth_allocated
+= ep
->load
/ ep
->period
;
950 start_transfer(sl811
);
951 sl811_write(sl811
, SL11H_IRQ_ENABLE
, sl811
->irq_enable
);
954 usb_hcd_unlink_urb_from_ep(hcd
, urb
);
956 spin_unlock_irqrestore(&sl811
->lock
, flags
);
960 static int sl811h_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
, int status
)
962 struct sl811
*sl811
= hcd_to_sl811(hcd
);
963 struct usb_host_endpoint
*hep
;
965 struct sl811h_ep
*ep
;
968 spin_lock_irqsave(&sl811
->lock
, flags
);
969 retval
= usb_hcd_check_unlink_urb(hcd
, urb
, status
);
976 /* finish right away if this urb can't be active ...
977 * note that some drivers wrongly expect delays
979 if (ep
->hep
->urb_list
.next
!= &urb
->urb_list
) {
980 /* not front of queue? never active */
982 /* for active transfers, we expect an IRQ */
983 } else if (sl811
->active_a
== ep
) {
984 if (time_before_eq(sl811
->jiffies_a
, jiffies
)) {
985 /* happens a lot with lowspeed?? */
986 DBG("giveup on DONE_A: ctrl %02x sts %02x\n",
988 SL811_EP_A(SL11H_HOSTCTLREG
)),
990 SL811_EP_A(SL11H_PKTSTATREG
)));
991 sl811_write(sl811
, SL811_EP_A(SL11H_HOSTCTLREG
),
993 sl811
->active_a
= NULL
;
997 } else if (sl811
->active_b
== ep
) {
998 if (time_before_eq(sl811
->jiffies_a
, jiffies
)) {
999 /* happens a lot with lowspeed?? */
1000 DBG("giveup on DONE_B: ctrl %02x sts %02x\n",
1002 SL811_EP_B(SL11H_HOSTCTLREG
)),
1004 SL811_EP_B(SL11H_PKTSTATREG
)));
1005 sl811_write(sl811
, SL811_EP_B(SL11H_HOSTCTLREG
),
1007 sl811
->active_b
= NULL
;
1012 /* front of queue for inactive endpoint */
1016 finish_request(sl811
, ep
, urb
, 0);
1018 VDBG("dequeue, urb %p active %s; wait4irq\n", urb
,
1019 (sl811
->active_a
== ep
) ? "A" : "B");
1023 spin_unlock_irqrestore(&sl811
->lock
, flags
);
1028 sl811h_endpoint_disable(struct usb_hcd
*hcd
, struct usb_host_endpoint
*hep
)
1030 struct sl811h_ep
*ep
= hep
->hcpriv
;
1035 /* assume we'd just wait for the irq */
1036 if (!list_empty(&hep
->urb_list
))
1038 if (!list_empty(&hep
->urb_list
))
1039 WARNING("ep %p not empty?\n", ep
);
1046 sl811h_get_frame(struct usb_hcd
*hcd
)
1048 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1050 /* wrong except while periodic transfers are scheduled;
1051 * never matches the on-the-wire frame;
1052 * subject to overruns.
1054 return sl811
->frame
;
1058 /*-------------------------------------------------------------------------*/
1060 /* the virtual root hub timer IRQ checks for hub status */
1062 sl811h_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
1064 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1066 unsigned long flags
;
1068 /* non-SMP HACK: use root hub timer as i/o watchdog
1069 * this seems essential when SOF IRQs aren't in use...
1071 local_irq_save(flags
);
1072 if (!timer_pending(&sl811
->timer
)) {
1073 if (sl811h_irq( /* ~0, */ hcd
) != IRQ_NONE
)
1076 local_irq_restore(flags
);
1079 if (!(sl811
->port1
& (0xffff << 16)))
1082 /* tell khubd port 1 changed */
1088 sl811h_hub_descriptor (
1089 struct sl811
*sl811
,
1090 struct usb_hub_descriptor
*desc
1094 desc
->bDescriptorType
= 0x29;
1095 desc
->bHubContrCurrent
= 0;
1097 desc
->bNbrPorts
= 1;
1098 desc
->bDescLength
= 9;
1100 /* per-port power switching (gang of one!), or none */
1101 desc
->bPwrOn2PwrGood
= 0;
1102 if (sl811
->board
&& sl811
->board
->port_power
) {
1103 desc
->bPwrOn2PwrGood
= sl811
->board
->potpg
;
1104 if (!desc
->bPwrOn2PwrGood
)
1105 desc
->bPwrOn2PwrGood
= 10;
1110 /* no overcurrent errors detection/handling */
1113 desc
->wHubCharacteristics
= cpu_to_le16(temp
);
1115 /* ports removable, and legacy PortPwrCtrlMask */
1116 desc
->u
.hs
.DeviceRemovable
[0] = 0 << 1;
1117 desc
->u
.hs
.DeviceRemovable
[1] = ~0;
1121 sl811h_timer(unsigned long _sl811
)
1123 struct sl811
*sl811
= (void *) _sl811
;
1124 unsigned long flags
;
1126 u8 signaling
= sl811
->ctrl1
& SL11H_CTL1MASK_FORCE
;
1127 const u32 mask
= USB_PORT_STAT_CONNECTION
1128 | USB_PORT_STAT_ENABLE
1129 | USB_PORT_STAT_LOW_SPEED
;
1131 spin_lock_irqsave(&sl811
->lock
, flags
);
1133 /* stop special signaling */
1134 sl811
->ctrl1
&= ~SL11H_CTL1MASK_FORCE
;
1135 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
1138 irqstat
= sl811_read(sl811
, SL11H_IRQ_STATUS
);
1140 switch (signaling
) {
1141 case SL11H_CTL1MASK_SE0
:
1143 sl811
->port1
= (USB_PORT_STAT_C_RESET
<< 16)
1144 | USB_PORT_STAT_POWER
;
1146 /* don't wrongly ack RD */
1147 if (irqstat
& SL11H_INTMASK_INSRMV
)
1148 irqstat
&= ~SL11H_INTMASK_RD
;
1150 case SL11H_CTL1MASK_K
:
1151 DBG("end resume\n");
1152 sl811
->port1
&= ~USB_PORT_STAT_SUSPEND
;
1155 DBG("odd timer signaling: %02x\n", signaling
);
1158 sl811_write(sl811
, SL11H_IRQ_STATUS
, irqstat
);
1160 if (irqstat
& SL11H_INTMASK_RD
) {
1161 /* usbcore nukes all pending transactions on disconnect */
1162 if (sl811
->port1
& USB_PORT_STAT_CONNECTION
)
1163 sl811
->port1
|= (USB_PORT_STAT_C_CONNECTION
<< 16)
1164 | (USB_PORT_STAT_C_ENABLE
<< 16);
1165 sl811
->port1
&= ~mask
;
1166 sl811
->irq_enable
= SL11H_INTMASK_INSRMV
;
1168 sl811
->port1
|= mask
;
1169 if (irqstat
& SL11H_INTMASK_DP
)
1170 sl811
->port1
&= ~USB_PORT_STAT_LOW_SPEED
;
1171 sl811
->irq_enable
= SL11H_INTMASK_INSRMV
| SL11H_INTMASK_RD
;
1174 if (sl811
->port1
& USB_PORT_STAT_CONNECTION
) {
1175 u8 ctrl2
= SL811HS_CTL2_INIT
;
1177 sl811
->irq_enable
|= SL11H_INTMASK_DONE_A
;
1179 sl811
->irq_enable
|= SL11H_INTMASK_DONE_B
;
1181 if (sl811
->port1
& USB_PORT_STAT_LOW_SPEED
) {
1182 sl811
->ctrl1
|= SL11H_CTL1MASK_LSPD
;
1183 ctrl2
|= SL811HS_CTL2MASK_DSWAP
;
1186 /* start SOFs flowing, kickstarting with A registers */
1187 sl811
->ctrl1
|= SL11H_CTL1MASK_SOF_ENA
;
1188 sl811_write(sl811
, SL11H_SOFLOWREG
, 0xe0);
1189 sl811_write(sl811
, SL811HS_CTLREG2
, ctrl2
);
1191 /* autoincrementing */
1192 sl811_write(sl811
, SL811_EP_A(SL11H_BUFLNTHREG
), 0);
1193 writeb(SL_SOF
, sl811
->data_reg
);
1194 writeb(0, sl811
->data_reg
);
1195 sl811_write(sl811
, SL811_EP_A(SL11H_HOSTCTLREG
),
1196 SL11H_HCTLMASK_ARM
);
1198 /* khubd provides debounce delay */
1202 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
1205 sl811_write(sl811
, SL11H_IRQ_ENABLE
, sl811
->irq_enable
);
1206 spin_unlock_irqrestore(&sl811
->lock
, flags
);
1211 struct usb_hcd
*hcd
,
1218 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1220 unsigned long flags
;
1222 spin_lock_irqsave(&sl811
->lock
, flags
);
1225 case ClearHubFeature
:
1228 case C_HUB_OVER_CURRENT
:
1229 case C_HUB_LOCAL_POWER
:
1235 case ClearPortFeature
:
1236 if (wIndex
!= 1 || wLength
!= 0)
1240 case USB_PORT_FEAT_ENABLE
:
1241 sl811
->port1
&= USB_PORT_STAT_POWER
;
1243 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
1244 sl811
->irq_enable
= SL11H_INTMASK_INSRMV
;
1245 sl811_write(sl811
, SL11H_IRQ_ENABLE
,
1248 case USB_PORT_FEAT_SUSPEND
:
1249 if (!(sl811
->port1
& USB_PORT_STAT_SUSPEND
))
1252 /* 20 msec of resume/K signaling, other irqs blocked */
1253 DBG("start resume...\n");
1254 sl811
->irq_enable
= 0;
1255 sl811_write(sl811
, SL11H_IRQ_ENABLE
,
1257 sl811
->ctrl1
|= SL11H_CTL1MASK_K
;
1258 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
1260 mod_timer(&sl811
->timer
, jiffies
1261 + msecs_to_jiffies(20));
1263 case USB_PORT_FEAT_POWER
:
1264 port_power(sl811
, 0);
1266 case USB_PORT_FEAT_C_ENABLE
:
1267 case USB_PORT_FEAT_C_SUSPEND
:
1268 case USB_PORT_FEAT_C_CONNECTION
:
1269 case USB_PORT_FEAT_C_OVER_CURRENT
:
1270 case USB_PORT_FEAT_C_RESET
:
1275 sl811
->port1
&= ~(1 << wValue
);
1277 case GetHubDescriptor
:
1278 sl811h_hub_descriptor(sl811
, (struct usb_hub_descriptor
*) buf
);
1281 put_unaligned_le32(0, buf
);
1286 put_unaligned_le32(sl811
->port1
, buf
);
1289 if (*(u16
*)(buf
+2)) /* only if wPortChange is interesting */
1291 DBG("GetPortStatus %08x\n", sl811
->port1
);
1293 case SetPortFeature
:
1294 if (wIndex
!= 1 || wLength
!= 0)
1297 case USB_PORT_FEAT_SUSPEND
:
1298 if (sl811
->port1
& USB_PORT_STAT_RESET
)
1300 if (!(sl811
->port1
& USB_PORT_STAT_ENABLE
))
1303 DBG("suspend...\n");
1304 sl811
->ctrl1
&= ~SL11H_CTL1MASK_SOF_ENA
;
1305 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
1307 case USB_PORT_FEAT_POWER
:
1308 port_power(sl811
, 1);
1310 case USB_PORT_FEAT_RESET
:
1311 if (sl811
->port1
& USB_PORT_STAT_SUSPEND
)
1313 if (!(sl811
->port1
& USB_PORT_STAT_POWER
))
1316 /* 50 msec of reset/SE0 signaling, irqs blocked */
1317 sl811
->irq_enable
= 0;
1318 sl811_write(sl811
, SL11H_IRQ_ENABLE
,
1320 sl811
->ctrl1
= SL11H_CTL1MASK_SE0
;
1321 sl811_write(sl811
, SL11H_CTLREG1
, sl811
->ctrl1
);
1322 sl811
->port1
|= USB_PORT_STAT_RESET
;
1323 mod_timer(&sl811
->timer
, jiffies
1324 + msecs_to_jiffies(50));
1329 sl811
->port1
|= 1 << wValue
;
1334 /* "protocol stall" on error */
1338 spin_unlock_irqrestore(&sl811
->lock
, flags
);
1345 sl811h_bus_suspend(struct usb_hcd
*hcd
)
1348 DBG("%s\n", __func__
);
1353 sl811h_bus_resume(struct usb_hcd
*hcd
)
1356 DBG("%s\n", __func__
);
1362 #define sl811h_bus_suspend NULL
1363 #define sl811h_bus_resume NULL
1368 /*-------------------------------------------------------------------------*/
1370 #ifdef STUB_DEBUG_FILE
1372 static inline void create_debug_file(struct sl811
*sl811
) { }
1373 static inline void remove_debug_file(struct sl811
*sl811
) { }
1377 #include <linux/proc_fs.h>
1378 #include <linux/seq_file.h>
1380 static void dump_irq(struct seq_file
*s
, char *label
, u8 mask
)
1382 seq_printf(s
, "%s %02x%s%s%s%s%s%s\n", label
, mask
,
1383 (mask
& SL11H_INTMASK_DONE_A
) ? " done_a" : "",
1384 (mask
& SL11H_INTMASK_DONE_B
) ? " done_b" : "",
1385 (mask
& SL11H_INTMASK_SOFINTR
) ? " sof" : "",
1386 (mask
& SL11H_INTMASK_INSRMV
) ? " ins/rmv" : "",
1387 (mask
& SL11H_INTMASK_RD
) ? " rd" : "",
1388 (mask
& SL11H_INTMASK_DP
) ? " dp" : "");
1391 static int proc_sl811h_show(struct seq_file
*s
, void *unused
)
1393 struct sl811
*sl811
= s
->private;
1394 struct sl811h_ep
*ep
;
1397 seq_printf(s
, "%s\n%s version %s\nportstatus[1] = %08x\n",
1398 sl811_to_hcd(sl811
)->product_desc
,
1399 hcd_name
, DRIVER_VERSION
,
1402 seq_printf(s
, "insert/remove: %ld\n", sl811
->stat_insrmv
);
1403 seq_printf(s
, "current session: done_a %ld done_b %ld "
1404 "wake %ld sof %ld overrun %ld lost %ld\n\n",
1405 sl811
->stat_a
, sl811
->stat_b
,
1406 sl811
->stat_wake
, sl811
->stat_sof
,
1407 sl811
->stat_overrun
, sl811
->stat_lost
);
1409 spin_lock_irq(&sl811
->lock
);
1411 if (sl811
->ctrl1
& SL11H_CTL1MASK_SUSPEND
)
1412 seq_printf(s
, "(suspended)\n\n");
1414 u8 t
= sl811_read(sl811
, SL11H_CTLREG1
);
1416 seq_printf(s
, "ctrl1 %02x%s%s%s%s\n", t
,
1417 (t
& SL11H_CTL1MASK_SOF_ENA
) ? " sofgen" : "",
1418 ({char *s
; switch (t
& SL11H_CTL1MASK_FORCE
) {
1419 case SL11H_CTL1MASK_NORMAL
: s
= ""; break;
1420 case SL11H_CTL1MASK_SE0
: s
= " se0/reset"; break;
1421 case SL11H_CTL1MASK_K
: s
= " k/resume"; break;
1422 default: s
= "j"; break;
1424 (t
& SL11H_CTL1MASK_LSPD
) ? " lowspeed" : "",
1425 (t
& SL11H_CTL1MASK_SUSPEND
) ? " suspend" : "");
1427 dump_irq(s
, "irq_enable",
1428 sl811_read(sl811
, SL11H_IRQ_ENABLE
));
1429 dump_irq(s
, "irq_status",
1430 sl811_read(sl811
, SL11H_IRQ_STATUS
));
1431 seq_printf(s
, "frame clocks remaining: %d\n",
1432 sl811_read(sl811
, SL11H_SOFTMRREG
) << 6);
1435 seq_printf(s
, "A: qh%p ctl %02x sts %02x\n", sl811
->active_a
,
1436 sl811_read(sl811
, SL811_EP_A(SL11H_HOSTCTLREG
)),
1437 sl811_read(sl811
, SL811_EP_A(SL11H_PKTSTATREG
)));
1438 seq_printf(s
, "B: qh%p ctl %02x sts %02x\n", sl811
->active_b
,
1439 sl811_read(sl811
, SL811_EP_B(SL11H_HOSTCTLREG
)),
1440 sl811_read(sl811
, SL811_EP_B(SL11H_PKTSTATREG
)));
1441 seq_printf(s
, "\n");
1442 list_for_each_entry (ep
, &sl811
->async
, schedule
) {
1445 seq_printf(s
, "%s%sqh%p, ep%d%s, maxpacket %d"
1447 (ep
== sl811
->active_a
) ? "(A) " : "",
1448 (ep
== sl811
->active_b
) ? "(B) " : "",
1450 ({ char *s
; switch (ep
->nextpid
) {
1451 case USB_PID_IN
: s
= "in"; break;
1452 case USB_PID_OUT
: s
= "out"; break;
1453 case USB_PID_SETUP
: s
= "setup"; break;
1454 case USB_PID_ACK
: s
= "status"; break;
1455 default: s
= "?"; break;
1458 ep
->nak_count
, ep
->error_count
);
1459 list_for_each_entry (urb
, &ep
->hep
->urb_list
, urb_list
) {
1460 seq_printf(s
, " urb%p, %d/%d\n", urb
,
1462 urb
->transfer_buffer_length
);
1465 if (!list_empty(&sl811
->async
))
1466 seq_printf(s
, "\n");
1468 seq_printf(s
, "periodic size= %d\n", PERIODIC_SIZE
);
1470 for (i
= 0; i
< PERIODIC_SIZE
; i
++) {
1471 ep
= sl811
->periodic
[i
];
1474 seq_printf(s
, "%2d [%3d]:\n", i
, sl811
->load
[i
]);
1476 /* DUMB: prints shared entries multiple times */
1479 " %s%sqh%d/%p (%sdev%d ep%d%s max %d) "
1481 (ep
== sl811
->active_a
) ? "(A) " : "",
1482 (ep
== sl811
->active_b
) ? "(B) " : "",
1484 (ep
->udev
->speed
== USB_SPEED_FULL
)
1486 ep
->udev
->devnum
, ep
->epnum
,
1487 (ep
->epnum
== 0) ? ""
1488 : ((ep
->nextpid
== USB_PID_IN
)
1491 ep
->maxpacket
, ep
->error_count
);
1496 spin_unlock_irq(&sl811
->lock
);
1497 seq_printf(s
, "\n");
1502 static int proc_sl811h_open(struct inode
*inode
, struct file
*file
)
1504 return single_open(file
, proc_sl811h_show
, PDE(inode
)->data
);
1507 static const struct file_operations proc_ops
= {
1508 .open
= proc_sl811h_open
,
1510 .llseek
= seq_lseek
,
1511 .release
= single_release
,
1514 /* expect just one sl811 per system */
1515 static const char proc_filename
[] = "driver/sl811h";
1517 static void create_debug_file(struct sl811
*sl811
)
1519 sl811
->pde
= proc_create_data(proc_filename
, 0, NULL
, &proc_ops
, sl811
);
1522 static void remove_debug_file(struct sl811
*sl811
)
1525 remove_proc_entry(proc_filename
, NULL
);
1530 /*-------------------------------------------------------------------------*/
1533 sl811h_stop(struct usb_hcd
*hcd
)
1535 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1536 unsigned long flags
;
1538 del_timer_sync(&hcd
->rh_timer
);
1540 spin_lock_irqsave(&sl811
->lock
, flags
);
1541 port_power(sl811
, 0);
1542 spin_unlock_irqrestore(&sl811
->lock
, flags
);
1546 sl811h_start(struct usb_hcd
*hcd
)
1548 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1550 /* chip has been reset, VBUS power is off */
1551 hcd
->state
= HC_STATE_RUNNING
;
1554 if (!device_can_wakeup(hcd
->self
.controller
))
1555 device_init_wakeup(hcd
->self
.controller
,
1556 sl811
->board
->can_wakeup
);
1557 hcd
->power_budget
= sl811
->board
->power
* 2;
1560 /* enable power and interrupts */
1561 port_power(sl811
, 1);
1566 /*-------------------------------------------------------------------------*/
1568 static struct hc_driver sl811h_hc_driver
= {
1569 .description
= hcd_name
,
1570 .hcd_priv_size
= sizeof(struct sl811
),
1573 * generic hardware linkage
1576 .flags
= HCD_USB11
| HCD_MEMORY
,
1578 /* Basic lifecycle operations */
1579 .start
= sl811h_start
,
1580 .stop
= sl811h_stop
,
1583 * managing i/o requests and associated device resources
1585 .urb_enqueue
= sl811h_urb_enqueue
,
1586 .urb_dequeue
= sl811h_urb_dequeue
,
1587 .endpoint_disable
= sl811h_endpoint_disable
,
1590 * periodic schedule support
1592 .get_frame_number
= sl811h_get_frame
,
1597 .hub_status_data
= sl811h_hub_status_data
,
1598 .hub_control
= sl811h_hub_control
,
1599 .bus_suspend
= sl811h_bus_suspend
,
1600 .bus_resume
= sl811h_bus_resume
,
1603 /*-------------------------------------------------------------------------*/
1605 static int __devexit
1606 sl811h_remove(struct platform_device
*dev
)
1608 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
1609 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1610 struct resource
*res
;
1612 remove_debug_file(sl811
);
1613 usb_remove_hcd(hcd
);
1615 /* some platforms may use IORESOURCE_IO */
1616 res
= platform_get_resource(dev
, IORESOURCE_MEM
, 1);
1618 iounmap(sl811
->data_reg
);
1620 res
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
1622 iounmap(sl811
->addr_reg
);
1628 static int __devinit
1629 sl811h_probe(struct platform_device
*dev
)
1631 struct usb_hcd
*hcd
;
1632 struct sl811
*sl811
;
1633 struct resource
*addr
, *data
, *ires
;
1635 void __iomem
*addr_reg
;
1636 void __iomem
*data_reg
;
1639 unsigned long irqflags
;
1641 /* basic sanity checks first. board-specific init logic should
1642 * have initialized these three resources and probably board
1643 * specific platform_data. we don't probe for IRQs, and do only
1644 * minimal sanity checking.
1646 ires
= platform_get_resource(dev
, IORESOURCE_IRQ
, 0);
1647 if (dev
->num_resources
< 3 || !ires
)
1651 irqflags
= ires
->flags
& IRQF_TRIGGER_MASK
;
1653 /* refuse to confuse usbcore */
1654 if (dev
->dev
.dma_mask
) {
1655 DBG("no we won't dma\n");
1659 /* the chip may be wired for either kind of addressing */
1660 addr
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
1661 data
= platform_get_resource(dev
, IORESOURCE_MEM
, 1);
1663 if (!addr
|| !data
) {
1664 addr
= platform_get_resource(dev
, IORESOURCE_IO
, 0);
1665 data
= platform_get_resource(dev
, IORESOURCE_IO
, 1);
1670 * NOTE: 64-bit resource->start is getting truncated
1671 * to avoid compiler warning, assuming that ->start
1672 * is always 32-bit for this case
1674 addr_reg
= (void __iomem
*) (unsigned long) addr
->start
;
1675 data_reg
= (void __iomem
*) (unsigned long) data
->start
;
1677 addr_reg
= ioremap(addr
->start
, 1);
1678 if (addr_reg
== NULL
) {
1683 data_reg
= ioremap(data
->start
, 1);
1684 if (data_reg
== NULL
) {
1690 /* allocate and initialize hcd */
1691 hcd
= usb_create_hcd(&sl811h_hc_driver
, &dev
->dev
, dev_name(&dev
->dev
));
1696 hcd
->rsrc_start
= addr
->start
;
1697 sl811
= hcd_to_sl811(hcd
);
1699 spin_lock_init(&sl811
->lock
);
1700 INIT_LIST_HEAD(&sl811
->async
);
1701 sl811
->board
= dev
->dev
.platform_data
;
1702 init_timer(&sl811
->timer
);
1703 sl811
->timer
.function
= sl811h_timer
;
1704 sl811
->timer
.data
= (unsigned long) sl811
;
1705 sl811
->addr_reg
= addr_reg
;
1706 sl811
->data_reg
= data_reg
;
1708 spin_lock_irq(&sl811
->lock
);
1709 port_power(sl811
, 0);
1710 spin_unlock_irq(&sl811
->lock
);
1713 tmp
= sl811_read(sl811
, SL11H_HWREVREG
);
1716 hcd
->product_desc
= "SL811HS v1.2";
1719 hcd
->product_desc
= "SL811HS v1.5";
1722 /* reject case 0, SL11S is less functional */
1723 DBG("chiprev %02x\n", tmp
);
1728 /* The chip's IRQ is level triggered, active high. A requirement
1729 * for platform device setup is to cope with things like signal
1730 * inverters (e.g. CF is active low) or working only with edge
1731 * triggers (e.g. most ARM CPUs). Initial driver stress testing
1732 * was on a system with single edge triggering, so most sorts of
1733 * triggering arrangement should work.
1735 * Use resource IRQ flags if set by platform device setup.
1737 irqflags
|= IRQF_SHARED
;
1738 retval
= usb_add_hcd(hcd
, irq
, IRQF_DISABLED
| irqflags
);
1742 create_debug_file(sl811
);
1754 DBG("init error, %d\n", retval
);
1760 /* for this device there's no useful distinction between the controller
1761 * and its root hub, except that the root hub only gets direct PM calls
1762 * when CONFIG_USB_SUSPEND is enabled.
1766 sl811h_suspend(struct platform_device
*dev
, pm_message_t state
)
1768 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
1769 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1772 switch (state
.event
) {
1773 case PM_EVENT_FREEZE
:
1774 retval
= sl811h_bus_suspend(hcd
);
1776 case PM_EVENT_SUSPEND
:
1777 case PM_EVENT_HIBERNATE
:
1778 case PM_EVENT_PRETHAW
: /* explicitly discard hw state */
1779 port_power(sl811
, 0);
1786 sl811h_resume(struct platform_device
*dev
)
1788 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
1789 struct sl811
*sl811
= hcd_to_sl811(hcd
);
1791 /* with no "check to see if VBUS is still powered" board hook,
1792 * let's assume it'd only be powered to enable remote wakeup.
1794 if (!sl811
->port1
|| !device_can_wakeup(&hcd
->self
.root_hub
->dev
)) {
1796 port_power(sl811
, 1);
1797 usb_root_hub_lost_power(hcd
->self
.root_hub
);
1801 return sl811h_bus_resume(hcd
);
1806 #define sl811h_suspend NULL
1807 #define sl811h_resume NULL
1812 /* this driver is exported so sl811_cs can depend on it */
1813 struct platform_driver sl811h_driver
= {
1814 .probe
= sl811h_probe
,
1815 .remove
= __devexit_p(sl811h_remove
),
1817 .suspend
= sl811h_suspend
,
1818 .resume
= sl811h_resume
,
1820 .name
= (char *) hcd_name
,
1821 .owner
= THIS_MODULE
,
1824 EXPORT_SYMBOL(sl811h_driver
);
1826 /*-------------------------------------------------------------------------*/
1828 static int __init
sl811h_init(void)
1833 INFO("driver %s, %s\n", hcd_name
, DRIVER_VERSION
);
1834 return platform_driver_register(&sl811h_driver
);
1836 module_init(sl811h_init
);
1838 static void __exit
sl811h_cleanup(void)
1840 platform_driver_unregister(&sl811h_driver
);
1842 module_exit(sl811h_cleanup
);