1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2008 Rodolfo Giometti <giometti@linux.it>
4 * Copyright (c) 2008 Eurotech S.p.A. <info@eurtech.it>
6 * This code is *strongly* based on EHCI-HCD code by David Brownell since
7 * the chip is a quasi-EHCI compatible.
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/module.h>
25 #include <linux/pci.h>
26 #include <linux/dmapool.h>
27 #include <linux/kernel.h>
28 #include <linux/delay.h>
29 #include <linux/ioport.h>
30 #include <linux/sched.h>
31 #include <linux/slab.h>
32 #include <linux/errno.h>
33 #include <linux/timer.h>
34 #include <linux/list.h>
35 #include <linux/interrupt.h>
36 #include <linux/usb.h>
37 #include <linux/usb/hcd.h>
38 #include <linux/moduleparam.h>
39 #include <linux/dma-mapping.h>
43 #include <asm/unaligned.h>
45 #include <linux/irq.h>
46 #include <linux/platform_device.h>
50 #define DRIVER_VERSION "0.0.50"
56 #define oxu_dbg(oxu, fmt, args...) \
57 dev_dbg(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
58 #define oxu_err(oxu, fmt, args...) \
59 dev_err(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
60 #define oxu_info(oxu, fmt, args...) \
61 dev_info(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
63 #ifdef CONFIG_DYNAMIC_DEBUG
67 static inline struct usb_hcd
*oxu_to_hcd(struct oxu_hcd
*oxu
)
69 return container_of((void *) oxu
, struct usb_hcd
, hcd_priv
);
72 static inline struct oxu_hcd
*hcd_to_oxu(struct usb_hcd
*hcd
)
74 return (struct oxu_hcd
*) (hcd
->hcd_priv
);
82 #undef OXU_VERBOSE_DEBUG
84 #ifdef OXU_VERBOSE_DEBUG
85 #define oxu_vdbg oxu_dbg
87 #define oxu_vdbg(oxu, fmt, args...) /* Nop */
92 static int __attribute__((__unused__
))
93 dbg_status_buf(char *buf
, unsigned len
, const char *label
, u32 status
)
95 return scnprintf(buf
, len
, "%s%sstatus %04x%s%s%s%s%s%s%s%s%s%s",
96 label
, label
[0] ? " " : "", status
,
97 (status
& STS_ASS
) ? " Async" : "",
98 (status
& STS_PSS
) ? " Periodic" : "",
99 (status
& STS_RECL
) ? " Recl" : "",
100 (status
& STS_HALT
) ? " Halt" : "",
101 (status
& STS_IAA
) ? " IAA" : "",
102 (status
& STS_FATAL
) ? " FATAL" : "",
103 (status
& STS_FLR
) ? " FLR" : "",
104 (status
& STS_PCD
) ? " PCD" : "",
105 (status
& STS_ERR
) ? " ERR" : "",
106 (status
& STS_INT
) ? " INT" : ""
110 static int __attribute__((__unused__
))
111 dbg_intr_buf(char *buf
, unsigned len
, const char *label
, u32 enable
)
113 return scnprintf(buf
, len
, "%s%sintrenable %02x%s%s%s%s%s%s",
114 label
, label
[0] ? " " : "", enable
,
115 (enable
& STS_IAA
) ? " IAA" : "",
116 (enable
& STS_FATAL
) ? " FATAL" : "",
117 (enable
& STS_FLR
) ? " FLR" : "",
118 (enable
& STS_PCD
) ? " PCD" : "",
119 (enable
& STS_ERR
) ? " ERR" : "",
120 (enable
& STS_INT
) ? " INT" : ""
124 static const char *const fls_strings
[] =
125 { "1024", "512", "256", "??" };
127 static int dbg_command_buf(char *buf
, unsigned len
,
128 const char *label
, u32 command
)
130 return scnprintf(buf
, len
,
131 "%s%scommand %06x %s=%d ithresh=%d%s%s%s%s period=%s%s %s",
132 label
, label
[0] ? " " : "", command
,
133 (command
& CMD_PARK
) ? "park" : "(park)",
134 CMD_PARK_CNT(command
),
135 (command
>> 16) & 0x3f,
136 (command
& CMD_LRESET
) ? " LReset" : "",
137 (command
& CMD_IAAD
) ? " IAAD" : "",
138 (command
& CMD_ASE
) ? " Async" : "",
139 (command
& CMD_PSE
) ? " Periodic" : "",
140 fls_strings
[(command
>> 2) & 0x3],
141 (command
& CMD_RESET
) ? " Reset" : "",
142 (command
& CMD_RUN
) ? "RUN" : "HALT"
146 static int dbg_port_buf(char *buf
, unsigned len
, const char *label
,
147 int port
, u32 status
)
151 /* signaling state */
152 switch (status
& (3 << 10)) {
157 sig
= "k"; /* low speed */
167 return scnprintf(buf
, len
,
168 "%s%sport %d status %06x%s%s sig=%s%s%s%s%s%s%s%s%s%s",
169 label
, label
[0] ? " " : "", port
, status
,
170 (status
& PORT_POWER
) ? " POWER" : "",
171 (status
& PORT_OWNER
) ? " OWNER" : "",
173 (status
& PORT_RESET
) ? " RESET" : "",
174 (status
& PORT_SUSPEND
) ? " SUSPEND" : "",
175 (status
& PORT_RESUME
) ? " RESUME" : "",
176 (status
& PORT_OCC
) ? " OCC" : "",
177 (status
& PORT_OC
) ? " OC" : "",
178 (status
& PORT_PEC
) ? " PEC" : "",
179 (status
& PORT_PE
) ? " PE" : "",
180 (status
& PORT_CSC
) ? " CSC" : "",
181 (status
& PORT_CONNECT
) ? " CONNECT" : ""
187 static inline int __attribute__((__unused__
))
188 dbg_status_buf(char *buf
, unsigned len
, const char *label
, u32 status
)
191 static inline int __attribute__((__unused__
))
192 dbg_command_buf(char *buf
, unsigned len
, const char *label
, u32 command
)
195 static inline int __attribute__((__unused__
))
196 dbg_intr_buf(char *buf
, unsigned len
, const char *label
, u32 enable
)
199 static inline int __attribute__((__unused__
))
200 dbg_port_buf(char *buf
, unsigned len
, const char *label
, int port
, u32 status
)
205 /* functions have the "wrong" filename when they're output... */
206 #define dbg_status(oxu, label, status) { \
208 dbg_status_buf(_buf, sizeof _buf, label, status); \
209 oxu_dbg(oxu, "%s\n", _buf); \
212 #define dbg_cmd(oxu, label, command) { \
214 dbg_command_buf(_buf, sizeof _buf, label, command); \
215 oxu_dbg(oxu, "%s\n", _buf); \
218 #define dbg_port(oxu, label, port, status) { \
220 dbg_port_buf(_buf, sizeof _buf, label, port, status); \
221 oxu_dbg(oxu, "%s\n", _buf); \
228 /* Initial IRQ latency: faster than hw default */
229 static int log2_irq_thresh
; /* 0 to 6 */
230 module_param(log2_irq_thresh
, int, S_IRUGO
);
231 MODULE_PARM_DESC(log2_irq_thresh
, "log2 IRQ latency, 1-64 microframes");
233 /* Initial park setting: slower than hw default */
234 static unsigned park
;
235 module_param(park
, uint
, S_IRUGO
);
236 MODULE_PARM_DESC(park
, "park setting; 1-3 back-to-back async packets");
238 /* For flakey hardware, ignore overcurrent indicators */
239 static bool ignore_oc
;
240 module_param(ignore_oc
, bool, S_IRUGO
);
241 MODULE_PARM_DESC(ignore_oc
, "ignore bogus hardware overcurrent indications");
244 static void ehci_work(struct oxu_hcd
*oxu
);
245 static int oxu_hub_control(struct usb_hcd
*hcd
,
246 u16 typeReq
, u16 wValue
, u16 wIndex
,
247 char *buf
, u16 wLength
);
253 /* Low level read/write registers functions */
254 static inline u32
oxu_readl(void *base
, u32 reg
)
256 return readl(base
+ reg
);
259 static inline void oxu_writel(void *base
, u32 reg
, u32 val
)
261 writel(val
, base
+ reg
);
264 static inline void timer_action_done(struct oxu_hcd
*oxu
,
265 enum ehci_timer_action action
)
267 clear_bit(action
, &oxu
->actions
);
270 static inline void timer_action(struct oxu_hcd
*oxu
,
271 enum ehci_timer_action action
)
273 if (!test_and_set_bit(action
, &oxu
->actions
)) {
277 case TIMER_IAA_WATCHDOG
:
278 t
= EHCI_IAA_JIFFIES
;
280 case TIMER_IO_WATCHDOG
:
283 case TIMER_ASYNC_OFF
:
284 t
= EHCI_ASYNC_JIFFIES
;
286 case TIMER_ASYNC_SHRINK
:
288 t
= EHCI_SHRINK_JIFFIES
;
292 /* all timings except IAA watchdog can be overridden.
293 * async queue SHRINK often precedes IAA. while it's ready
294 * to go OFF neither can matter, and afterwards the IO
295 * watchdog stops unless there's still periodic traffic.
297 if (action
!= TIMER_IAA_WATCHDOG
298 && t
> oxu
->watchdog
.expires
299 && timer_pending(&oxu
->watchdog
))
301 mod_timer(&oxu
->watchdog
, t
);
306 * handshake - spin reading hc until handshake completes or fails
307 * @ptr: address of hc register to be read
308 * @mask: bits to look at in result of read
309 * @done: value of those bits when handshake succeeds
310 * @usec: timeout in microseconds
312 * Returns negative errno, or zero on success
314 * Success happens when the "mask" bits have the specified value (hardware
315 * handshake done). There are two failure modes: "usec" have passed (major
316 * hardware flakeout), or the register reads as all-ones (hardware removed).
318 * That last failure should_only happen in cases like physical cardbus eject
319 * before driver shutdown. But it also seems to be caused by bugs in cardbus
320 * bridge shutdown: shutting down the bridge before the devices using it.
322 static int handshake(struct oxu_hcd
*oxu
, void __iomem
*ptr
,
323 u32 mask
, u32 done
, int usec
)
329 if (result
== ~(u32
)0) /* card removed */
340 /* Force HC to halt state from unknown (EHCI spec section 2.3) */
341 static int ehci_halt(struct oxu_hcd
*oxu
)
343 u32 temp
= readl(&oxu
->regs
->status
);
345 /* disable any irqs left enabled by previous code */
346 writel(0, &oxu
->regs
->intr_enable
);
348 if ((temp
& STS_HALT
) != 0)
351 temp
= readl(&oxu
->regs
->command
);
353 writel(temp
, &oxu
->regs
->command
);
354 return handshake(oxu
, &oxu
->regs
->status
,
355 STS_HALT
, STS_HALT
, 16 * 125);
358 /* Put TDI/ARC silicon into EHCI mode */
359 static void tdi_reset(struct oxu_hcd
*oxu
)
361 u32 __iomem
*reg_ptr
;
364 reg_ptr
= (u32 __iomem
*)(((u8 __iomem
*)oxu
->regs
) + 0x68);
365 tmp
= readl(reg_ptr
);
367 writel(tmp
, reg_ptr
);
370 /* Reset a non-running (STS_HALT == 1) controller */
371 static int ehci_reset(struct oxu_hcd
*oxu
)
374 u32 command
= readl(&oxu
->regs
->command
);
376 command
|= CMD_RESET
;
377 dbg_cmd(oxu
, "reset", command
);
378 writel(command
, &oxu
->regs
->command
);
379 oxu_to_hcd(oxu
)->state
= HC_STATE_HALT
;
380 oxu
->next_statechange
= jiffies
;
381 retval
= handshake(oxu
, &oxu
->regs
->command
,
382 CMD_RESET
, 0, 250 * 1000);
392 /* Idle the controller (from running) */
393 static void ehci_quiesce(struct oxu_hcd
*oxu
)
398 BUG_ON(!HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
));
401 /* wait for any schedule enables/disables to take effect */
402 temp
= readl(&oxu
->regs
->command
) << 10;
403 temp
&= STS_ASS
| STS_PSS
;
404 if (handshake(oxu
, &oxu
->regs
->status
, STS_ASS
| STS_PSS
,
405 temp
, 16 * 125) != 0) {
406 oxu_to_hcd(oxu
)->state
= HC_STATE_HALT
;
410 /* then disable anything that's still active */
411 temp
= readl(&oxu
->regs
->command
);
412 temp
&= ~(CMD_ASE
| CMD_IAAD
| CMD_PSE
);
413 writel(temp
, &oxu
->regs
->command
);
415 /* hardware can take 16 microframes to turn off ... */
416 if (handshake(oxu
, &oxu
->regs
->status
, STS_ASS
| STS_PSS
,
418 oxu_to_hcd(oxu
)->state
= HC_STATE_HALT
;
423 static int check_reset_complete(struct oxu_hcd
*oxu
, int index
,
424 u32 __iomem
*status_reg
, int port_status
)
426 if (!(port_status
& PORT_CONNECT
)) {
427 oxu
->reset_done
[index
] = 0;
431 /* if reset finished and it's still not enabled -- handoff */
432 if (!(port_status
& PORT_PE
)) {
433 oxu_dbg(oxu
, "Failed to enable port %d on root hub TT\n",
437 oxu_dbg(oxu
, "port %d high speed\n", index
+ 1);
442 static void ehci_hub_descriptor(struct oxu_hcd
*oxu
,
443 struct usb_hub_descriptor
*desc
)
445 int ports
= HCS_N_PORTS(oxu
->hcs_params
);
448 desc
->bDescriptorType
= USB_DT_HUB
;
449 desc
->bPwrOn2PwrGood
= 10; /* oxu 1.0, 2.3.9 says 20ms max */
450 desc
->bHubContrCurrent
= 0;
452 desc
->bNbrPorts
= ports
;
453 temp
= 1 + (ports
/ 8);
454 desc
->bDescLength
= 7 + 2 * temp
;
456 /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
457 memset(&desc
->u
.hs
.DeviceRemovable
[0], 0, temp
);
458 memset(&desc
->u
.hs
.DeviceRemovable
[temp
], 0xff, temp
);
460 temp
= HUB_CHAR_INDV_PORT_OCPM
; /* per-port overcurrent reporting */
461 if (HCS_PPC(oxu
->hcs_params
))
462 temp
|= HUB_CHAR_INDV_PORT_LPSM
; /* per-port power control */
464 temp
|= HUB_CHAR_NO_LPSM
; /* no power switching */
465 desc
->wHubCharacteristics
= (__force __u16
)cpu_to_le16(temp
);
469 /* Allocate an OXU210HP on-chip memory data buffer
471 * An on-chip memory data buffer is required for each OXU210HP USB transfer.
472 * Each transfer descriptor has one or more on-chip memory data buffers.
474 * Data buffers are allocated from a fix sized pool of data blocks.
475 * To minimise fragmentation and give reasonable memory utlisation,
476 * data buffers are allocated with sizes the power of 2 multiples of
477 * the block size, starting on an address a multiple of the allocated size.
479 * FIXME: callers of this function require a buffer to be allocated for
480 * len=0. This is a waste of on-chip memory and should be fix. Then this
481 * function should be changed to not allocate a buffer for len=0.
483 static int oxu_buf_alloc(struct oxu_hcd
*oxu
, struct ehci_qtd
*qtd
, int len
)
485 int n_blocks
; /* minium blocks needed to hold len */
486 int a_blocks
; /* blocks allocated */
489 /* Don't allocte bigger than supported */
490 if (len
> BUFFER_SIZE
* BUFFER_NUM
) {
491 oxu_err(oxu
, "buffer too big (%d)\n", len
);
495 spin_lock(&oxu
->mem_lock
);
497 /* Number of blocks needed to hold len */
498 n_blocks
= (len
+ BUFFER_SIZE
- 1) / BUFFER_SIZE
;
500 /* Round the number of blocks up to the power of 2 */
501 for (a_blocks
= 1; a_blocks
< n_blocks
; a_blocks
<<= 1)
504 /* Find a suitable available data buffer */
505 for (i
= 0; i
< BUFFER_NUM
;
506 i
+= max(a_blocks
, (int)oxu
->db_used
[i
])) {
508 /* Check all the required blocks are available */
509 for (j
= 0; j
< a_blocks
; j
++)
510 if (oxu
->db_used
[i
+ j
])
516 /* Allocate blocks found! */
517 qtd
->buffer
= (void *) &oxu
->mem
->db_pool
[i
];
518 qtd
->buffer_dma
= virt_to_phys(qtd
->buffer
);
520 qtd
->qtd_buffer_len
= BUFFER_SIZE
* a_blocks
;
521 oxu
->db_used
[i
] = a_blocks
;
523 spin_unlock(&oxu
->mem_lock
);
530 spin_unlock(&oxu
->mem_lock
);
535 static void oxu_buf_free(struct oxu_hcd
*oxu
, struct ehci_qtd
*qtd
)
539 spin_lock(&oxu
->mem_lock
);
541 index
= (qtd
->buffer
- (void *) &oxu
->mem
->db_pool
[0])
543 oxu
->db_used
[index
] = 0;
544 qtd
->qtd_buffer_len
= 0;
548 spin_unlock(&oxu
->mem_lock
);
551 static inline void ehci_qtd_init(struct ehci_qtd
*qtd
, dma_addr_t dma
)
553 memset(qtd
, 0, sizeof *qtd
);
555 qtd
->hw_token
= cpu_to_le32(QTD_STS_HALT
);
556 qtd
->hw_next
= EHCI_LIST_END
;
557 qtd
->hw_alt_next
= EHCI_LIST_END
;
558 INIT_LIST_HEAD(&qtd
->qtd_list
);
561 static inline void oxu_qtd_free(struct oxu_hcd
*oxu
, struct ehci_qtd
*qtd
)
566 oxu_buf_free(oxu
, qtd
);
568 spin_lock(&oxu
->mem_lock
);
570 index
= qtd
- &oxu
->mem
->qtd_pool
[0];
571 oxu
->qtd_used
[index
] = 0;
573 spin_unlock(&oxu
->mem_lock
);
576 static struct ehci_qtd
*ehci_qtd_alloc(struct oxu_hcd
*oxu
)
579 struct ehci_qtd
*qtd
= NULL
;
581 spin_lock(&oxu
->mem_lock
);
583 for (i
= 0; i
< QTD_NUM
; i
++)
584 if (!oxu
->qtd_used
[i
])
588 qtd
= (struct ehci_qtd
*) &oxu
->mem
->qtd_pool
[i
];
589 memset(qtd
, 0, sizeof *qtd
);
591 qtd
->hw_token
= cpu_to_le32(QTD_STS_HALT
);
592 qtd
->hw_next
= EHCI_LIST_END
;
593 qtd
->hw_alt_next
= EHCI_LIST_END
;
594 INIT_LIST_HEAD(&qtd
->qtd_list
);
596 qtd
->qtd_dma
= virt_to_phys(qtd
);
598 oxu
->qtd_used
[i
] = 1;
601 spin_unlock(&oxu
->mem_lock
);
606 static void oxu_qh_free(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
610 spin_lock(&oxu
->mem_lock
);
612 index
= qh
- &oxu
->mem
->qh_pool
[0];
613 oxu
->qh_used
[index
] = 0;
615 spin_unlock(&oxu
->mem_lock
);
618 static void qh_destroy(struct kref
*kref
)
620 struct ehci_qh
*qh
= container_of(kref
, struct ehci_qh
, kref
);
621 struct oxu_hcd
*oxu
= qh
->oxu
;
623 /* clean qtds first, and know this is not linked */
624 if (!list_empty(&qh
->qtd_list
) || qh
->qh_next
.ptr
) {
625 oxu_dbg(oxu
, "unused qh not empty!\n");
629 oxu_qtd_free(oxu
, qh
->dummy
);
630 oxu_qh_free(oxu
, qh
);
633 static struct ehci_qh
*oxu_qh_alloc(struct oxu_hcd
*oxu
)
636 struct ehci_qh
*qh
= NULL
;
638 spin_lock(&oxu
->mem_lock
);
640 for (i
= 0; i
< QHEAD_NUM
; i
++)
641 if (!oxu
->qh_used
[i
])
645 qh
= (struct ehci_qh
*) &oxu
->mem
->qh_pool
[i
];
646 memset(qh
, 0, sizeof *qh
);
648 kref_init(&qh
->kref
);
650 qh
->qh_dma
= virt_to_phys(qh
);
651 INIT_LIST_HEAD(&qh
->qtd_list
);
653 /* dummy td enables safe urb queuing */
654 qh
->dummy
= ehci_qtd_alloc(oxu
);
655 if (qh
->dummy
== NULL
) {
656 oxu_dbg(oxu
, "no dummy td\n");
665 spin_unlock(&oxu
->mem_lock
);
670 /* to share a qh (cpu threads, or hc) */
671 static inline struct ehci_qh
*qh_get(struct ehci_qh
*qh
)
677 static inline void qh_put(struct ehci_qh
*qh
)
679 kref_put(&qh
->kref
, qh_destroy
);
682 static void oxu_murb_free(struct oxu_hcd
*oxu
, struct oxu_murb
*murb
)
686 spin_lock(&oxu
->mem_lock
);
688 index
= murb
- &oxu
->murb_pool
[0];
689 oxu
->murb_used
[index
] = 0;
691 spin_unlock(&oxu
->mem_lock
);
694 static struct oxu_murb
*oxu_murb_alloc(struct oxu_hcd
*oxu
)
698 struct oxu_murb
*murb
= NULL
;
700 spin_lock(&oxu
->mem_lock
);
702 for (i
= 0; i
< MURB_NUM
; i
++)
703 if (!oxu
->murb_used
[i
])
707 murb
= &(oxu
->murb_pool
)[i
];
709 oxu
->murb_used
[i
] = 1;
712 spin_unlock(&oxu
->mem_lock
);
717 /* The queue heads and transfer descriptors are managed from pools tied
718 * to each of the "per device" structures.
719 * This is the initialisation and cleanup code.
721 static void ehci_mem_cleanup(struct oxu_hcd
*oxu
)
723 kfree(oxu
->murb_pool
);
724 oxu
->murb_pool
= NULL
;
730 del_timer(&oxu
->urb_timer
);
732 oxu
->periodic
= NULL
;
734 /* shadow periodic table */
739 /* Remember to add cleanup code (above) if you add anything here.
741 static int ehci_mem_init(struct oxu_hcd
*oxu
, gfp_t flags
)
745 for (i
= 0; i
< oxu
->periodic_size
; i
++)
746 oxu
->mem
->frame_list
[i
] = EHCI_LIST_END
;
747 for (i
= 0; i
< QHEAD_NUM
; i
++)
749 for (i
= 0; i
< QTD_NUM
; i
++)
750 oxu
->qtd_used
[i
] = 0;
752 oxu
->murb_pool
= kcalloc(MURB_NUM
, sizeof(struct oxu_murb
), flags
);
756 for (i
= 0; i
< MURB_NUM
; i
++)
757 oxu
->murb_used
[i
] = 0;
759 oxu
->async
= oxu_qh_alloc(oxu
);
763 oxu
->periodic
= (__le32
*) &oxu
->mem
->frame_list
;
764 oxu
->periodic_dma
= virt_to_phys(oxu
->periodic
);
766 for (i
= 0; i
< oxu
->periodic_size
; i
++)
767 oxu
->periodic
[i
] = EHCI_LIST_END
;
769 /* software shadow of hardware table */
770 oxu
->pshadow
= kcalloc(oxu
->periodic_size
, sizeof(void *), flags
);
771 if (oxu
->pshadow
!= NULL
)
775 oxu_dbg(oxu
, "couldn't init memory\n");
776 ehci_mem_cleanup(oxu
);
780 /* Fill a qtd, returning how much of the buffer we were able to queue up.
782 static int qtd_fill(struct ehci_qtd
*qtd
, dma_addr_t buf
, size_t len
,
783 int token
, int maxpacket
)
788 /* one buffer entry per 4K ... first might be short or unaligned */
789 qtd
->hw_buf
[0] = cpu_to_le32((u32
)addr
);
790 qtd
->hw_buf_hi
[0] = cpu_to_le32((u32
)(addr
>> 32));
791 count
= 0x1000 - (buf
& 0x0fff); /* rest of that page */
792 if (likely(len
< count
)) /* ... iff needed */
798 /* per-qtd limit: from 16K to 20K (best alignment) */
799 for (i
= 1; count
< len
&& i
< 5; i
++) {
801 qtd
->hw_buf
[i
] = cpu_to_le32((u32
)addr
);
802 qtd
->hw_buf_hi
[i
] = cpu_to_le32((u32
)(addr
>> 32));
804 if ((count
+ 0x1000) < len
)
810 /* short packets may only terminate transfers */
812 count
-= (count
% maxpacket
);
814 qtd
->hw_token
= cpu_to_le32((count
<< 16) | token
);
820 static inline void qh_update(struct oxu_hcd
*oxu
,
821 struct ehci_qh
*qh
, struct ehci_qtd
*qtd
)
823 /* writes to an active overlay are unsafe */
824 BUG_ON(qh
->qh_state
!= QH_STATE_IDLE
);
826 qh
->hw_qtd_next
= QTD_NEXT(qtd
->qtd_dma
);
827 qh
->hw_alt_next
= EHCI_LIST_END
;
829 /* Except for control endpoints, we make hardware maintain data
830 * toggle (like OHCI) ... here (re)initialize the toggle in the QH,
831 * and set the pseudo-toggle in udev. Only usb_clear_halt() will
834 if (!(qh
->hw_info1
& cpu_to_le32(1 << 14))) {
835 unsigned is_out
, epnum
;
837 is_out
= !(qtd
->hw_token
& cpu_to_le32(1 << 8));
838 epnum
= (le32_to_cpup(&qh
->hw_info1
) >> 8) & 0x0f;
839 if (unlikely(!usb_gettoggle(qh
->dev
, epnum
, is_out
))) {
840 qh
->hw_token
&= ~cpu_to_le32(QTD_TOGGLE
);
841 usb_settoggle(qh
->dev
, epnum
, is_out
, 1);
845 /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
847 qh
->hw_token
&= cpu_to_le32(QTD_TOGGLE
| QTD_STS_PING
);
850 /* If it weren't for a common silicon quirk (writing the dummy into the qh
851 * overlay, so qh->hw_token wrongly becomes inactive/halted), only fault
852 * recovery (including urb dequeue) would need software changes to a QH...
854 static void qh_refresh(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
856 struct ehci_qtd
*qtd
;
858 if (list_empty(&qh
->qtd_list
))
861 qtd
= list_entry(qh
->qtd_list
.next
,
862 struct ehci_qtd
, qtd_list
);
863 /* first qtd may already be partially processed */
864 if (cpu_to_le32(qtd
->qtd_dma
) == qh
->hw_current
)
869 qh_update(oxu
, qh
, qtd
);
872 static void qtd_copy_status(struct oxu_hcd
*oxu
, struct urb
*urb
,
873 size_t length
, u32 token
)
875 /* count IN/OUT bytes, not SETUP (even short packets) */
876 if (likely(QTD_PID(token
) != 2))
877 urb
->actual_length
+= length
- QTD_LENGTH(token
);
879 /* don't modify error codes */
880 if (unlikely(urb
->status
!= -EINPROGRESS
))
883 /* force cleanup after short read; not always an error */
884 if (unlikely(IS_SHORT_READ(token
)))
885 urb
->status
= -EREMOTEIO
;
887 /* serious "can't proceed" faults reported by the hardware */
888 if (token
& QTD_STS_HALT
) {
889 if (token
& QTD_STS_BABBLE
) {
890 /* FIXME "must" disable babbling device's port too */
891 urb
->status
= -EOVERFLOW
;
892 } else if (token
& QTD_STS_MMF
) {
893 /* fs/ls interrupt xfer missed the complete-split */
894 urb
->status
= -EPROTO
;
895 } else if (token
& QTD_STS_DBE
) {
896 urb
->status
= (QTD_PID(token
) == 1) /* IN ? */
897 ? -ENOSR
/* hc couldn't read data */
898 : -ECOMM
; /* hc couldn't write data */
899 } else if (token
& QTD_STS_XACT
) {
900 /* timeout, bad crc, wrong PID, etc; retried */
902 urb
->status
= -EPIPE
;
904 oxu_dbg(oxu
, "devpath %s ep%d%s 3strikes\n",
906 usb_pipeendpoint(urb
->pipe
),
907 usb_pipein(urb
->pipe
) ? "in" : "out");
908 urb
->status
= -EPROTO
;
910 /* CERR nonzero + no errors + halt --> stall */
911 } else if (QTD_CERR(token
))
912 urb
->status
= -EPIPE
;
914 urb
->status
= -EPROTO
;
916 oxu_vdbg(oxu
, "dev%d ep%d%s qtd token %08x --> status %d\n",
917 usb_pipedevice(urb
->pipe
),
918 usb_pipeendpoint(urb
->pipe
),
919 usb_pipein(urb
->pipe
) ? "in" : "out",
924 static void ehci_urb_done(struct oxu_hcd
*oxu
, struct urb
*urb
)
925 __releases(oxu
->lock
)
926 __acquires(oxu
->lock
)
928 if (likely(urb
->hcpriv
!= NULL
)) {
929 struct ehci_qh
*qh
= (struct ehci_qh
*) urb
->hcpriv
;
931 /* S-mask in a QH means it's an interrupt urb */
932 if ((qh
->hw_info2
& cpu_to_le32(QH_SMASK
)) != 0) {
934 /* ... update hc-wide periodic stats (for usbfs) */
935 oxu_to_hcd(oxu
)->self
.bandwidth_int_reqs
--;
941 switch (urb
->status
) {
942 case -EINPROGRESS
: /* success */
946 case -EREMOTEIO
: /* fault or normal */
947 if (!(urb
->transfer_flags
& URB_SHORT_NOT_OK
))
950 case -ECONNRESET
: /* canceled */
956 oxu_dbg(oxu
, "%s %s urb %p ep%d%s status %d len %d/%d\n",
957 __func__
, urb
->dev
->devpath
, urb
,
958 usb_pipeendpoint(urb
->pipe
),
959 usb_pipein(urb
->pipe
) ? "in" : "out",
961 urb
->actual_length
, urb
->transfer_buffer_length
);
964 /* complete() can reenter this HCD */
965 spin_unlock(&oxu
->lock
);
966 usb_hcd_giveback_urb(oxu_to_hcd(oxu
), urb
, urb
->status
);
967 spin_lock(&oxu
->lock
);
970 static void start_unlink_async(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
);
971 static void unlink_async(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
);
973 static void intr_deschedule(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
);
974 static int qh_schedule(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
);
976 #define HALT_BIT cpu_to_le32(QTD_STS_HALT)
978 /* Process and free completed qtds for a qh, returning URBs to drivers.
979 * Chases up to qh->hw_current. Returns number of completions called,
980 * indicating how much "real" work we did.
982 static unsigned qh_completions(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
984 struct ehci_qtd
*last
= NULL
, *end
= qh
->dummy
;
985 struct ehci_qtd
*qtd
, *tmp
;
990 struct oxu_murb
*murb
= NULL
;
992 if (unlikely(list_empty(&qh
->qtd_list
)))
995 /* completions (or tasks on other cpus) must never clobber HALT
996 * till we've gone through and cleaned everything up, even when
997 * they add urbs to this qh's queue or mark them for unlinking.
999 * NOTE: unlinking expects to be done in queue order.
1001 state
= qh
->qh_state
;
1002 qh
->qh_state
= QH_STATE_COMPLETING
;
1003 stopped
= (state
== QH_STATE_IDLE
);
1005 /* remove de-activated QTDs from front of queue.
1006 * after faults (including short reads), cleanup this urb
1007 * then let the queue advance.
1008 * if queue is stopped, handles unlinks.
1010 list_for_each_entry_safe(qtd
, tmp
, &qh
->qtd_list
, qtd_list
) {
1016 /* Clean up any state from previous QTD ...*/
1018 if (likely(last
->urb
!= urb
)) {
1019 if (last
->urb
->complete
== NULL
) {
1020 murb
= (struct oxu_murb
*) last
->urb
;
1021 last
->urb
= murb
->main
;
1023 ehci_urb_done(oxu
, last
->urb
);
1026 oxu_murb_free(oxu
, murb
);
1028 ehci_urb_done(oxu
, last
->urb
);
1032 oxu_qtd_free(oxu
, last
);
1036 /* ignore urbs submitted during completions we reported */
1040 /* hardware copies qtd out of qh overlay */
1042 token
= le32_to_cpu(qtd
->hw_token
);
1044 /* always clean up qtds the hc de-activated */
1045 if ((token
& QTD_STS_ACTIVE
) == 0) {
1047 if ((token
& QTD_STS_HALT
) != 0) {
1050 /* magic dummy for some short reads; qh won't advance.
1051 * that silicon quirk can kick in with this dummy too.
1053 } else if (IS_SHORT_READ(token
) &&
1054 !(qtd
->hw_alt_next
& EHCI_LIST_END
)) {
1059 /* stop scanning when we reach qtds the hc is using */
1060 } else if (likely(!stopped
&&
1061 HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
))) {
1067 if (unlikely(!HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
)))
1068 urb
->status
= -ESHUTDOWN
;
1070 /* ignore active urbs unless some previous qtd
1071 * for the urb faulted (including short read) or
1072 * its urb was canceled. we may patch qh or qtds.
1074 if (likely(urb
->status
== -EINPROGRESS
))
1077 /* issue status after short control reads */
1078 if (unlikely(do_status
!= 0)
1079 && QTD_PID(token
) == 0 /* OUT */) {
1084 /* token in overlay may be most current */
1085 if (state
== QH_STATE_IDLE
1086 && cpu_to_le32(qtd
->qtd_dma
)
1088 token
= le32_to_cpu(qh
->hw_token
);
1090 /* force halt for unlinked or blocked qh, so we'll
1091 * patch the qh later and so that completions can't
1092 * activate it while we "know" it's stopped.
1094 if ((HALT_BIT
& qh
->hw_token
) == 0) {
1096 qh
->hw_token
|= HALT_BIT
;
1101 /* Remove it from the queue */
1102 qtd_copy_status(oxu
, urb
->complete
?
1103 urb
: ((struct oxu_murb
*) urb
)->main
,
1104 qtd
->length
, token
);
1105 if ((usb_pipein(qtd
->urb
->pipe
)) &&
1106 (NULL
!= qtd
->transfer_buffer
))
1107 memcpy(qtd
->transfer_buffer
, qtd
->buffer
, qtd
->length
);
1108 do_status
= (urb
->status
== -EREMOTEIO
)
1109 && usb_pipecontrol(urb
->pipe
);
1111 if (stopped
&& qtd
->qtd_list
.prev
!= &qh
->qtd_list
) {
1112 last
= list_entry(qtd
->qtd_list
.prev
,
1113 struct ehci_qtd
, qtd_list
);
1114 last
->hw_next
= qtd
->hw_next
;
1116 list_del(&qtd
->qtd_list
);
1120 /* last urb's completion might still need calling */
1121 if (likely(last
!= NULL
)) {
1122 if (last
->urb
->complete
== NULL
) {
1123 murb
= (struct oxu_murb
*) last
->urb
;
1124 last
->urb
= murb
->main
;
1126 ehci_urb_done(oxu
, last
->urb
);
1129 oxu_murb_free(oxu
, murb
);
1131 ehci_urb_done(oxu
, last
->urb
);
1134 oxu_qtd_free(oxu
, last
);
1137 /* restore original state; caller must unlink or relink */
1138 qh
->qh_state
= state
;
1140 /* be sure the hardware's done with the qh before refreshing
1141 * it after fault cleanup, or recovering from silicon wrongly
1142 * overlaying the dummy qtd (which reduces DMA chatter).
1144 if (stopped
!= 0 || qh
->hw_qtd_next
== EHCI_LIST_END
) {
1147 qh_refresh(oxu
, qh
);
1149 case QH_STATE_LINKED
:
1150 /* should be rare for periodic transfers,
1151 * except maybe high bandwidth ...
1153 if ((cpu_to_le32(QH_SMASK
)
1154 & qh
->hw_info2
) != 0) {
1155 intr_deschedule(oxu
, qh
);
1156 (void) qh_schedule(oxu
, qh
);
1158 unlink_async(oxu
, qh
);
1160 /* otherwise, unlink already started */
1167 /* High bandwidth multiplier, as encoded in highspeed endpoint descriptors */
1168 #define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03))
1169 /* ... and packet size, for any kind of endpoint descriptor */
1170 #define max_packet(wMaxPacketSize) ((wMaxPacketSize) & 0x07ff)
1172 /* Reverse of qh_urb_transaction: free a list of TDs.
1173 * used for cleanup after errors, before HC sees an URB's TDs.
1175 static void qtd_list_free(struct oxu_hcd
*oxu
,
1176 struct urb
*urb
, struct list_head
*head
)
1178 struct ehci_qtd
*qtd
, *temp
;
1180 list_for_each_entry_safe(qtd
, temp
, head
, qtd_list
) {
1181 list_del(&qtd
->qtd_list
);
1182 oxu_qtd_free(oxu
, qtd
);
1186 /* Create a list of filled qtds for this URB; won't link into qh.
1188 static struct list_head
*qh_urb_transaction(struct oxu_hcd
*oxu
,
1190 struct list_head
*head
,
1193 struct ehci_qtd
*qtd
, *qtd_prev
;
1198 void *transfer_buf
= NULL
;
1202 * URBs map to sequences of QTDs: one logical transaction
1204 qtd
= ehci_qtd_alloc(oxu
);
1207 list_add_tail(&qtd
->qtd_list
, head
);
1210 token
= QTD_STS_ACTIVE
;
1211 token
|= (EHCI_TUNE_CERR
<< 10);
1212 /* for split transactions, SplitXState initialized to zero */
1214 len
= urb
->transfer_buffer_length
;
1215 is_input
= usb_pipein(urb
->pipe
);
1216 if (!urb
->transfer_buffer
&& urb
->transfer_buffer_length
&& is_input
)
1217 urb
->transfer_buffer
= phys_to_virt(urb
->transfer_dma
);
1219 if (usb_pipecontrol(urb
->pipe
)) {
1221 ret
= oxu_buf_alloc(oxu
, qtd
, sizeof(struct usb_ctrlrequest
));
1225 qtd_fill(qtd
, qtd
->buffer_dma
, sizeof(struct usb_ctrlrequest
),
1226 token
| (2 /* "setup" */ << 8), 8);
1227 memcpy(qtd
->buffer
, qtd
->urb
->setup_packet
,
1228 sizeof(struct usb_ctrlrequest
));
1230 /* ... and always at least one more pid */
1231 token
^= QTD_TOGGLE
;
1233 qtd
= ehci_qtd_alloc(oxu
);
1237 qtd_prev
->hw_next
= QTD_NEXT(qtd
->qtd_dma
);
1238 list_add_tail(&qtd
->qtd_list
, head
);
1240 /* for zero length DATA stages, STATUS is always IN */
1242 token
|= (1 /* "in" */ << 8);
1246 * Data transfer stage: buffer setup
1249 ret
= oxu_buf_alloc(oxu
, qtd
, len
);
1253 buf
= qtd
->buffer_dma
;
1254 transfer_buf
= urb
->transfer_buffer
;
1257 memcpy(qtd
->buffer
, qtd
->urb
->transfer_buffer
, len
);
1260 token
|= (1 /* "in" */ << 8);
1261 /* else it's already initted to "out" pid (0 << 8) */
1263 maxpacket
= max_packet(usb_maxpacket(urb
->dev
, urb
->pipe
, !is_input
));
1266 * buffer gets wrapped in one or more qtds;
1267 * last one may be "short" (including zero len)
1268 * and may serve as a control status ack
1273 this_qtd_len
= qtd_fill(qtd
, buf
, len
, token
, maxpacket
);
1274 qtd
->transfer_buffer
= transfer_buf
;
1275 len
-= this_qtd_len
;
1276 buf
+= this_qtd_len
;
1277 transfer_buf
+= this_qtd_len
;
1279 qtd
->hw_alt_next
= oxu
->async
->hw_alt_next
;
1281 /* qh makes control packets use qtd toggle; maybe switch it */
1282 if ((maxpacket
& (this_qtd_len
+ (maxpacket
- 1))) == 0)
1283 token
^= QTD_TOGGLE
;
1285 if (likely(len
<= 0))
1289 qtd
= ehci_qtd_alloc(oxu
);
1292 if (likely(len
> 0)) {
1293 ret
= oxu_buf_alloc(oxu
, qtd
, len
);
1298 qtd_prev
->hw_next
= QTD_NEXT(qtd
->qtd_dma
);
1299 list_add_tail(&qtd
->qtd_list
, head
);
1302 /* unless the bulk/interrupt caller wants a chance to clean
1303 * up after short reads, hc should advance qh past this urb
1305 if (likely((urb
->transfer_flags
& URB_SHORT_NOT_OK
) == 0
1306 || usb_pipecontrol(urb
->pipe
)))
1307 qtd
->hw_alt_next
= EHCI_LIST_END
;
1310 * control requests may need a terminating data "status" ack;
1311 * bulk ones may need a terminating short packet (zero length).
1313 if (likely(urb
->transfer_buffer_length
!= 0)) {
1316 if (usb_pipecontrol(urb
->pipe
)) {
1318 token
^= 0x0100; /* "in" <--> "out" */
1319 token
|= QTD_TOGGLE
; /* force DATA1 */
1320 } else if (usb_pipebulk(urb
->pipe
)
1321 && (urb
->transfer_flags
& URB_ZERO_PACKET
)
1322 && !(urb
->transfer_buffer_length
% maxpacket
)) {
1327 qtd
= ehci_qtd_alloc(oxu
);
1331 qtd_prev
->hw_next
= QTD_NEXT(qtd
->qtd_dma
);
1332 list_add_tail(&qtd
->qtd_list
, head
);
1334 /* never any data in such packets */
1335 qtd_fill(qtd
, 0, 0, token
, 0);
1339 /* by default, enable interrupt on urb completion */
1340 qtd
->hw_token
|= cpu_to_le32(QTD_IOC
);
1344 qtd_list_free(oxu
, urb
, head
);
1348 /* Each QH holds a qtd list; a QH is used for everything except iso.
1350 * For interrupt urbs, the scheduler must set the microframe scheduling
1351 * mask(s) each time the QH gets scheduled. For highspeed, that's
1352 * just one microframe in the s-mask. For split interrupt transactions
1353 * there are additional complications: c-mask, maybe FSTNs.
1355 static struct ehci_qh
*qh_make(struct oxu_hcd
*oxu
,
1356 struct urb
*urb
, gfp_t flags
)
1358 struct ehci_qh
*qh
= oxu_qh_alloc(oxu
);
1359 u32 info1
= 0, info2
= 0;
1367 * init endpoint/device data for this QH
1369 info1
|= usb_pipeendpoint(urb
->pipe
) << 8;
1370 info1
|= usb_pipedevice(urb
->pipe
) << 0;
1372 is_input
= usb_pipein(urb
->pipe
);
1373 type
= usb_pipetype(urb
->pipe
);
1374 maxp
= usb_maxpacket(urb
->dev
, urb
->pipe
, !is_input
);
1376 /* Compute interrupt scheduling parameters just once, and save.
1377 * - allowing for high bandwidth, how many nsec/uframe are used?
1378 * - split transactions need a second CSPLIT uframe; same question
1379 * - splits also need a schedule gap (for full/low speed I/O)
1380 * - qh has a polling interval
1382 * For control/bulk requests, the HC or TT handles these.
1384 if (type
== PIPE_INTERRUPT
) {
1385 qh
->usecs
= NS_TO_US(usb_calc_bus_time(USB_SPEED_HIGH
,
1387 hb_mult(maxp
) * max_packet(maxp
)));
1388 qh
->start
= NO_FRAME
;
1390 if (urb
->dev
->speed
== USB_SPEED_HIGH
) {
1394 qh
->period
= urb
->interval
>> 3;
1395 if (qh
->period
== 0 && urb
->interval
!= 1) {
1396 /* NOTE interval 2 or 4 uframes could work.
1397 * But interval 1 scheduling is simpler, and
1398 * includes high bandwidth.
1400 oxu_dbg(oxu
, "intr period %d uframes, NYET!\n",
1405 struct usb_tt
*tt
= urb
->dev
->tt
;
1408 /* gap is f(FS/LS transfer times) */
1409 qh
->gap_uf
= 1 + usb_calc_bus_time(urb
->dev
->speed
,
1410 is_input
, 0, maxp
) / (125 * 1000);
1412 /* FIXME this just approximates SPLIT/CSPLIT times */
1413 if (is_input
) { /* SPLIT, gap, CSPLIT+DATA */
1414 qh
->c_usecs
= qh
->usecs
+ HS_USECS(0);
1415 qh
->usecs
= HS_USECS(1);
1416 } else { /* SPLIT+DATA, gap, CSPLIT */
1417 qh
->usecs
+= HS_USECS(1);
1418 qh
->c_usecs
= HS_USECS(0);
1421 think_time
= tt
? tt
->think_time
: 0;
1422 qh
->tt_usecs
= NS_TO_US(think_time
+
1423 usb_calc_bus_time(urb
->dev
->speed
,
1424 is_input
, 0, max_packet(maxp
)));
1425 qh
->period
= urb
->interval
;
1429 /* support for tt scheduling, and access to toggles */
1433 switch (urb
->dev
->speed
) {
1435 info1
|= (1 << 12); /* EPS "low" */
1438 case USB_SPEED_FULL
:
1439 /* EPS 0 means "full" */
1440 if (type
!= PIPE_INTERRUPT
)
1441 info1
|= (EHCI_TUNE_RL_TT
<< 28);
1442 if (type
== PIPE_CONTROL
) {
1443 info1
|= (1 << 27); /* for TT */
1444 info1
|= 1 << 14; /* toggle from qtd */
1446 info1
|= maxp
<< 16;
1448 info2
|= (EHCI_TUNE_MULT_TT
<< 30);
1449 info2
|= urb
->dev
->ttport
<< 23;
1451 /* NOTE: if (PIPE_INTERRUPT) { scheduler sets c-mask } */
1455 case USB_SPEED_HIGH
: /* no TT involved */
1456 info1
|= (2 << 12); /* EPS "high" */
1457 if (type
== PIPE_CONTROL
) {
1458 info1
|= (EHCI_TUNE_RL_HS
<< 28);
1459 info1
|= 64 << 16; /* usb2 fixed maxpacket */
1460 info1
|= 1 << 14; /* toggle from qtd */
1461 info2
|= (EHCI_TUNE_MULT_HS
<< 30);
1462 } else if (type
== PIPE_BULK
) {
1463 info1
|= (EHCI_TUNE_RL_HS
<< 28);
1464 info1
|= 512 << 16; /* usb2 fixed maxpacket */
1465 info2
|= (EHCI_TUNE_MULT_HS
<< 30);
1466 } else { /* PIPE_INTERRUPT */
1467 info1
|= max_packet(maxp
) << 16;
1468 info2
|= hb_mult(maxp
) << 30;
1472 oxu_dbg(oxu
, "bogus dev %p speed %d\n", urb
->dev
, urb
->dev
->speed
);
1478 /* NOTE: if (PIPE_INTERRUPT) { scheduler sets s-mask } */
1480 /* init as live, toggle clear, advance to dummy */
1481 qh
->qh_state
= QH_STATE_IDLE
;
1482 qh
->hw_info1
= cpu_to_le32(info1
);
1483 qh
->hw_info2
= cpu_to_le32(info2
);
1484 usb_settoggle(urb
->dev
, usb_pipeendpoint(urb
->pipe
), !is_input
, 1);
1485 qh_refresh(oxu
, qh
);
1489 /* Move qh (and its qtds) onto async queue; maybe enable queue.
1491 static void qh_link_async(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
1493 __le32 dma
= QH_NEXT(qh
->qh_dma
);
1494 struct ehci_qh
*head
;
1496 /* (re)start the async schedule? */
1498 timer_action_done(oxu
, TIMER_ASYNC_OFF
);
1499 if (!head
->qh_next
.qh
) {
1500 u32 cmd
= readl(&oxu
->regs
->command
);
1502 if (!(cmd
& CMD_ASE
)) {
1503 /* in case a clear of CMD_ASE didn't take yet */
1504 (void)handshake(oxu
, &oxu
->regs
->status
,
1506 cmd
|= CMD_ASE
| CMD_RUN
;
1507 writel(cmd
, &oxu
->regs
->command
);
1508 oxu_to_hcd(oxu
)->state
= HC_STATE_RUNNING
;
1509 /* posted write need not be known to HC yet ... */
1513 /* clear halt and/or toggle; and maybe recover from silicon quirk */
1514 if (qh
->qh_state
== QH_STATE_IDLE
)
1515 qh_refresh(oxu
, qh
);
1517 /* splice right after start */
1518 qh
->qh_next
= head
->qh_next
;
1519 qh
->hw_next
= head
->hw_next
;
1522 head
->qh_next
.qh
= qh
;
1523 head
->hw_next
= dma
;
1525 qh
->qh_state
= QH_STATE_LINKED
;
1526 /* qtd completions reported later by interrupt */
1529 #define QH_ADDR_MASK cpu_to_le32(0x7f)
1532 * For control/bulk/interrupt, return QH with these TDs appended.
1533 * Allocates and initializes the QH if necessary.
1534 * Returns null if it can't allocate a QH it needs to.
1535 * If the QH has TDs (urbs) already, that's great.
1537 static struct ehci_qh
*qh_append_tds(struct oxu_hcd
*oxu
,
1538 struct urb
*urb
, struct list_head
*qtd_list
,
1539 int epnum
, void **ptr
)
1541 struct ehci_qh
*qh
= NULL
;
1543 qh
= (struct ehci_qh
*) *ptr
;
1544 if (unlikely(qh
== NULL
)) {
1545 /* can't sleep here, we have oxu->lock... */
1546 qh
= qh_make(oxu
, urb
, GFP_ATOMIC
);
1549 if (likely(qh
!= NULL
)) {
1550 struct ehci_qtd
*qtd
;
1552 if (unlikely(list_empty(qtd_list
)))
1555 qtd
= list_entry(qtd_list
->next
, struct ehci_qtd
,
1558 /* control qh may need patching ... */
1559 if (unlikely(epnum
== 0)) {
1561 /* usb_reset_device() briefly reverts to address 0 */
1562 if (usb_pipedevice(urb
->pipe
) == 0)
1563 qh
->hw_info1
&= ~QH_ADDR_MASK
;
1566 /* just one way to queue requests: swap with the dummy qtd.
1567 * only hc or qh_refresh() ever modify the overlay.
1569 if (likely(qtd
!= NULL
)) {
1570 struct ehci_qtd
*dummy
;
1574 /* to avoid racing the HC, use the dummy td instead of
1575 * the first td of our list (becomes new dummy). both
1576 * tds stay deactivated until we're done, when the
1577 * HC is allowed to fetch the old dummy (4.10.2).
1579 token
= qtd
->hw_token
;
1580 qtd
->hw_token
= HALT_BIT
;
1584 dma
= dummy
->qtd_dma
;
1586 dummy
->qtd_dma
= dma
;
1588 list_del(&qtd
->qtd_list
);
1589 list_add(&dummy
->qtd_list
, qtd_list
);
1590 list_splice(qtd_list
, qh
->qtd_list
.prev
);
1592 ehci_qtd_init(qtd
, qtd
->qtd_dma
);
1595 /* hc must see the new dummy at list end */
1597 qtd
= list_entry(qh
->qtd_list
.prev
,
1598 struct ehci_qtd
, qtd_list
);
1599 qtd
->hw_next
= QTD_NEXT(dma
);
1601 /* let the hc process these next qtds */
1602 dummy
->hw_token
= (token
& ~(0x80));
1604 dummy
->hw_token
= token
;
1606 urb
->hcpriv
= qh_get(qh
);
1612 static int submit_async(struct oxu_hcd
*oxu
, struct urb
*urb
,
1613 struct list_head
*qtd_list
, gfp_t mem_flags
)
1615 struct ehci_qtd
*qtd
;
1617 unsigned long flags
;
1618 struct ehci_qh
*qh
= NULL
;
1621 qtd
= list_entry(qtd_list
->next
, struct ehci_qtd
, qtd_list
);
1622 epnum
= urb
->ep
->desc
.bEndpointAddress
;
1624 #ifdef OXU_URB_TRACE
1625 oxu_dbg(oxu
, "%s %s urb %p ep%d%s len %d, qtd %p [qh %p]\n",
1626 __func__
, urb
->dev
->devpath
, urb
,
1627 epnum
& 0x0f, (epnum
& USB_DIR_IN
) ? "in" : "out",
1628 urb
->transfer_buffer_length
,
1629 qtd
, urb
->ep
->hcpriv
);
1632 spin_lock_irqsave(&oxu
->lock
, flags
);
1633 if (unlikely(!HCD_HW_ACCESSIBLE(oxu_to_hcd(oxu
)))) {
1638 qh
= qh_append_tds(oxu
, urb
, qtd_list
, epnum
, &urb
->ep
->hcpriv
);
1639 if (unlikely(qh
== NULL
)) {
1644 /* Control/bulk operations through TTs don't need scheduling,
1645 * the HC and TT handle it when the TT has a buffer ready.
1647 if (likely(qh
->qh_state
== QH_STATE_IDLE
))
1648 qh_link_async(oxu
, qh_get(qh
));
1650 spin_unlock_irqrestore(&oxu
->lock
, flags
);
1651 if (unlikely(qh
== NULL
))
1652 qtd_list_free(oxu
, urb
, qtd_list
);
1656 /* The async qh for the qtds being reclaimed are now unlinked from the HC */
1658 static void end_unlink_async(struct oxu_hcd
*oxu
)
1660 struct ehci_qh
*qh
= oxu
->reclaim
;
1661 struct ehci_qh
*next
;
1663 timer_action_done(oxu
, TIMER_IAA_WATCHDOG
);
1665 qh
->qh_state
= QH_STATE_IDLE
;
1666 qh
->qh_next
.qh
= NULL
;
1667 qh_put(qh
); /* refcount from reclaim */
1669 /* other unlink(s) may be pending (in QH_STATE_UNLINK_WAIT) */
1671 oxu
->reclaim
= next
;
1672 oxu
->reclaim_ready
= 0;
1675 qh_completions(oxu
, qh
);
1677 if (!list_empty(&qh
->qtd_list
)
1678 && HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
))
1679 qh_link_async(oxu
, qh
);
1681 qh_put(qh
); /* refcount from async list */
1683 /* it's not free to turn the async schedule on/off; leave it
1684 * active but idle for a while once it empties.
1686 if (HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
)
1687 && oxu
->async
->qh_next
.qh
== NULL
)
1688 timer_action(oxu
, TIMER_ASYNC_OFF
);
1692 oxu
->reclaim
= NULL
;
1693 start_unlink_async(oxu
, next
);
1697 /* makes sure the async qh will become idle */
1698 /* caller must own oxu->lock */
1700 static void start_unlink_async(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
1702 int cmd
= readl(&oxu
->regs
->command
);
1703 struct ehci_qh
*prev
;
1706 assert_spin_locked(&oxu
->lock
);
1707 BUG_ON(oxu
->reclaim
|| (qh
->qh_state
!= QH_STATE_LINKED
1708 && qh
->qh_state
!= QH_STATE_UNLINK_WAIT
));
1711 /* stop async schedule right now? */
1712 if (unlikely(qh
== oxu
->async
)) {
1713 /* can't get here without STS_ASS set */
1714 if (oxu_to_hcd(oxu
)->state
!= HC_STATE_HALT
1716 /* ... and CMD_IAAD clear */
1717 writel(cmd
& ~CMD_ASE
, &oxu
->regs
->command
);
1719 /* handshake later, if we need to */
1720 timer_action_done(oxu
, TIMER_ASYNC_OFF
);
1725 qh
->qh_state
= QH_STATE_UNLINK
;
1726 oxu
->reclaim
= qh
= qh_get(qh
);
1729 while (prev
->qh_next
.qh
!= qh
)
1730 prev
= prev
->qh_next
.qh
;
1732 prev
->hw_next
= qh
->hw_next
;
1733 prev
->qh_next
= qh
->qh_next
;
1736 if (unlikely(oxu_to_hcd(oxu
)->state
== HC_STATE_HALT
)) {
1737 /* if (unlikely(qh->reclaim != 0))
1738 * this will recurse, probably not much
1740 end_unlink_async(oxu
);
1744 oxu
->reclaim_ready
= 0;
1746 writel(cmd
, &oxu
->regs
->command
);
1747 (void) readl(&oxu
->regs
->command
);
1748 timer_action(oxu
, TIMER_IAA_WATCHDOG
);
1751 static void scan_async(struct oxu_hcd
*oxu
)
1754 enum ehci_timer_action action
= TIMER_IO_WATCHDOG
;
1756 if (!++(oxu
->stamp
))
1758 timer_action_done(oxu
, TIMER_ASYNC_SHRINK
);
1760 qh
= oxu
->async
->qh_next
.qh
;
1761 if (likely(qh
!= NULL
)) {
1763 /* clean any finished work for this qh */
1764 if (!list_empty(&qh
->qtd_list
)
1765 && qh
->stamp
!= oxu
->stamp
) {
1768 /* unlinks could happen here; completion
1769 * reporting drops the lock. rescan using
1770 * the latest schedule, but don't rescan
1771 * qhs we already finished (no looping).
1774 qh
->stamp
= oxu
->stamp
;
1775 temp
= qh_completions(oxu
, qh
);
1781 /* unlink idle entries, reducing HC PCI usage as well
1782 * as HCD schedule-scanning costs. delay for any qh
1783 * we just scanned, there's a not-unusual case that it
1784 * doesn't stay idle for long.
1785 * (plus, avoids some kind of re-activation race.)
1787 if (list_empty(&qh
->qtd_list
)) {
1788 if (qh
->stamp
== oxu
->stamp
)
1789 action
= TIMER_ASYNC_SHRINK
;
1790 else if (!oxu
->reclaim
1791 && qh
->qh_state
== QH_STATE_LINKED
)
1792 start_unlink_async(oxu
, qh
);
1795 qh
= qh
->qh_next
.qh
;
1798 if (action
== TIMER_ASYNC_SHRINK
)
1799 timer_action(oxu
, TIMER_ASYNC_SHRINK
);
1803 * periodic_next_shadow - return "next" pointer on shadow list
1804 * @periodic: host pointer to qh/itd/sitd
1805 * @tag: hardware tag for type of this record
1807 static union ehci_shadow
*periodic_next_shadow(union ehci_shadow
*periodic
,
1813 return &periodic
->qh
->qh_next
;
1817 /* caller must hold oxu->lock */
1818 static void periodic_unlink(struct oxu_hcd
*oxu
, unsigned frame
, void *ptr
)
1820 union ehci_shadow
*prev_p
= &oxu
->pshadow
[frame
];
1821 __le32
*hw_p
= &oxu
->periodic
[frame
];
1822 union ehci_shadow here
= *prev_p
;
1824 /* find predecessor of "ptr"; hw and shadow lists are in sync */
1825 while (here
.ptr
&& here
.ptr
!= ptr
) {
1826 prev_p
= periodic_next_shadow(prev_p
, Q_NEXT_TYPE(*hw_p
));
1827 hw_p
= here
.hw_next
;
1830 /* an interrupt entry (at list end) could have been shared */
1834 /* update shadow and hardware lists ... the old "next" pointers
1835 * from ptr may still be in use, the caller updates them.
1837 *prev_p
= *periodic_next_shadow(&here
, Q_NEXT_TYPE(*hw_p
));
1838 *hw_p
= *here
.hw_next
;
1841 /* how many of the uframe's 125 usecs are allocated? */
1842 static unsigned short periodic_usecs(struct oxu_hcd
*oxu
,
1843 unsigned frame
, unsigned uframe
)
1845 __le32
*hw_p
= &oxu
->periodic
[frame
];
1846 union ehci_shadow
*q
= &oxu
->pshadow
[frame
];
1850 switch (Q_NEXT_TYPE(*hw_p
)) {
1853 /* is it in the S-mask? */
1854 if (q
->qh
->hw_info2
& cpu_to_le32(1 << uframe
))
1855 usecs
+= q
->qh
->usecs
;
1856 /* ... or C-mask? */
1857 if (q
->qh
->hw_info2
& cpu_to_le32(1 << (8 + uframe
)))
1858 usecs
+= q
->qh
->c_usecs
;
1859 hw_p
= &q
->qh
->hw_next
;
1860 q
= &q
->qh
->qh_next
;
1866 oxu_err(oxu
, "uframe %d sched overrun: %d usecs\n",
1867 frame
* 8 + uframe
, usecs
);
1872 static int enable_periodic(struct oxu_hcd
*oxu
)
1877 /* did clearing PSE did take effect yet?
1878 * takes effect only at frame boundaries...
1880 status
= handshake(oxu
, &oxu
->regs
->status
, STS_PSS
, 0, 9 * 125);
1882 oxu_to_hcd(oxu
)->state
= HC_STATE_HALT
;
1883 usb_hc_died(oxu_to_hcd(oxu
));
1887 cmd
= readl(&oxu
->regs
->command
) | CMD_PSE
;
1888 writel(cmd
, &oxu
->regs
->command
);
1889 /* posted write ... PSS happens later */
1890 oxu_to_hcd(oxu
)->state
= HC_STATE_RUNNING
;
1892 /* make sure ehci_work scans these */
1893 oxu
->next_uframe
= readl(&oxu
->regs
->frame_index
)
1894 % (oxu
->periodic_size
<< 3);
1898 static int disable_periodic(struct oxu_hcd
*oxu
)
1903 /* did setting PSE not take effect yet?
1904 * takes effect only at frame boundaries...
1906 status
= handshake(oxu
, &oxu
->regs
->status
, STS_PSS
, STS_PSS
, 9 * 125);
1908 oxu_to_hcd(oxu
)->state
= HC_STATE_HALT
;
1909 usb_hc_died(oxu_to_hcd(oxu
));
1913 cmd
= readl(&oxu
->regs
->command
) & ~CMD_PSE
;
1914 writel(cmd
, &oxu
->regs
->command
);
1915 /* posted write ... */
1917 oxu
->next_uframe
= -1;
1921 /* periodic schedule slots have iso tds (normal or split) first, then a
1922 * sparse tree for active interrupt transfers.
1924 * this just links in a qh; caller guarantees uframe masks are set right.
1925 * no FSTN support (yet; oxu 0.96+)
1927 static int qh_link_periodic(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
1930 unsigned period
= qh
->period
;
1932 dev_dbg(&qh
->dev
->dev
,
1933 "link qh%d-%04x/%p start %d [%d/%d us]\n",
1934 period
, le32_to_cpup(&qh
->hw_info2
) & (QH_CMASK
| QH_SMASK
),
1935 qh
, qh
->start
, qh
->usecs
, qh
->c_usecs
);
1937 /* high bandwidth, or otherwise every microframe */
1941 for (i
= qh
->start
; i
< oxu
->periodic_size
; i
+= period
) {
1942 union ehci_shadow
*prev
= &oxu
->pshadow
[i
];
1943 __le32
*hw_p
= &oxu
->periodic
[i
];
1944 union ehci_shadow here
= *prev
;
1947 /* skip the iso nodes at list head */
1949 type
= Q_NEXT_TYPE(*hw_p
);
1950 if (type
== Q_TYPE_QH
)
1952 prev
= periodic_next_shadow(prev
, type
);
1953 hw_p
= &here
.qh
->hw_next
;
1957 /* sorting each branch by period (slow-->fast)
1958 * enables sharing interior tree nodes
1960 while (here
.ptr
&& qh
!= here
.qh
) {
1961 if (qh
->period
> here
.qh
->period
)
1963 prev
= &here
.qh
->qh_next
;
1964 hw_p
= &here
.qh
->hw_next
;
1967 /* link in this qh, unless some earlier pass did that */
1968 if (qh
!= here
.qh
) {
1971 qh
->hw_next
= *hw_p
;
1974 *hw_p
= QH_NEXT(qh
->qh_dma
);
1977 qh
->qh_state
= QH_STATE_LINKED
;
1980 /* update per-qh bandwidth for usbfs */
1981 oxu_to_hcd(oxu
)->self
.bandwidth_allocated
+= qh
->period
1982 ? ((qh
->usecs
+ qh
->c_usecs
) / qh
->period
)
1985 /* maybe enable periodic schedule processing */
1986 if (!oxu
->periodic_sched
++)
1987 return enable_periodic(oxu
);
1992 static void qh_unlink_periodic(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
1998 * IF this isn't high speed
1999 * and this qh is active in the current uframe
2000 * (and overlay token SplitXstate is false?)
2002 * qh->hw_info1 |= cpu_to_le32(1 << 7 "ignore");
2005 /* high bandwidth, or otherwise part of every microframe */
2006 period
= qh
->period
;
2010 for (i
= qh
->start
; i
< oxu
->periodic_size
; i
+= period
)
2011 periodic_unlink(oxu
, i
, qh
);
2013 /* update per-qh bandwidth for usbfs */
2014 oxu_to_hcd(oxu
)->self
.bandwidth_allocated
-= qh
->period
2015 ? ((qh
->usecs
+ qh
->c_usecs
) / qh
->period
)
2018 dev_dbg(&qh
->dev
->dev
,
2019 "unlink qh%d-%04x/%p start %d [%d/%d us]\n",
2021 le32_to_cpup(&qh
->hw_info2
) & (QH_CMASK
| QH_SMASK
),
2022 qh
, qh
->start
, qh
->usecs
, qh
->c_usecs
);
2024 /* qh->qh_next still "live" to HC */
2025 qh
->qh_state
= QH_STATE_UNLINK
;
2026 qh
->qh_next
.ptr
= NULL
;
2029 /* maybe turn off periodic schedule */
2030 oxu
->periodic_sched
--;
2031 if (!oxu
->periodic_sched
)
2032 (void) disable_periodic(oxu
);
2035 static void intr_deschedule(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
2039 qh_unlink_periodic(oxu
, qh
);
2041 /* simple/paranoid: always delay, expecting the HC needs to read
2042 * qh->hw_next or finish a writeback after SPLIT/CSPLIT ... and
2043 * expect hub_wq to clean up after any CSPLITs we won't issue.
2044 * active high speed queues may need bigger delays...
2046 if (list_empty(&qh
->qtd_list
)
2047 || (cpu_to_le32(QH_CMASK
) & qh
->hw_info2
) != 0)
2050 wait
= 55; /* worst case: 3 * 1024 */
2053 qh
->qh_state
= QH_STATE_IDLE
;
2054 qh
->hw_next
= EHCI_LIST_END
;
2058 static int check_period(struct oxu_hcd
*oxu
,
2059 unsigned frame
, unsigned uframe
,
2060 unsigned period
, unsigned usecs
)
2064 /* complete split running into next frame?
2065 * given FSTN support, we could sometimes check...
2071 * 80% periodic == 100 usec/uframe available
2072 * convert "usecs we need" to "max already claimed"
2074 usecs
= 100 - usecs
;
2076 /* we "know" 2 and 4 uframe intervals were rejected; so
2077 * for period 0, check _every_ microframe in the schedule.
2079 if (unlikely(period
== 0)) {
2081 for (uframe
= 0; uframe
< 7; uframe
++) {
2082 claimed
= periodic_usecs(oxu
, frame
, uframe
);
2083 if (claimed
> usecs
)
2086 } while ((frame
+= 1) < oxu
->periodic_size
);
2088 /* just check the specified uframe, at that period */
2091 claimed
= periodic_usecs(oxu
, frame
, uframe
);
2092 if (claimed
> usecs
)
2094 } while ((frame
+= period
) < oxu
->periodic_size
);
2100 static int check_intr_schedule(struct oxu_hcd
*oxu
,
2101 unsigned frame
, unsigned uframe
,
2102 const struct ehci_qh
*qh
, __le32
*c_maskp
)
2104 int retval
= -ENOSPC
;
2106 if (qh
->c_usecs
&& uframe
>= 6) /* FSTN territory? */
2109 if (!check_period(oxu
, frame
, uframe
, qh
->period
, qh
->usecs
))
2121 /* "first fit" scheduling policy used the first time through,
2122 * or when the previous schedule slot can't be re-used.
2124 static int qh_schedule(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
2129 unsigned frame
; /* 0..(qh->period - 1), or NO_FRAME */
2131 qh_refresh(oxu
, qh
);
2132 qh
->hw_next
= EHCI_LIST_END
;
2135 /* reuse the previous schedule slots, if we can */
2136 if (frame
< qh
->period
) {
2137 uframe
= ffs(le32_to_cpup(&qh
->hw_info2
) & QH_SMASK
);
2138 status
= check_intr_schedule(oxu
, frame
, --uframe
,
2146 /* else scan the schedule to find a group of slots such that all
2147 * uframes have enough periodic bandwidth available.
2150 /* "normal" case, uframing flexible except with splits */
2152 frame
= qh
->period
- 1;
2154 for (uframe
= 0; uframe
< 8; uframe
++) {
2155 status
= check_intr_schedule(oxu
,
2161 } while (status
&& frame
--);
2163 /* qh->period == 0 means every uframe */
2166 status
= check_intr_schedule(oxu
, 0, 0, qh
, &c_mask
);
2172 /* reset S-frame and (maybe) C-frame masks */
2173 qh
->hw_info2
&= cpu_to_le32(~(QH_CMASK
| QH_SMASK
));
2174 qh
->hw_info2
|= qh
->period
2175 ? cpu_to_le32(1 << uframe
)
2176 : cpu_to_le32(QH_SMASK
);
2177 qh
->hw_info2
|= c_mask
;
2179 oxu_dbg(oxu
, "reused qh %p schedule\n", qh
);
2181 /* stuff into the periodic schedule */
2182 status
= qh_link_periodic(oxu
, qh
);
2187 static int intr_submit(struct oxu_hcd
*oxu
, struct urb
*urb
,
2188 struct list_head
*qtd_list
, gfp_t mem_flags
)
2191 unsigned long flags
;
2194 struct list_head empty
;
2196 /* get endpoint and transfer/schedule data */
2197 epnum
= urb
->ep
->desc
.bEndpointAddress
;
2199 spin_lock_irqsave(&oxu
->lock
, flags
);
2201 if (unlikely(!HCD_HW_ACCESSIBLE(oxu_to_hcd(oxu
)))) {
2202 status
= -ESHUTDOWN
;
2206 /* get qh and force any scheduling errors */
2207 INIT_LIST_HEAD(&empty
);
2208 qh
= qh_append_tds(oxu
, urb
, &empty
, epnum
, &urb
->ep
->hcpriv
);
2213 if (qh
->qh_state
== QH_STATE_IDLE
) {
2214 status
= qh_schedule(oxu
, qh
);
2219 /* then queue the urb's tds to the qh */
2220 qh
= qh_append_tds(oxu
, urb
, qtd_list
, epnum
, &urb
->ep
->hcpriv
);
2223 /* ... update usbfs periodic stats */
2224 oxu_to_hcd(oxu
)->self
.bandwidth_int_reqs
++;
2227 spin_unlock_irqrestore(&oxu
->lock
, flags
);
2229 qtd_list_free(oxu
, urb
, qtd_list
);
2234 static inline int itd_submit(struct oxu_hcd
*oxu
, struct urb
*urb
,
2237 oxu_dbg(oxu
, "iso support is missing!\n");
2241 static inline int sitd_submit(struct oxu_hcd
*oxu
, struct urb
*urb
,
2244 oxu_dbg(oxu
, "split iso support is missing!\n");
2248 static void scan_periodic(struct oxu_hcd
*oxu
)
2250 unsigned frame
, clock
, now_uframe
, mod
;
2253 mod
= oxu
->periodic_size
<< 3;
2256 * When running, scan from last scan point up to "now"
2257 * else clean up by scanning everything that's left.
2258 * Touches as few pages as possible: cache-friendly.
2260 now_uframe
= oxu
->next_uframe
;
2261 if (HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
))
2262 clock
= readl(&oxu
->regs
->frame_index
);
2264 clock
= now_uframe
+ mod
- 1;
2268 union ehci_shadow q
, *q_p
;
2272 /* don't scan past the live uframe */
2273 frame
= now_uframe
>> 3;
2274 if (frame
== (clock
>> 3))
2275 uframes
= now_uframe
& 0x07;
2277 /* safe to scan the whole frame at once */
2283 /* scan each element in frame's queue for completions */
2284 q_p
= &oxu
->pshadow
[frame
];
2285 hw_p
= &oxu
->periodic
[frame
];
2287 type
= Q_NEXT_TYPE(*hw_p
);
2290 while (q
.ptr
!= NULL
) {
2291 union ehci_shadow temp
;
2295 /* handle any completions */
2296 temp
.qh
= qh_get(q
.qh
);
2297 type
= Q_NEXT_TYPE(q
.qh
->hw_next
);
2299 modified
= qh_completions(oxu
, temp
.qh
);
2300 if (unlikely(list_empty(&temp
.qh
->qtd_list
)))
2301 intr_deschedule(oxu
, temp
.qh
);
2305 oxu_dbg(oxu
, "corrupt type %d frame %d shadow %p\n",
2306 type
, frame
, q
.ptr
);
2310 /* assume completion callbacks modify the queue */
2311 if (unlikely(modified
))
2315 /* Stop when we catch up to the HC */
2317 /* FIXME: this assumes we won't get lapped when
2318 * latencies climb; that should be rare, but...
2319 * detect it, and just go all the way around.
2320 * FLR might help detect this case, so long as latencies
2321 * don't exceed periodic_size msec (default 1.024 sec).
2324 /* FIXME: likewise assumes HC doesn't halt mid-scan */
2326 if (now_uframe
== clock
) {
2329 if (!HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
))
2331 oxu
->next_uframe
= now_uframe
;
2332 now
= readl(&oxu
->regs
->frame_index
) % mod
;
2333 if (now_uframe
== now
)
2336 /* rescan the rest of this frame, then ... */
2345 /* On some systems, leaving remote wakeup enabled prevents system shutdown.
2346 * The firmware seems to think that powering off is a wakeup event!
2347 * This routine turns off remote wakeup and everything else, on all ports.
2349 static void ehci_turn_off_all_ports(struct oxu_hcd
*oxu
)
2351 int port
= HCS_N_PORTS(oxu
->hcs_params
);
2354 writel(PORT_RWC_BITS
, &oxu
->regs
->port_status
[port
]);
2357 static void ehci_port_power(struct oxu_hcd
*oxu
, int is_on
)
2361 if (!HCS_PPC(oxu
->hcs_params
))
2364 oxu_dbg(oxu
, "...power%s ports...\n", is_on
? "up" : "down");
2365 for (port
= HCS_N_PORTS(oxu
->hcs_params
); port
> 0; )
2366 (void) oxu_hub_control(oxu_to_hcd(oxu
),
2367 is_on
? SetPortFeature
: ClearPortFeature
,
2368 USB_PORT_FEAT_POWER
,
2373 /* Called from some interrupts, timers, and so on.
2374 * It calls driver completion functions, after dropping oxu->lock.
2376 static void ehci_work(struct oxu_hcd
*oxu
)
2378 timer_action_done(oxu
, TIMER_IO_WATCHDOG
);
2379 if (oxu
->reclaim_ready
)
2380 end_unlink_async(oxu
);
2382 /* another CPU may drop oxu->lock during a schedule scan while
2383 * it reports urb completions. this flag guards against bogus
2384 * attempts at re-entrant schedule scanning.
2390 if (oxu
->next_uframe
!= -1)
2394 /* the IO watchdog guards against hardware or driver bugs that
2395 * misplace IRQs, and should let us run completely without IRQs.
2396 * such lossage has been observed on both VT6202 and VT8235.
2398 if (HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
) &&
2399 (oxu
->async
->qh_next
.ptr
!= NULL
||
2400 oxu
->periodic_sched
!= 0))
2401 timer_action(oxu
, TIMER_IO_WATCHDOG
);
2404 static void unlink_async(struct oxu_hcd
*oxu
, struct ehci_qh
*qh
)
2406 /* if we need to use IAA and it's busy, defer */
2407 if (qh
->qh_state
== QH_STATE_LINKED
2409 && HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
)) {
2410 struct ehci_qh
*last
;
2412 for (last
= oxu
->reclaim
;
2414 last
= last
->reclaim
)
2416 qh
->qh_state
= QH_STATE_UNLINK_WAIT
;
2419 /* bypass IAA if the hc can't care */
2420 } else if (!HC_IS_RUNNING(oxu_to_hcd(oxu
)->state
) && oxu
->reclaim
)
2421 end_unlink_async(oxu
);
2423 /* something else might have unlinked the qh by now */
2424 if (qh
->qh_state
== QH_STATE_LINKED
)
2425 start_unlink_async(oxu
, qh
);
2429 * USB host controller methods
2432 static irqreturn_t
oxu210_hcd_irq(struct usb_hcd
*hcd
)
2434 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2435 u32 status
, pcd_status
= 0;
2438 spin_lock(&oxu
->lock
);
2440 status
= readl(&oxu
->regs
->status
);
2442 /* e.g. cardbus physical eject */
2443 if (status
== ~(u32
) 0) {
2444 oxu_dbg(oxu
, "device removed\n");
2449 status
&= INTR_MASK
;
2450 if (!status
|| unlikely(hcd
->state
== HC_STATE_HALT
)) {
2451 spin_unlock(&oxu
->lock
);
2455 /* clear (just) interrupts */
2456 writel(status
, &oxu
->regs
->status
);
2457 readl(&oxu
->regs
->command
); /* unblock posted write */
2460 #ifdef OXU_VERBOSE_DEBUG
2461 /* unrequested/ignored: Frame List Rollover */
2462 dbg_status(oxu
, "irq", status
);
2465 /* INT, ERR, and IAA interrupt rates can be throttled */
2467 /* normal [4.15.1.2] or error [4.15.1.1] completion */
2468 if (likely((status
& (STS_INT
|STS_ERR
)) != 0))
2471 /* complete the unlinking of some qh [4.15.2.3] */
2472 if (status
& STS_IAA
) {
2473 oxu
->reclaim_ready
= 1;
2477 /* remote wakeup [4.3.1] */
2478 if (status
& STS_PCD
) {
2479 unsigned i
= HCS_N_PORTS(oxu
->hcs_params
);
2480 pcd_status
= status
;
2482 /* resume root hub? */
2483 if (!(readl(&oxu
->regs
->command
) & CMD_RUN
))
2484 usb_hcd_resume_root_hub(hcd
);
2487 int pstatus
= readl(&oxu
->regs
->port_status
[i
]);
2489 if (pstatus
& PORT_OWNER
)
2491 if (!(pstatus
& PORT_RESUME
)
2492 || oxu
->reset_done
[i
] != 0)
2495 /* start USB_RESUME_TIMEOUT resume signaling from this
2496 * port, and make hub_wq collect PORT_STAT_C_SUSPEND to
2497 * stop that signaling.
2499 oxu
->reset_done
[i
] = jiffies
+
2500 msecs_to_jiffies(USB_RESUME_TIMEOUT
);
2501 oxu_dbg(oxu
, "port %d remote wakeup\n", i
+ 1);
2502 mod_timer(&hcd
->rh_timer
, oxu
->reset_done
[i
]);
2506 /* PCI errors [4.15.2.4] */
2507 if (unlikely((status
& STS_FATAL
) != 0)) {
2508 /* bogus "fatal" IRQs appear on some chips... why? */
2509 status
= readl(&oxu
->regs
->status
);
2510 dbg_cmd(oxu
, "fatal", readl(&oxu
->regs
->command
));
2511 dbg_status(oxu
, "fatal", status
);
2512 if (status
& STS_HALT
) {
2513 oxu_err(oxu
, "fatal error\n");
2516 writel(0, &oxu
->regs
->configured_flag
);
2518 /* generic layer kills/unlinks all urbs, then
2519 * uses oxu_stop to clean up the rest
2527 spin_unlock(&oxu
->lock
);
2528 if (pcd_status
& STS_PCD
)
2529 usb_hcd_poll_rh_status(hcd
);
2533 static irqreturn_t
oxu_irq(struct usb_hcd
*hcd
)
2535 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2536 int ret
= IRQ_HANDLED
;
2538 u32 status
= oxu_readl(hcd
->regs
, OXU_CHIPIRQSTATUS
);
2539 u32 enable
= oxu_readl(hcd
->regs
, OXU_CHIPIRQEN_SET
);
2541 /* Disable all interrupt */
2542 oxu_writel(hcd
->regs
, OXU_CHIPIRQEN_CLR
, enable
);
2544 if ((oxu
->is_otg
&& (status
& OXU_USBOTGI
)) ||
2545 (!oxu
->is_otg
&& (status
& OXU_USBSPHI
)))
2546 oxu210_hcd_irq(hcd
);
2550 /* Enable all interrupt back */
2551 oxu_writel(hcd
->regs
, OXU_CHIPIRQEN_SET
, enable
);
2556 static void oxu_watchdog(unsigned long param
)
2558 struct oxu_hcd
*oxu
= (struct oxu_hcd
*) param
;
2559 unsigned long flags
;
2561 spin_lock_irqsave(&oxu
->lock
, flags
);
2563 /* lost IAA irqs wedge things badly; seen with a vt8235 */
2565 u32 status
= readl(&oxu
->regs
->status
);
2566 if (status
& STS_IAA
) {
2567 oxu_vdbg(oxu
, "lost IAA\n");
2568 writel(STS_IAA
, &oxu
->regs
->status
);
2569 oxu
->reclaim_ready
= 1;
2573 /* stop async processing after it's idled a bit */
2574 if (test_bit(TIMER_ASYNC_OFF
, &oxu
->actions
))
2575 start_unlink_async(oxu
, oxu
->async
);
2577 /* oxu could run by timer, without IRQs ... */
2580 spin_unlock_irqrestore(&oxu
->lock
, flags
);
2583 /* One-time init, only for memory state.
2585 static int oxu_hcd_init(struct usb_hcd
*hcd
)
2587 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2592 spin_lock_init(&oxu
->lock
);
2594 setup_timer(&oxu
->watchdog
, oxu_watchdog
, (unsigned long)oxu
);
2597 * hw default: 1K periodic list heads, one per frame.
2598 * periodic_size can shrink by USBCMD update if hcc_params allows.
2600 oxu
->periodic_size
= DEFAULT_I_TDPS
;
2601 retval
= ehci_mem_init(oxu
, GFP_KERNEL
);
2605 /* controllers may cache some of the periodic schedule ... */
2606 hcc_params
= readl(&oxu
->caps
->hcc_params
);
2607 if (HCC_ISOC_CACHE(hcc_params
)) /* full frame cache */
2609 else /* N microframes cached */
2610 oxu
->i_thresh
= 2 + HCC_ISOC_THRES(hcc_params
);
2612 oxu
->reclaim
= NULL
;
2613 oxu
->reclaim_ready
= 0;
2614 oxu
->next_uframe
= -1;
2617 * dedicate a qh for the async ring head, since we couldn't unlink
2618 * a 'real' qh without stopping the async schedule [4.8]. use it
2619 * as the 'reclamation list head' too.
2620 * its dummy is used in hw_alt_next of many tds, to prevent the qh
2621 * from automatically advancing to the next td after short reads.
2623 oxu
->async
->qh_next
.qh
= NULL
;
2624 oxu
->async
->hw_next
= QH_NEXT(oxu
->async
->qh_dma
);
2625 oxu
->async
->hw_info1
= cpu_to_le32(QH_HEAD
);
2626 oxu
->async
->hw_token
= cpu_to_le32(QTD_STS_HALT
);
2627 oxu
->async
->hw_qtd_next
= EHCI_LIST_END
;
2628 oxu
->async
->qh_state
= QH_STATE_LINKED
;
2629 oxu
->async
->hw_alt_next
= QTD_NEXT(oxu
->async
->dummy
->qtd_dma
);
2631 /* clear interrupt enables, set irq latency */
2632 if (log2_irq_thresh
< 0 || log2_irq_thresh
> 6)
2633 log2_irq_thresh
= 0;
2634 temp
= 1 << (16 + log2_irq_thresh
);
2635 if (HCC_CANPARK(hcc_params
)) {
2636 /* HW default park == 3, on hardware that supports it (like
2637 * NVidia and ALI silicon), maximizes throughput on the async
2638 * schedule by avoiding QH fetches between transfers.
2640 * With fast usb storage devices and NForce2, "park" seems to
2641 * make problems: throughput reduction (!), data errors...
2644 park
= min(park
, (unsigned) 3);
2648 oxu_dbg(oxu
, "park %d\n", park
);
2650 if (HCC_PGM_FRAMELISTLEN(hcc_params
)) {
2651 /* periodic schedule size can be smaller than default */
2653 temp
|= (EHCI_TUNE_FLS
<< 2);
2655 oxu
->command
= temp
;
2660 /* Called during probe() after chip reset completes.
2662 static int oxu_reset(struct usb_hcd
*hcd
)
2664 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2666 spin_lock_init(&oxu
->mem_lock
);
2667 INIT_LIST_HEAD(&oxu
->urb_list
);
2671 hcd
->self
.controller
->dma_mask
= NULL
;
2674 oxu
->caps
= hcd
->regs
+ OXU_OTG_CAP_OFFSET
;
2675 oxu
->regs
= hcd
->regs
+ OXU_OTG_CAP_OFFSET
+ \
2676 HC_LENGTH(readl(&oxu
->caps
->hc_capbase
));
2678 oxu
->mem
= hcd
->regs
+ OXU_SPH_MEM
;
2680 oxu
->caps
= hcd
->regs
+ OXU_SPH_CAP_OFFSET
;
2681 oxu
->regs
= hcd
->regs
+ OXU_SPH_CAP_OFFSET
+ \
2682 HC_LENGTH(readl(&oxu
->caps
->hc_capbase
));
2684 oxu
->mem
= hcd
->regs
+ OXU_OTG_MEM
;
2687 oxu
->hcs_params
= readl(&oxu
->caps
->hcs_params
);
2690 return oxu_hcd_init(hcd
);
2693 static int oxu_run(struct usb_hcd
*hcd
)
2695 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2697 u32 temp
, hcc_params
;
2699 hcd
->uses_new_polling
= 1;
2701 /* EHCI spec section 4.1 */
2702 retval
= ehci_reset(oxu
);
2704 ehci_mem_cleanup(oxu
);
2707 writel(oxu
->periodic_dma
, &oxu
->regs
->frame_list
);
2708 writel((u32
) oxu
->async
->qh_dma
, &oxu
->regs
->async_next
);
2710 /* hcc_params controls whether oxu->regs->segment must (!!!)
2711 * be used; it constrains QH/ITD/SITD and QTD locations.
2712 * dma_pool consistent memory always uses segment zero.
2713 * streaming mappings for I/O buffers, like pci_map_single(),
2714 * can return segments above 4GB, if the device allows.
2716 * NOTE: the dma mask is visible through dev->dma_mask, so
2717 * drivers can pass this info along ... like NETIF_F_HIGHDMA,
2718 * Scsi_Host.highmem_io, and so forth. It's readonly to all
2719 * host side drivers though.
2721 hcc_params
= readl(&oxu
->caps
->hcc_params
);
2722 if (HCC_64BIT_ADDR(hcc_params
))
2723 writel(0, &oxu
->regs
->segment
);
2725 oxu
->command
&= ~(CMD_LRESET
| CMD_IAAD
| CMD_PSE
|
2726 CMD_ASE
| CMD_RESET
);
2727 oxu
->command
|= CMD_RUN
;
2728 writel(oxu
->command
, &oxu
->regs
->command
);
2729 dbg_cmd(oxu
, "init", oxu
->command
);
2732 * Start, enabling full USB 2.0 functionality ... usb 1.1 devices
2733 * are explicitly handed to companion controller(s), so no TT is
2734 * involved with the root hub. (Except where one is integrated,
2735 * and there's no companion controller unless maybe for USB OTG.)
2737 hcd
->state
= HC_STATE_RUNNING
;
2738 writel(FLAG_CF
, &oxu
->regs
->configured_flag
);
2739 readl(&oxu
->regs
->command
); /* unblock posted writes */
2741 temp
= HC_VERSION(readl(&oxu
->caps
->hc_capbase
));
2742 oxu_info(oxu
, "USB %x.%x started, quasi-EHCI %x.%02x, driver %s%s\n",
2743 ((oxu
->sbrn
& 0xf0)>>4), (oxu
->sbrn
& 0x0f),
2744 temp
>> 8, temp
& 0xff, DRIVER_VERSION
,
2745 ignore_oc
? ", overcurrent ignored" : "");
2747 writel(INTR_MASK
, &oxu
->regs
->intr_enable
); /* Turn On Interrupts */
2752 static void oxu_stop(struct usb_hcd
*hcd
)
2754 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2756 /* Turn off port power on all root hub ports. */
2757 ehci_port_power(oxu
, 0);
2759 /* no more interrupts ... */
2760 del_timer_sync(&oxu
->watchdog
);
2762 spin_lock_irq(&oxu
->lock
);
2763 if (HC_IS_RUNNING(hcd
->state
))
2767 writel(0, &oxu
->regs
->intr_enable
);
2768 spin_unlock_irq(&oxu
->lock
);
2770 /* let companion controllers work when we aren't */
2771 writel(0, &oxu
->regs
->configured_flag
);
2773 /* root hub is shut down separately (first, when possible) */
2774 spin_lock_irq(&oxu
->lock
);
2777 spin_unlock_irq(&oxu
->lock
);
2778 ehci_mem_cleanup(oxu
);
2780 dbg_status(oxu
, "oxu_stop completed", readl(&oxu
->regs
->status
));
2783 /* Kick in for silicon on any bus (not just pci, etc).
2784 * This forcibly disables dma and IRQs, helping kexec and other cases
2785 * where the next system software may expect clean state.
2787 static void oxu_shutdown(struct usb_hcd
*hcd
)
2789 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2791 (void) ehci_halt(oxu
);
2792 ehci_turn_off_all_ports(oxu
);
2794 /* make BIOS/etc use companion controller during reboot */
2795 writel(0, &oxu
->regs
->configured_flag
);
2797 /* unblock posted writes */
2798 readl(&oxu
->regs
->configured_flag
);
2801 /* Non-error returns are a promise to giveback() the urb later
2802 * we drop ownership so next owner (or urb unlink) can get it
2804 * urb + dev is in hcd.self.controller.urb_list
2805 * we're queueing TDs onto software and hardware lists
2807 * hcd-specific init for hcpriv hasn't been done yet
2809 * NOTE: control, bulk, and interrupt share the same code to append TDs
2810 * to a (possibly active) QH, and the same QH scanning code.
2812 static int __oxu_urb_enqueue(struct usb_hcd
*hcd
, struct urb
*urb
,
2815 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2816 struct list_head qtd_list
;
2818 INIT_LIST_HEAD(&qtd_list
);
2820 switch (usb_pipetype(urb
->pipe
)) {
2824 if (!qh_urb_transaction(oxu
, urb
, &qtd_list
, mem_flags
))
2826 return submit_async(oxu
, urb
, &qtd_list
, mem_flags
);
2828 case PIPE_INTERRUPT
:
2829 if (!qh_urb_transaction(oxu
, urb
, &qtd_list
, mem_flags
))
2831 return intr_submit(oxu
, urb
, &qtd_list
, mem_flags
);
2833 case PIPE_ISOCHRONOUS
:
2834 if (urb
->dev
->speed
== USB_SPEED_HIGH
)
2835 return itd_submit(oxu
, urb
, mem_flags
);
2837 return sitd_submit(oxu
, urb
, mem_flags
);
2841 /* This function is responsible for breaking URBs with big data size
2842 * into smaller size and processing small urbs in sequence.
2844 static int oxu_urb_enqueue(struct usb_hcd
*hcd
, struct urb
*urb
,
2847 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2849 int transfer_buffer_length
;
2850 void *transfer_buffer
;
2854 /* If not bulk pipe just enqueue the URB */
2855 if (!usb_pipebulk(urb
->pipe
))
2856 return __oxu_urb_enqueue(hcd
, urb
, mem_flags
);
2858 /* Otherwise we should verify the USB transfer buffer size! */
2859 transfer_buffer
= urb
->transfer_buffer
;
2860 transfer_buffer_length
= urb
->transfer_buffer_length
;
2862 num
= urb
->transfer_buffer_length
/ 4096;
2863 rem
= urb
->transfer_buffer_length
% 4096;
2867 /* If URB is smaller than 4096 bytes just enqueue it! */
2869 return __oxu_urb_enqueue(hcd
, urb
, mem_flags
);
2871 /* Ok, we have more job to do! :) */
2873 for (i
= 0; i
< num
- 1; i
++) {
2874 /* Get free micro URB poll till a free urb is received */
2877 murb
= (struct urb
*) oxu_murb_alloc(oxu
);
2882 /* Coping the urb */
2883 memcpy(murb
, urb
, sizeof(struct urb
));
2885 murb
->transfer_buffer_length
= 4096;
2886 murb
->transfer_buffer
= transfer_buffer
+ i
* 4096;
2888 /* Null pointer for the encodes that this is a micro urb */
2889 murb
->complete
= NULL
;
2891 ((struct oxu_murb
*) murb
)->main
= urb
;
2892 ((struct oxu_murb
*) murb
)->last
= 0;
2894 /* This loop is to guarantee urb to be processed when there's
2895 * not enough resources at a particular time by retrying.
2898 ret
= __oxu_urb_enqueue(hcd
, murb
, mem_flags
);
2904 /* Last urb requires special handling */
2906 /* Get free micro URB poll till a free urb is received */
2908 murb
= (struct urb
*) oxu_murb_alloc(oxu
);
2913 /* Coping the urb */
2914 memcpy(murb
, urb
, sizeof(struct urb
));
2916 murb
->transfer_buffer_length
= rem
> 0 ? rem
: 4096;
2917 murb
->transfer_buffer
= transfer_buffer
+ (num
- 1) * 4096;
2919 /* Null pointer for the encodes that this is a micro urb */
2920 murb
->complete
= NULL
;
2922 ((struct oxu_murb
*) murb
)->main
= urb
;
2923 ((struct oxu_murb
*) murb
)->last
= 1;
2926 ret
= __oxu_urb_enqueue(hcd
, murb
, mem_flags
);
2934 /* Remove from hardware lists.
2935 * Completions normally happen asynchronously
2937 static int oxu_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
, int status
)
2939 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
2941 unsigned long flags
;
2943 spin_lock_irqsave(&oxu
->lock
, flags
);
2944 switch (usb_pipetype(urb
->pipe
)) {
2948 qh
= (struct ehci_qh
*) urb
->hcpriv
;
2951 unlink_async(oxu
, qh
);
2954 case PIPE_INTERRUPT
:
2955 qh
= (struct ehci_qh
*) urb
->hcpriv
;
2958 switch (qh
->qh_state
) {
2959 case QH_STATE_LINKED
:
2960 intr_deschedule(oxu
, qh
);
2963 qh_completions(oxu
, qh
);
2966 oxu_dbg(oxu
, "bogus qh %p state %d\n",
2971 /* reschedule QH iff another request is queued */
2972 if (!list_empty(&qh
->qtd_list
)
2973 && HC_IS_RUNNING(hcd
->state
)) {
2976 status
= qh_schedule(oxu
, qh
);
2977 spin_unlock_irqrestore(&oxu
->lock
, flags
);
2980 /* shouldn't happen often, but ...
2981 * FIXME kill those tds' urbs
2983 dev_err(hcd
->self
.controller
,
2984 "can't reschedule qh %p, err %d\n", qh
,
2992 spin_unlock_irqrestore(&oxu
->lock
, flags
);
2996 /* Bulk qh holds the data toggle */
2997 static void oxu_endpoint_disable(struct usb_hcd
*hcd
,
2998 struct usb_host_endpoint
*ep
)
3000 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
3001 unsigned long flags
;
3002 struct ehci_qh
*qh
, *tmp
;
3004 /* ASSERT: any requests/urbs are being unlinked */
3005 /* ASSERT: nobody can be submitting urbs for this any more */
3008 spin_lock_irqsave(&oxu
->lock
, flags
);
3013 /* endpoints can be iso streams. for now, we don't
3014 * accelerate iso completions ... so spin a while.
3016 if (qh
->hw_info1
== 0) {
3017 oxu_vdbg(oxu
, "iso delay\n");
3021 if (!HC_IS_RUNNING(hcd
->state
))
3022 qh
->qh_state
= QH_STATE_IDLE
;
3023 switch (qh
->qh_state
) {
3024 case QH_STATE_LINKED
:
3025 for (tmp
= oxu
->async
->qh_next
.qh
;
3027 tmp
= tmp
->qh_next
.qh
)
3029 /* periodic qh self-unlinks on empty */
3032 unlink_async(oxu
, qh
);
3034 case QH_STATE_UNLINK
: /* wait for hw to finish? */
3036 spin_unlock_irqrestore(&oxu
->lock
, flags
);
3037 schedule_timeout_uninterruptible(1);
3039 case QH_STATE_IDLE
: /* fully unlinked */
3040 if (list_empty(&qh
->qtd_list
)) {
3047 /* caller was supposed to have unlinked any requests;
3048 * that's not our job. just leak this memory.
3050 oxu_err(oxu
, "qh %p (#%02x) state %d%s\n",
3051 qh
, ep
->desc
.bEndpointAddress
, qh
->qh_state
,
3052 list_empty(&qh
->qtd_list
) ? "" : "(has tds)");
3057 spin_unlock_irqrestore(&oxu
->lock
, flags
);
3060 static int oxu_get_frame(struct usb_hcd
*hcd
)
3062 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
3064 return (readl(&oxu
->regs
->frame_index
) >> 3) %
3068 /* Build "status change" packet (one or two bytes) from HC registers */
3069 static int oxu_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
3071 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
3072 u32 temp
, mask
, status
= 0;
3073 int ports
, i
, retval
= 1;
3074 unsigned long flags
;
3076 /* if !PM, root hub timers won't get shut down ... */
3077 if (!HC_IS_RUNNING(hcd
->state
))
3080 /* init status to no-changes */
3082 ports
= HCS_N_PORTS(oxu
->hcs_params
);
3088 /* Some boards (mostly VIA?) report bogus overcurrent indications,
3089 * causing massive log spam unless we completely ignore them. It
3090 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
3091 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
3092 * PORT_POWER; that's surprising, but maybe within-spec.
3095 mask
= PORT_CSC
| PORT_PEC
| PORT_OCC
;
3097 mask
= PORT_CSC
| PORT_PEC
;
3099 /* no hub change reports (bit 0) for now (power, ...) */
3101 /* port N changes (bit N)? */
3102 spin_lock_irqsave(&oxu
->lock
, flags
);
3103 for (i
= 0; i
< ports
; i
++) {
3104 temp
= readl(&oxu
->regs
->port_status
[i
]);
3107 * Return status information even for ports with OWNER set.
3108 * Otherwise hub_wq wouldn't see the disconnect event when a
3109 * high-speed device is switched over to the companion
3110 * controller by the user.
3113 if (!(temp
& PORT_CONNECT
))
3114 oxu
->reset_done
[i
] = 0;
3115 if ((temp
& mask
) != 0 || ((temp
& PORT_RESUME
) != 0 &&
3116 time_after_eq(jiffies
, oxu
->reset_done
[i
]))) {
3118 buf
[0] |= 1 << (i
+ 1);
3120 buf
[1] |= 1 << (i
- 7);
3124 /* FIXME autosuspend idle root hubs */
3125 spin_unlock_irqrestore(&oxu
->lock
, flags
);
3126 return status
? retval
: 0;
3129 /* Returns the speed of a device attached to a port on the root hub. */
3130 static inline unsigned int oxu_port_speed(struct oxu_hcd
*oxu
,
3131 unsigned int portsc
)
3133 switch ((portsc
>> 26) & 3) {
3137 return USB_PORT_STAT_LOW_SPEED
;
3140 return USB_PORT_STAT_HIGH_SPEED
;
3144 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
3145 static int oxu_hub_control(struct usb_hcd
*hcd
, u16 typeReq
,
3146 u16 wValue
, u16 wIndex
, char *buf
, u16 wLength
)
3148 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
3149 int ports
= HCS_N_PORTS(oxu
->hcs_params
);
3150 u32 __iomem
*status_reg
= &oxu
->regs
->port_status
[wIndex
- 1];
3152 unsigned long flags
;
3157 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
3158 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
3159 * (track current state ourselves) ... blink for diagnostics,
3160 * power, "this is the one", etc. EHCI spec supports this.
3163 spin_lock_irqsave(&oxu
->lock
, flags
);
3165 case ClearHubFeature
:
3167 case C_HUB_LOCAL_POWER
:
3168 case C_HUB_OVER_CURRENT
:
3169 /* no hub-wide feature/status flags */
3175 case ClearPortFeature
:
3176 if (!wIndex
|| wIndex
> ports
)
3179 temp
= readl(status_reg
);
3182 * Even if OWNER is set, so the port is owned by the
3183 * companion controller, hub_wq needs to be able to clear
3184 * the port-change status bits (especially
3185 * USB_PORT_STAT_C_CONNECTION).
3189 case USB_PORT_FEAT_ENABLE
:
3190 writel(temp
& ~PORT_PE
, status_reg
);
3192 case USB_PORT_FEAT_C_ENABLE
:
3193 writel((temp
& ~PORT_RWC_BITS
) | PORT_PEC
, status_reg
);
3195 case USB_PORT_FEAT_SUSPEND
:
3196 if (temp
& PORT_RESET
)
3198 if (temp
& PORT_SUSPEND
) {
3199 if ((temp
& PORT_PE
) == 0)
3201 /* resume signaling for 20 msec */
3202 temp
&= ~(PORT_RWC_BITS
| PORT_WAKE_BITS
);
3203 writel(temp
| PORT_RESUME
, status_reg
);
3204 oxu
->reset_done
[wIndex
] = jiffies
3205 + msecs_to_jiffies(20);
3208 case USB_PORT_FEAT_C_SUSPEND
:
3209 /* we auto-clear this feature */
3211 case USB_PORT_FEAT_POWER
:
3212 if (HCS_PPC(oxu
->hcs_params
))
3213 writel(temp
& ~(PORT_RWC_BITS
| PORT_POWER
),
3216 case USB_PORT_FEAT_C_CONNECTION
:
3217 writel((temp
& ~PORT_RWC_BITS
) | PORT_CSC
, status_reg
);
3219 case USB_PORT_FEAT_C_OVER_CURRENT
:
3220 writel((temp
& ~PORT_RWC_BITS
) | PORT_OCC
, status_reg
);
3222 case USB_PORT_FEAT_C_RESET
:
3223 /* GetPortStatus clears reset */
3228 readl(&oxu
->regs
->command
); /* unblock posted write */
3230 case GetHubDescriptor
:
3231 ehci_hub_descriptor(oxu
, (struct usb_hub_descriptor
*)
3235 /* no hub-wide feature/status flags */
3239 if (!wIndex
|| wIndex
> ports
)
3243 temp
= readl(status_reg
);
3245 /* wPortChange bits */
3246 if (temp
& PORT_CSC
)
3247 status
|= USB_PORT_STAT_C_CONNECTION
<< 16;
3248 if (temp
& PORT_PEC
)
3249 status
|= USB_PORT_STAT_C_ENABLE
<< 16;
3250 if ((temp
& PORT_OCC
) && !ignore_oc
)
3251 status
|= USB_PORT_STAT_C_OVERCURRENT
<< 16;
3253 /* whoever resumes must GetPortStatus to complete it!! */
3254 if (temp
& PORT_RESUME
) {
3256 /* Remote Wakeup received? */
3257 if (!oxu
->reset_done
[wIndex
]) {
3258 /* resume signaling for 20 msec */
3259 oxu
->reset_done
[wIndex
] = jiffies
3260 + msecs_to_jiffies(20);
3261 /* check the port again */
3262 mod_timer(&oxu_to_hcd(oxu
)->rh_timer
,
3263 oxu
->reset_done
[wIndex
]);
3266 /* resume completed? */
3267 else if (time_after_eq(jiffies
,
3268 oxu
->reset_done
[wIndex
])) {
3269 status
|= USB_PORT_STAT_C_SUSPEND
<< 16;
3270 oxu
->reset_done
[wIndex
] = 0;
3272 /* stop resume signaling */
3273 temp
= readl(status_reg
);
3274 writel(temp
& ~(PORT_RWC_BITS
| PORT_RESUME
),
3276 retval
= handshake(oxu
, status_reg
,
3277 PORT_RESUME
, 0, 2000 /* 2msec */);
3280 "port %d resume error %d\n",
3281 wIndex
+ 1, retval
);
3284 temp
&= ~(PORT_SUSPEND
|PORT_RESUME
|(3<<10));
3288 /* whoever resets must GetPortStatus to complete it!! */
3289 if ((temp
& PORT_RESET
)
3290 && time_after_eq(jiffies
,
3291 oxu
->reset_done
[wIndex
])) {
3292 status
|= USB_PORT_STAT_C_RESET
<< 16;
3293 oxu
->reset_done
[wIndex
] = 0;
3295 /* force reset to complete */
3296 writel(temp
& ~(PORT_RWC_BITS
| PORT_RESET
),
3298 /* REVISIT: some hardware needs 550+ usec to clear
3299 * this bit; seems too long to spin routinely...
3301 retval
= handshake(oxu
, status_reg
,
3302 PORT_RESET
, 0, 750);
3304 oxu_err(oxu
, "port %d reset error %d\n",
3305 wIndex
+ 1, retval
);
3309 /* see what we found out */
3310 temp
= check_reset_complete(oxu
, wIndex
, status_reg
,
3314 /* transfer dedicated ports to the companion hc */
3315 if ((temp
& PORT_CONNECT
) &&
3316 test_bit(wIndex
, &oxu
->companion_ports
)) {
3317 temp
&= ~PORT_RWC_BITS
;
3319 writel(temp
, status_reg
);
3320 oxu_dbg(oxu
, "port %d --> companion\n", wIndex
+ 1);
3321 temp
= readl(status_reg
);
3325 * Even if OWNER is set, there's no harm letting hub_wq
3326 * see the wPortStatus values (they should all be 0 except
3327 * for PORT_POWER anyway).
3330 if (temp
& PORT_CONNECT
) {
3331 status
|= USB_PORT_STAT_CONNECTION
;
3332 /* status may be from integrated TT */
3333 status
|= oxu_port_speed(oxu
, temp
);
3336 status
|= USB_PORT_STAT_ENABLE
;
3337 if (temp
& (PORT_SUSPEND
|PORT_RESUME
))
3338 status
|= USB_PORT_STAT_SUSPEND
;
3340 status
|= USB_PORT_STAT_OVERCURRENT
;
3341 if (temp
& PORT_RESET
)
3342 status
|= USB_PORT_STAT_RESET
;
3343 if (temp
& PORT_POWER
)
3344 status
|= USB_PORT_STAT_POWER
;
3346 #ifndef OXU_VERBOSE_DEBUG
3347 if (status
& ~0xffff) /* only if wPortChange is interesting */
3349 dbg_port(oxu
, "GetStatus", wIndex
+ 1, temp
);
3350 put_unaligned(cpu_to_le32(status
), (__le32
*) buf
);
3354 case C_HUB_LOCAL_POWER
:
3355 case C_HUB_OVER_CURRENT
:
3356 /* no hub-wide feature/status flags */
3362 case SetPortFeature
:
3363 selector
= wIndex
>> 8;
3365 if (!wIndex
|| wIndex
> ports
)
3368 temp
= readl(status_reg
);
3369 if (temp
& PORT_OWNER
)
3372 temp
&= ~PORT_RWC_BITS
;
3374 case USB_PORT_FEAT_SUSPEND
:
3375 if ((temp
& PORT_PE
) == 0
3376 || (temp
& PORT_RESET
) != 0)
3378 if (device_may_wakeup(&hcd
->self
.root_hub
->dev
))
3379 temp
|= PORT_WAKE_BITS
;
3380 writel(temp
| PORT_SUSPEND
, status_reg
);
3382 case USB_PORT_FEAT_POWER
:
3383 if (HCS_PPC(oxu
->hcs_params
))
3384 writel(temp
| PORT_POWER
, status_reg
);
3386 case USB_PORT_FEAT_RESET
:
3387 if (temp
& PORT_RESUME
)
3389 /* line status bits may report this as low speed,
3390 * which can be fine if this root hub has a
3391 * transaction translator built in.
3393 oxu_vdbg(oxu
, "port %d reset\n", wIndex
+ 1);
3398 * caller must wait, then call GetPortStatus
3399 * usb 2.0 spec says 50 ms resets on root
3401 oxu
->reset_done
[wIndex
] = jiffies
3402 + msecs_to_jiffies(50);
3403 writel(temp
, status_reg
);
3406 /* For downstream facing ports (these): one hub port is put
3407 * into test mode according to USB2 11.24.2.13, then the hub
3408 * must be reset (which for root hub now means rmmod+modprobe,
3409 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
3410 * about the EHCI-specific stuff.
3412 case USB_PORT_FEAT_TEST
:
3413 if (!selector
|| selector
> 5)
3417 temp
|= selector
<< 16;
3418 writel(temp
, status_reg
);
3424 readl(&oxu
->regs
->command
); /* unblock posted writes */
3429 /* "stall" on error */
3432 spin_unlock_irqrestore(&oxu
->lock
, flags
);
3438 static int oxu_bus_suspend(struct usb_hcd
*hcd
)
3440 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
3444 oxu_dbg(oxu
, "suspend root hub\n");
3446 if (time_before(jiffies
, oxu
->next_statechange
))
3449 port
= HCS_N_PORTS(oxu
->hcs_params
);
3450 spin_lock_irq(&oxu
->lock
);
3452 /* stop schedules, clean any completed work */
3453 if (HC_IS_RUNNING(hcd
->state
)) {
3455 hcd
->state
= HC_STATE_QUIESCING
;
3457 oxu
->command
= readl(&oxu
->regs
->command
);
3459 oxu
->reclaim_ready
= 1;
3462 /* Unlike other USB host controller types, EHCI doesn't have
3463 * any notion of "global" or bus-wide suspend. The driver has
3464 * to manually suspend all the active unsuspended ports, and
3465 * then manually resume them in the bus_resume() routine.
3467 oxu
->bus_suspended
= 0;
3469 u32 __iomem
*reg
= &oxu
->regs
->port_status
[port
];
3470 u32 t1
= readl(reg
) & ~PORT_RWC_BITS
;
3473 /* keep track of which ports we suspend */
3474 if ((t1
& PORT_PE
) && !(t1
& PORT_OWNER
) &&
3475 !(t1
& PORT_SUSPEND
)) {
3477 set_bit(port
, &oxu
->bus_suspended
);
3480 /* enable remote wakeup on all ports */
3481 if (device_may_wakeup(&hcd
->self
.root_hub
->dev
))
3482 t2
|= PORT_WKOC_E
|PORT_WKDISC_E
|PORT_WKCONN_E
;
3484 t2
&= ~(PORT_WKOC_E
|PORT_WKDISC_E
|PORT_WKCONN_E
);
3487 oxu_vdbg(oxu
, "port %d, %08x -> %08x\n",
3493 /* turn off now-idle HC */
3494 del_timer_sync(&oxu
->watchdog
);
3496 hcd
->state
= HC_STATE_SUSPENDED
;
3498 /* allow remote wakeup */
3500 if (!device_may_wakeup(&hcd
->self
.root_hub
->dev
))
3502 writel(mask
, &oxu
->regs
->intr_enable
);
3503 readl(&oxu
->regs
->intr_enable
);
3505 oxu
->next_statechange
= jiffies
+ msecs_to_jiffies(10);
3506 spin_unlock_irq(&oxu
->lock
);
3510 /* Caller has locked the root hub, and should reset/reinit on error */
3511 static int oxu_bus_resume(struct usb_hcd
*hcd
)
3513 struct oxu_hcd
*oxu
= hcd_to_oxu(hcd
);
3517 if (time_before(jiffies
, oxu
->next_statechange
))
3519 spin_lock_irq(&oxu
->lock
);
3521 /* Ideally and we've got a real resume here, and no port's power
3522 * was lost. (For PCI, that means Vaux was maintained.) But we
3523 * could instead be restoring a swsusp snapshot -- so that BIOS was
3524 * the last user of the controller, not reset/pm hardware keeping
3525 * state we gave to it.
3527 temp
= readl(&oxu
->regs
->intr_enable
);
3528 oxu_dbg(oxu
, "resume root hub%s\n", temp
? "" : " after power loss");
3530 /* at least some APM implementations will try to deliver
3531 * IRQs right away, so delay them until we're ready.
3533 writel(0, &oxu
->regs
->intr_enable
);
3535 /* re-init operational registers */
3536 writel(0, &oxu
->regs
->segment
);
3537 writel(oxu
->periodic_dma
, &oxu
->regs
->frame_list
);
3538 writel((u32
) oxu
->async
->qh_dma
, &oxu
->regs
->async_next
);
3540 /* restore CMD_RUN, framelist size, and irq threshold */
3541 writel(oxu
->command
, &oxu
->regs
->command
);
3543 /* Some controller/firmware combinations need a delay during which
3544 * they set up the port statuses. See Bugzilla #8190. */
3547 /* manually resume the ports we suspended during bus_suspend() */
3548 i
= HCS_N_PORTS(oxu
->hcs_params
);
3550 temp
= readl(&oxu
->regs
->port_status
[i
]);
3551 temp
&= ~(PORT_RWC_BITS
3552 | PORT_WKOC_E
| PORT_WKDISC_E
| PORT_WKCONN_E
);
3553 if (test_bit(i
, &oxu
->bus_suspended
) && (temp
& PORT_SUSPEND
)) {
3554 oxu
->reset_done
[i
] = jiffies
+ msecs_to_jiffies(20);
3555 temp
|= PORT_RESUME
;
3557 writel(temp
, &oxu
->regs
->port_status
[i
]);
3559 i
= HCS_N_PORTS(oxu
->hcs_params
);
3562 temp
= readl(&oxu
->regs
->port_status
[i
]);
3563 if (test_bit(i
, &oxu
->bus_suspended
) && (temp
& PORT_SUSPEND
)) {
3564 temp
&= ~(PORT_RWC_BITS
| PORT_RESUME
);
3565 writel(temp
, &oxu
->regs
->port_status
[i
]);
3566 oxu_vdbg(oxu
, "resumed port %d\n", i
+ 1);
3569 (void) readl(&oxu
->regs
->command
);
3571 /* maybe re-activate the schedule(s) */
3573 if (oxu
->async
->qh_next
.qh
)
3575 if (oxu
->periodic_sched
)
3578 oxu
->command
|= temp
;
3579 writel(oxu
->command
, &oxu
->regs
->command
);
3582 oxu
->next_statechange
= jiffies
+ msecs_to_jiffies(5);
3583 hcd
->state
= HC_STATE_RUNNING
;
3585 /* Now we can safely re-enable irqs */
3586 writel(INTR_MASK
, &oxu
->regs
->intr_enable
);
3588 spin_unlock_irq(&oxu
->lock
);
3594 static int oxu_bus_suspend(struct usb_hcd
*hcd
)
3599 static int oxu_bus_resume(struct usb_hcd
*hcd
)
3604 #endif /* CONFIG_PM */
3606 static const struct hc_driver oxu_hc_driver
= {
3607 .description
= "oxu210hp_hcd",
3608 .product_desc
= "oxu210hp HCD",
3609 .hcd_priv_size
= sizeof(struct oxu_hcd
),
3612 * Generic hardware linkage
3615 .flags
= HCD_MEMORY
| HCD_USB2
,
3618 * Basic lifecycle operations
3623 .shutdown
= oxu_shutdown
,
3626 * Managing i/o requests and associated device resources
3628 .urb_enqueue
= oxu_urb_enqueue
,
3629 .urb_dequeue
= oxu_urb_dequeue
,
3630 .endpoint_disable
= oxu_endpoint_disable
,
3633 * Scheduling support
3635 .get_frame_number
= oxu_get_frame
,
3640 .hub_status_data
= oxu_hub_status_data
,
3641 .hub_control
= oxu_hub_control
,
3642 .bus_suspend
= oxu_bus_suspend
,
3643 .bus_resume
= oxu_bus_resume
,
3650 static void oxu_configuration(struct platform_device
*pdev
, void *base
)
3654 /* Initialize top level registers.
3657 oxu_writel(base
, OXU_HOSTIFCONFIG
, 0x0000037D);
3658 oxu_writel(base
, OXU_SOFTRESET
, OXU_SRESET
);
3659 oxu_writel(base
, OXU_HOSTIFCONFIG
, 0x0000037D);
3661 tmp
= oxu_readl(base
, OXU_PIOBURSTREADCTRL
);
3662 oxu_writel(base
, OXU_PIOBURSTREADCTRL
, tmp
| 0x0040);
3664 oxu_writel(base
, OXU_ASO
, OXU_SPHPOEN
| OXU_OVRCCURPUPDEN
|
3665 OXU_COMPARATOR
| OXU_ASO_OP
);
3667 tmp
= oxu_readl(base
, OXU_CLKCTRL_SET
);
3668 oxu_writel(base
, OXU_CLKCTRL_SET
, tmp
| OXU_SYSCLKEN
| OXU_USBOTGCLKEN
);
3670 /* Clear all top interrupt enable */
3671 oxu_writel(base
, OXU_CHIPIRQEN_CLR
, 0xff);
3673 /* Clear all top interrupt status */
3674 oxu_writel(base
, OXU_CHIPIRQSTATUS
, 0xff);
3676 /* Enable all needed top interrupt except OTG SPH core */
3677 oxu_writel(base
, OXU_CHIPIRQEN_SET
, OXU_USBSPHLPWUI
| OXU_USBOTGLPWUI
);
3680 static int oxu_verify_id(struct platform_device
*pdev
, void *base
)
3683 static const char * const bo
[] = {
3690 /* Read controller signature register to find a match */
3691 id
= oxu_readl(base
, OXU_DEVICEID
);
3692 dev_info(&pdev
->dev
, "device ID %x\n", id
);
3693 if ((id
& OXU_REV_MASK
) != (OXU_REV_2100
<< OXU_REV_SHIFT
))
3696 dev_info(&pdev
->dev
, "found device %x %s (%04x:%04x)\n",
3697 id
>> OXU_REV_SHIFT
,
3698 bo
[(id
& OXU_BO_MASK
) >> OXU_BO_SHIFT
],
3699 (id
& OXU_MAJ_REV_MASK
) >> OXU_MAJ_REV_SHIFT
,
3700 (id
& OXU_MIN_REV_MASK
) >> OXU_MIN_REV_SHIFT
);
3705 static const struct hc_driver oxu_hc_driver
;
3706 static struct usb_hcd
*oxu_create(struct platform_device
*pdev
,
3707 unsigned long memstart
, unsigned long memlen
,
3708 void *base
, int irq
, int otg
)
3710 struct device
*dev
= &pdev
->dev
;
3712 struct usb_hcd
*hcd
;
3713 struct oxu_hcd
*oxu
;
3716 /* Set endian mode and host mode */
3717 oxu_writel(base
+ (otg
? OXU_OTG_CORE_OFFSET
: OXU_SPH_CORE_OFFSET
),
3719 OXU_CM_HOST_ONLY
| OXU_ES_LITTLE
| OXU_VBPS
);
3721 hcd
= usb_create_hcd(&oxu_hc_driver
, dev
,
3722 otg
? "oxu210hp_otg" : "oxu210hp_sph");
3724 return ERR_PTR(-ENOMEM
);
3726 hcd
->rsrc_start
= memstart
;
3727 hcd
->rsrc_len
= memlen
;
3730 hcd
->state
= HC_STATE_HALT
;
3732 oxu
= hcd_to_oxu(hcd
);
3735 ret
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
3737 return ERR_PTR(ret
);
3739 device_wakeup_enable(hcd
->self
.controller
);
3743 static int oxu_init(struct platform_device
*pdev
,
3744 unsigned long memstart
, unsigned long memlen
,
3745 void *base
, int irq
)
3747 struct oxu_info
*info
= platform_get_drvdata(pdev
);
3748 struct usb_hcd
*hcd
;
3751 /* First time configuration at start up */
3752 oxu_configuration(pdev
, base
);
3754 ret
= oxu_verify_id(pdev
, base
);
3756 dev_err(&pdev
->dev
, "no devices found!\n");
3760 /* Create the OTG controller */
3761 hcd
= oxu_create(pdev
, memstart
, memlen
, base
, irq
, 1);
3763 dev_err(&pdev
->dev
, "cannot create OTG controller!\n");
3765 goto error_create_otg
;
3769 /* Create the SPH host controller */
3770 hcd
= oxu_create(pdev
, memstart
, memlen
, base
, irq
, 0);
3772 dev_err(&pdev
->dev
, "cannot create SPH controller!\n");
3774 goto error_create_sph
;
3778 oxu_writel(base
, OXU_CHIPIRQEN_SET
,
3779 oxu_readl(base
, OXU_CHIPIRQEN_SET
) | 3);
3784 usb_remove_hcd(info
->hcd
[0]);
3785 usb_put_hcd(info
->hcd
[0]);
3791 static int oxu_drv_probe(struct platform_device
*pdev
)
3793 struct resource
*res
;
3795 unsigned long memstart
, memlen
;
3797 struct oxu_info
*info
;
3803 * Get the platform resources
3805 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
3808 "no IRQ! Check %s setup!\n", dev_name(&pdev
->dev
));
3812 dev_dbg(&pdev
->dev
, "IRQ resource %d\n", irq
);
3814 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
3815 base
= devm_ioremap_resource(&pdev
->dev
, res
);
3817 ret
= PTR_ERR(base
);
3820 memstart
= res
->start
;
3821 memlen
= resource_size(res
);
3823 ret
= irq_set_irq_type(irq
, IRQF_TRIGGER_FALLING
);
3825 dev_err(&pdev
->dev
, "error setting irq type\n");
3830 /* Allocate a driver data struct to hold useful info for both
3833 info
= devm_kzalloc(&pdev
->dev
, sizeof(struct oxu_info
), GFP_KERNEL
);
3838 platform_set_drvdata(pdev
, info
);
3840 ret
= oxu_init(pdev
, memstart
, memlen
, base
, irq
);
3842 dev_dbg(&pdev
->dev
, "cannot init USB devices\n");
3846 dev_info(&pdev
->dev
, "devices enabled and running\n");
3847 platform_set_drvdata(pdev
, info
);
3852 dev_err(&pdev
->dev
, "init %s fail, %d\n", dev_name(&pdev
->dev
), ret
);
3856 static void oxu_remove(struct platform_device
*pdev
, struct usb_hcd
*hcd
)
3858 usb_remove_hcd(hcd
);
3862 static int oxu_drv_remove(struct platform_device
*pdev
)
3864 struct oxu_info
*info
= platform_get_drvdata(pdev
);
3866 oxu_remove(pdev
, info
->hcd
[0]);
3867 oxu_remove(pdev
, info
->hcd
[1]);
3872 static void oxu_drv_shutdown(struct platform_device
*pdev
)
3874 oxu_drv_remove(pdev
);
3879 static int oxu_drv_suspend(struct device
*dev
)
3881 struct platform_device
*pdev
= to_platform_device(dev
);
3882 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
3887 static int oxu_drv_resume(struct device
*dev
)
3889 struct platform_device
*pdev
= to_platform_device(dev
);
3890 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
3895 #define oxu_drv_suspend NULL
3896 #define oxu_drv_resume NULL
3899 static struct platform_driver oxu_driver
= {
3900 .probe
= oxu_drv_probe
,
3901 .remove
= oxu_drv_remove
,
3902 .shutdown
= oxu_drv_shutdown
,
3903 .suspend
= oxu_drv_suspend
,
3904 .resume
= oxu_drv_resume
,
3906 .name
= "oxu210hp-hcd",
3907 .bus
= &platform_bus_type
3911 module_platform_driver(oxu_driver
);
3913 MODULE_DESCRIPTION("Oxford OXU210HP HCD driver - ver. " DRIVER_VERSION
);
3914 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
3915 MODULE_LICENSE("GPL");