2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2001-2002 by David Brownell
|
2006-08-30 21:50:06 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the
|
|
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
|
|
* option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
* for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
* Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_EHCI_HCD_H
|
|
|
|
#define __LINUX_EHCI_HCD_H
|
|
|
|
|
|
|
|
/* definitions used for the EHCI driver */
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
/*
|
|
|
|
* __hc32 and __hc16 are "Host Controller" types, they may be equivalent to
|
|
|
|
* __leXX (normally) or __beXX (given EHCI_BIG_ENDIAN_DESC), depending on
|
|
|
|
* the host controller implementation.
|
|
|
|
*
|
|
|
|
* To facilitate the strongest possible byte-order checking from "sparse"
|
|
|
|
* and so on, we use __leXX unless that's not practical.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
|
|
|
|
typedef __u32 __bitwise __hc32;
|
|
|
|
typedef __u16 __bitwise __hc16;
|
|
|
|
#else
|
|
|
|
#define __hc32 __le32
|
|
|
|
#define __hc16 __le16
|
|
|
|
#endif
|
|
|
|
|
2009-07-07 09:54:23 +00:00
|
|
|
/* statistics can be kept for tuning/monitoring */
|
2013-11-18 12:23:16 +00:00
|
|
|
#ifdef CONFIG_DYNAMIC_DEBUG
|
2013-01-22 16:59:58 +00:00
|
|
|
#define EHCI_STATS
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ehci_stats {
|
|
|
|
/* irq usage */
|
|
|
|
unsigned long normal;
|
|
|
|
unsigned long error;
|
2012-07-11 15:21:38 +00:00
|
|
|
unsigned long iaa;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long lost_iaa;
|
|
|
|
|
|
|
|
/* termination of urbs from core */
|
|
|
|
unsigned long complete;
|
|
|
|
unsigned long unlink;
|
|
|
|
};
|
|
|
|
|
2013-10-11 15:29:03 +00:00
|
|
|
/*
|
|
|
|
* Scheduling and budgeting information for periodic transfers, for both
|
|
|
|
* high-speed devices and full/low-speed devices lying behind a TT.
|
|
|
|
*/
|
|
|
|
struct ehci_per_sched {
|
|
|
|
struct usb_device *udev; /* access to the TT */
|
|
|
|
struct usb_host_endpoint *ep;
|
2013-10-12 02:16:21 +00:00
|
|
|
struct list_head ps_list; /* node on ehci_tt's ps_list */
|
2013-10-11 15:29:03 +00:00
|
|
|
u16 tt_usecs; /* time on the FS/LS bus */
|
2013-10-11 15:29:13 +00:00
|
|
|
u16 cs_mask; /* C-mask and S-mask bytes */
|
2013-10-11 15:29:03 +00:00
|
|
|
u16 period; /* actual period in frames */
|
|
|
|
u16 phase; /* actual phase, frame part */
|
2013-10-11 15:29:13 +00:00
|
|
|
u8 bw_phase; /* same, for bandwidth
|
|
|
|
reservation */
|
2013-10-11 15:29:03 +00:00
|
|
|
u8 phase_uf; /* uframe part of the phase */
|
|
|
|
u8 usecs, c_usecs; /* times on the HS bus */
|
2013-10-11 15:29:13 +00:00
|
|
|
u8 bw_uperiod; /* period in microframes, for
|
|
|
|
bandwidth reservation */
|
|
|
|
u8 bw_period; /* same, in frames */
|
2013-10-11 15:29:03 +00:00
|
|
|
};
|
2013-10-11 15:28:52 +00:00
|
|
|
#define NO_FRAME 29999 /* frame not assigned yet */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* ehci_hcd->lock guards shared data against other CPUs:
|
2012-07-11 15:21:38 +00:00
|
|
|
* ehci_hcd: async, unlink, periodic (and shadow), ...
|
2005-04-16 22:20:36 +00:00
|
|
|
* usb_host_endpoint: hcpriv
|
|
|
|
* ehci_qh: qh_next, qtd_list
|
|
|
|
* ehci_qtd: qtd_list
|
|
|
|
*
|
|
|
|
* Also, hold this lock when talking to HC registers or
|
|
|
|
* when updating hw_* fields in shared qh/qtd/... structures.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define EHCI_MAX_ROOT_PORTS 15 /* see HCS_N_PORTS */
|
|
|
|
|
2012-07-11 15:21:48 +00:00
|
|
|
/*
|
|
|
|
* ehci_rh_state values of EHCI_RH_RUNNING or above mean that the
|
|
|
|
* controller may be doing DMA. Lower values mean there's no DMA.
|
|
|
|
*/
|
2011-08-18 20:31:30 +00:00
|
|
|
enum ehci_rh_state {
|
|
|
|
EHCI_RH_HALTED,
|
|
|
|
EHCI_RH_SUSPENDED,
|
2012-07-11 15:21:48 +00:00
|
|
|
EHCI_RH_RUNNING,
|
|
|
|
EHCI_RH_STOPPING
|
2011-08-18 20:31:30 +00:00
|
|
|
};
|
|
|
|
|
2012-07-11 15:21:54 +00:00
|
|
|
/*
|
|
|
|
* Timer events, ordered by increasing delay length.
|
|
|
|
* Always update event_delays_ns[] and event_handlers[] (defined in
|
|
|
|
* ehci-timer.c) in parallel with this list.
|
|
|
|
*/
|
|
|
|
enum ehci_hrtimer_event {
|
2012-07-11 15:22:21 +00:00
|
|
|
EHCI_HRTIMER_POLL_ASS, /* Poll for async schedule off */
|
2012-07-11 15:22:05 +00:00
|
|
|
EHCI_HRTIMER_POLL_PSS, /* Poll for periodic schedule off */
|
2012-07-11 15:22:31 +00:00
|
|
|
EHCI_HRTIMER_POLL_DEAD, /* Wait for dead controller to stop */
|
2012-07-11 15:22:26 +00:00
|
|
|
EHCI_HRTIMER_UNLINK_INTR, /* Wait for interrupt QH unlink */
|
2012-07-11 15:22:35 +00:00
|
|
|
EHCI_HRTIMER_FREE_ITDS, /* Wait for unused iTDs and siTDs */
|
USB: EHCI: add a delay when unlinking an active QH
Michael Reutman reports that an AMD/ATI EHCI host controller on one of
his computers does not stop transferring data when an active bulk QH
is unlinked from the async schedule. Apparently that host controller
fails to implement the IAA mechanism correctly when an active QH is
unlinked. This leads to data corruption, because the controller
continues to update the QH in memory when the driver doesn't expect
it. As a result, the next URB submitted for that QH can hang, because
the link pointers for the TD queue have been messed up. This
misbehavior is observed quite regularly.
To be fair, the EHCI spec (section 4.8.2) says that active QHs should
not be unlinked. It goes on to recommend a procedure that involves
waiting for the QH to go inactive before unlinking it. In the real
world this is impractical, not least because the QH may _never_ go
inactive. (What were they thinking?) Sometimes we have no choice but
to unlink an active QH.
In an attempt to avoid the problems that can ensue, this patch changes
how the driver decides when the unlink is complete. In addition to
waiting through two IAA cycles, in cases where the QH was not known to
be inactive beforehand we now wait until a 2-ms period has elapsed
with the host controller making no change to the QH data structure
(the hw_current and hw_token fields in particular). The intuition
here is that after such a long period, the endpoint must be NAKing and
hopefully the QH has been dropped from the host controller's internal
cache. There's no way to know if this reasoning is really valid --
the spec is no help in this regard -- but at least this approach fixes
Michael's problem.
The test for whether the QH is already known to be inactive involves
the reason for unlinking the QH originally. If it was unlinked
because it had halted, or it stopped in response to a short read, or
it overlaid a dummy TD (a silicon bug), then it certainly is inactive.
If it was unlinked because the TD queue was empty and no TDs have been
added to the queue in the meantime, then it must be inactive. Or if
the hardware status indicates that the QH is currently halted (even if
that wasn't the reason for unlinking it), then it is inactive.
Otherwise, if none of those checks apply, we go through the 2-ms
delay.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Reported-by: Michael Reutman <mreutman@epiqsolutions.com>
Tested-by: Michael Reutman <mreutman@epiqsolutions.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-01-25 20:45:25 +00:00
|
|
|
EHCI_HRTIMER_ACTIVE_UNLINK, /* Wait while unlinking an active QH */
|
2013-07-03 14:53:10 +00:00
|
|
|
EHCI_HRTIMER_START_UNLINK_INTR, /* Unlink empty interrupt QHs */
|
2012-07-11 15:22:53 +00:00
|
|
|
EHCI_HRTIMER_ASYNC_UNLINKS, /* Unlink empty async QHs */
|
2012-07-11 15:22:44 +00:00
|
|
|
EHCI_HRTIMER_IAA_WATCHDOG, /* Handle lost IAA interrupts */
|
2012-07-11 15:22:05 +00:00
|
|
|
EHCI_HRTIMER_DISABLE_PERIODIC, /* Wait to disable periodic sched */
|
2012-07-11 15:22:21 +00:00
|
|
|
EHCI_HRTIMER_DISABLE_ASYNC, /* Wait to disable async sched */
|
2012-07-11 15:23:04 +00:00
|
|
|
EHCI_HRTIMER_IO_WATCHDOG, /* Check for missing IRQs */
|
2012-07-11 15:21:54 +00:00
|
|
|
EHCI_HRTIMER_NUM_EVENTS /* Must come last */
|
|
|
|
};
|
|
|
|
#define EHCI_HRTIMER_NO_EVENT 99
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ehci_hcd { /* one per controller */
|
2012-07-11 15:21:54 +00:00
|
|
|
/* timing support */
|
|
|
|
enum ehci_hrtimer_event next_hrtimer_event;
|
|
|
|
unsigned enabled_hrtimer_events;
|
|
|
|
ktime_t hr_timeouts[EHCI_HRTIMER_NUM_EVENTS];
|
|
|
|
struct hrtimer hrtimer;
|
|
|
|
|
2012-07-11 15:22:05 +00:00
|
|
|
int PSS_poll_count;
|
2012-07-11 15:22:21 +00:00
|
|
|
int ASS_poll_count;
|
2012-07-11 15:22:31 +00:00
|
|
|
int died_poll_count;
|
2012-07-11 15:22:05 +00:00
|
|
|
|
2005-04-09 16:00:29 +00:00
|
|
|
/* glue to PCI and HCD framework */
|
|
|
|
struct ehci_caps __iomem *caps;
|
|
|
|
struct ehci_regs __iomem *regs;
|
|
|
|
struct ehci_dbg_port __iomem *debug;
|
|
|
|
|
|
|
|
__u32 hcs_params; /* cached register copy */
|
2005-04-16 22:20:36 +00:00
|
|
|
spinlock_t lock;
|
2011-08-18 20:31:30 +00:00
|
|
|
enum ehci_rh_state rh_state;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-11 15:22:26 +00:00
|
|
|
/* general schedule support */
|
2012-07-11 15:22:57 +00:00
|
|
|
bool scanning:1;
|
|
|
|
bool need_rescan:1;
|
2012-07-11 15:22:26 +00:00
|
|
|
bool intr_unlinking:1;
|
2013-03-22 17:31:58 +00:00
|
|
|
bool iaa_in_progress:1;
|
2012-07-11 15:22:49 +00:00
|
|
|
bool async_unlinking:1;
|
2012-07-11 15:23:16 +00:00
|
|
|
bool shutdown:1;
|
2012-07-11 15:23:00 +00:00
|
|
|
struct ehci_qh *qh_scan_next;
|
2012-07-11 15:22:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* async schedule support */
|
|
|
|
struct ehci_qh *async;
|
2010-11-08 09:58:35 +00:00
|
|
|
struct ehci_qh *dummy; /* For AMD quirk use */
|
2013-03-22 17:31:45 +00:00
|
|
|
struct list_head async_unlink;
|
2013-03-22 17:31:58 +00:00
|
|
|
struct list_head async_idle;
|
2012-07-11 15:22:53 +00:00
|
|
|
unsigned async_unlink_cycle;
|
2012-07-11 15:22:21 +00:00
|
|
|
unsigned async_count; /* async activity count */
|
USB: EHCI: add a delay when unlinking an active QH
Michael Reutman reports that an AMD/ATI EHCI host controller on one of
his computers does not stop transferring data when an active bulk QH
is unlinked from the async schedule. Apparently that host controller
fails to implement the IAA mechanism correctly when an active QH is
unlinked. This leads to data corruption, because the controller
continues to update the QH in memory when the driver doesn't expect
it. As a result, the next URB submitted for that QH can hang, because
the link pointers for the TD queue have been messed up. This
misbehavior is observed quite regularly.
To be fair, the EHCI spec (section 4.8.2) says that active QHs should
not be unlinked. It goes on to recommend a procedure that involves
waiting for the QH to go inactive before unlinking it. In the real
world this is impractical, not least because the QH may _never_ go
inactive. (What were they thinking?) Sometimes we have no choice but
to unlink an active QH.
In an attempt to avoid the problems that can ensue, this patch changes
how the driver decides when the unlink is complete. In addition to
waiting through two IAA cycles, in cases where the QH was not known to
be inactive beforehand we now wait until a 2-ms period has elapsed
with the host controller making no change to the QH data structure
(the hw_current and hw_token fields in particular). The intuition
here is that after such a long period, the endpoint must be NAKing and
hopefully the QH has been dropped from the host controller's internal
cache. There's no way to know if this reasoning is really valid --
the spec is no help in this regard -- but at least this approach fixes
Michael's problem.
The test for whether the QH is already known to be inactive involves
the reason for unlinking the QH originally. If it was unlinked
because it had halted, or it stopped in response to a short read, or
it overlaid a dummy TD (a silicon bug), then it certainly is inactive.
If it was unlinked because the TD queue was empty and no TDs have been
added to the queue in the meantime, then it must be inactive. Or if
the hardware status indicates that the QH is currently halted (even if
that wasn't the reason for unlinking it), then it is inactive.
Otherwise, if none of those checks apply, we go through the 2-ms
delay.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Reported-by: Michael Reutman <mreutman@epiqsolutions.com>
Tested-by: Michael Reutman <mreutman@epiqsolutions.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-01-25 20:45:25 +00:00
|
|
|
__hc32 old_current; /* Test for QH becoming */
|
|
|
|
__hc32 old_token; /* inactive during unlink */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* periodic schedule support */
|
|
|
|
#define DEFAULT_I_TDPS 1024 /* some HCs can do less */
|
|
|
|
unsigned periodic_size;
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 *periodic; /* hw periodic table */
|
2005-04-16 22:20:36 +00:00
|
|
|
dma_addr_t periodic_dma;
|
2012-07-11 15:23:00 +00:00
|
|
|
struct list_head intr_qh_list;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned i_thresh; /* uframes HC might cache */
|
|
|
|
|
|
|
|
union ehci_shadow *pshadow; /* mirror hw periodic table */
|
2013-07-03 14:53:10 +00:00
|
|
|
struct list_head intr_unlink_wait;
|
2013-03-22 17:31:45 +00:00
|
|
|
struct list_head intr_unlink;
|
2013-07-03 14:53:10 +00:00
|
|
|
unsigned intr_unlink_wait_cycle;
|
2012-07-11 15:22:26 +00:00
|
|
|
unsigned intr_unlink_cycle;
|
2012-07-11 15:23:07 +00:00
|
|
|
unsigned now_frame; /* frame from HC hardware */
|
2012-09-28 20:01:23 +00:00
|
|
|
unsigned last_iso_frame; /* last frame scanned for iso */
|
2012-07-11 15:23:00 +00:00
|
|
|
unsigned intr_count; /* intr activity count */
|
|
|
|
unsigned isoc_count; /* isoc activity count */
|
2012-07-11 15:22:05 +00:00
|
|
|
unsigned periodic_count; /* periodic activity count */
|
USB: EHCI: Allow users to override 80% max periodic bandwidth
There are cases, when 80% max isochronous bandwidth is too limiting.
For example I have two USB video capture cards which stream uncompressed
video, and to stream full NTSC + PAL videos we'd need
NTSC 640x480 YUV422 @30fps ~17.6 MB/s
PAL 720x576 YUV422 @25fps ~19.7 MB/s
isoc bandwidth.
Now, due to limited alt settings in capture devices NTSC one ends up
streaming with max_pkt_size=2688 and PAL with max_pkt_size=2892, both
with interval=1. In terms of microframe time allocation this gives
NTSC ~53us
PAL ~57us
and together
~110us > 100us == 80% of 125us uframe time.
So those two devices can't work together simultaneously because the'd
over allocate isochronous bandwidth.
80% seemed a bit arbitrary to me, and I've tried to raise it to 90% and
both devices started to work together, so I though sometimes it would be
a good idea for users to override hardcoded default of max 80% isoc
bandwidth.
After all, isn't it a user who should decide how to load the bus? If I
can live with 10% or even 5% bulk bandwidth that should be ok. I'm a USB
newcomer, but that 80% set in stone by USB 2.0 specification seems to be
chosen pretty arbitrary to me, just to serve as a reasonable default.
NOTE 1
~~~~~~
for two streams with max_pkt_size=3072 (worst case) both time
allocation would be 60us+60us=120us which is 96% periodic bandwidth
leaving 4% for bulk and control. Alan Stern suggested that bulk then
would be problematic (less than 300*8 bittimes left per microframe), but
I think that is still enough for control traffic.
NOTE 2
~~~~~~
Sarah Sharp expressed concern that maxing out periodic bandwidth
could lead to vendor-specific hardware bugs on host controllers, because
> It's entirely possible that you'll run into
> vendor-specific bugs if you try to pack the schedule with isochronous
> transfers. I don't think any hardware designer would seriously test or
> validate their hardware with a schedule that is basically a violation of
> the USB bus spec (more than 80% for periodic transfers).
So far I've only tested this patch on my HP Mini 5103 with N10 chipset
kirr@mini:~$ lspci
00:00.0 Host bridge: Intel Corporation N10 Family DMI Bridge
00:02.0 VGA compatible controller: Intel Corporation N10 Family Integrated Graphics Controller
00:02.1 Display controller: Intel Corporation N10 Family Integrated Graphics Controller
00:1b.0 Audio device: Intel Corporation N10/ICH 7 Family High Definition Audio Controller (rev 02)
00:1c.0 PCI bridge: Intel Corporation N10/ICH 7 Family PCI Express Port 1 (rev 02)
00:1c.3 PCI bridge: Intel Corporation N10/ICH 7 Family PCI Express Port 4 (rev 02)
00:1d.0 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #1 (rev 02)
00:1d.1 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #2 (rev 02)
00:1d.2 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #3 (rev 02)
00:1d.3 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #4 (rev 02)
00:1d.7 USB Controller: Intel Corporation N10/ICH 7 Family USB2 EHCI Controller (rev 02)
00:1e.0 PCI bridge: Intel Corporation 82801 Mobile PCI Bridge (rev e2)
00:1f.0 ISA bridge: Intel Corporation NM10 Family LPC Controller (rev 02)
00:1f.2 SATA controller: Intel Corporation N10/ICH7 Family SATA AHCI Controller (rev 02)
01:00.0 Network controller: Broadcom Corporation BCM4313 802.11b/g/n Wireless LAN Controller (rev 01)
02:00.0 Ethernet controller: Marvell Technology Group Ltd. 88E8059 PCI-E Gigabit Ethernet Controller (rev 11)
and the system works stable with 110us/uframe (~88%) isoc bandwith allocated for
above-mentioned isochronous transfers.
NOTE 3
~~~~~~
This feature is off by default. I mean max periodic bandwidth is set to
100us/uframe by default exactly as it was before the patch. So only those of us
who need the extreme settings are taking the risk - normal users who do not
alter uframe_periodic_max sysfs attribute should not see any change at all.
NOTE 4
~~~~~~
I've tried to update documentation in Documentation/ABI/ thoroughly, but
only "TBD" was put into Documentation/usb/ehci.txt -- the text there seems
to be outdated and much needing refreshing, before it could be amended.
Cc: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Kirill Smelkov <kirr@mns.spb.ru>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-07-03 16:36:57 +00:00
|
|
|
unsigned uframe_periodic_max; /* max periodic time per uframe */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-11 15:23:07 +00:00
|
|
|
/* list of itds & sitds completed while now_frame was still active */
|
2009-02-09 00:07:58 +00:00
|
|
|
struct list_head cached_itd_list;
|
2012-07-11 15:22:35 +00:00
|
|
|
struct ehci_itd *last_itd_to_free;
|
2010-04-08 20:56:37 +00:00
|
|
|
struct list_head cached_sitd_list;
|
2012-07-11 15:22:35 +00:00
|
|
|
struct ehci_sitd *last_sitd_to_free;
|
2009-02-09 00:07:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* per root hub port */
|
2016-01-26 01:44:46 +00:00
|
|
|
unsigned long reset_done[EHCI_MAX_ROOT_PORTS];
|
2007-05-04 15:52:40 +00:00
|
|
|
|
2007-01-16 16:59:45 +00:00
|
|
|
/* bit vectors (one bit per port) */
|
|
|
|
unsigned long bus_suspended; /* which ports were
|
|
|
|
already suspended at the start of a bus suspend */
|
|
|
|
unsigned long companion_ports; /* which ports are
|
|
|
|
dedicated to the companion controller */
|
2007-05-04 15:52:40 +00:00
|
|
|
unsigned long owned_ports; /* which ports are
|
|
|
|
owned by the companion during a bus suspend */
|
2008-05-20 20:58:58 +00:00
|
|
|
unsigned long port_c_suspend; /* which ports have
|
|
|
|
the change-suspend feature turned on */
|
2008-10-06 15:25:53 +00:00
|
|
|
unsigned long suspended_ports; /* which ports are
|
|
|
|
suspended */
|
2012-04-03 19:24:30 +00:00
|
|
|
unsigned long resuming_ports; /* which ports have
|
|
|
|
started to resume */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* per-HC memory pools (could be per-bus, but ...) */
|
|
|
|
struct dma_pool *qh_pool; /* qh per active urb */
|
|
|
|
struct dma_pool *qtd_pool; /* one or more per qh */
|
|
|
|
struct dma_pool *itd_pool; /* itd per iso urb */
|
|
|
|
struct dma_pool *sitd_pool; /* sitd per split iso urb */
|
|
|
|
|
2009-05-22 21:02:33 +00:00
|
|
|
unsigned random_frame;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long next_statechange;
|
2009-11-27 14:17:59 +00:00
|
|
|
ktime_t last_periodic_enable;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 command;
|
|
|
|
|
2006-01-20 21:57:52 +00:00
|
|
|
/* SILICON QUIRKS */
|
2006-01-20 21:55:14 +00:00
|
|
|
unsigned no_selective_suspend:1;
|
2006-01-20 21:57:52 +00:00
|
|
|
unsigned has_fsl_port_bug:1; /* FreeScale */
|
2015-08-06 09:21:27 +00:00
|
|
|
unsigned has_fsl_hs_errata:1; /* Freescale HS quirk */
|
2006-12-14 19:54:08 +00:00
|
|
|
unsigned big_endian_mmio:1;
|
2007-05-01 16:29:37 +00:00
|
|
|
unsigned big_endian_desc:1;
|
2011-05-03 18:11:57 +00:00
|
|
|
unsigned big_endian_capbase:1;
|
USB: powerpc: Workaround for the PPC440EPX USBH_23 errata [take 3]
A published errata for ppc440epx states, that when running Linux with
both EHCI and OHCI modules loaded, the EHCI module experiences a fatal
error when a high-speed device is connected to the USB2.0, and
functions normally if OHCI module is not loaded.
There used to be recommendation to use only hi-speed or full-speed
devices with specific conditions, when respective module was unloaded.
Later, it was observed that ohci suspend is enough to keep things
going, and it was turned into workaround, as explained below.
Quote from original descriprion:
The 440EPx USB 2.0 Host controller is an EHCI compliant controller. In
USB 2.0 Host controllers, each EHCI controller has one or more companion
controllers, which may be OHCI or UHCI. An USB 2.0 Host controller will
contain one or more ports. For each port, only one of the controllers
is connected at any one time. In the 440EPx, there is only one OHCI
companion controller, and only one USB 2.0 Host port.
All ports on an USB 2.0 controller default to the companion
controller. If you load only an ohci driver, it will have control of
the ports and any deviceplugged in will operate, although high speed
devices will be forced to operate at full speed. When an ehci driver
is loaded, it explicitly takes control of the ports. If there is a
device connected, and / or every time there is a new device connected,
the ehci driver determines if the device is high speed or not. If it
is high speed, the driver retains control of the port. If it is not,
the driver explicitly gives the companion controller control of the
port.
The is a software workaround that uses
Initial version of the software workaround was posted to
linux-usb-devel:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg54019.html
and later available from amcc.com:
http://www.amcc.com/Embedded/Downloads/download.html?cat=1&family=15&ins=2
The patch below is generally based on the latter, but reworked to
powerpc/of_device USB drivers, and uses a few devicetree inquiries to
get rid of (some) hardcoded defines.
Signed-off-by: Vitaly Bordug <vitb@kernel.crashing.org>
Signed-off-by: Stefan Roese <sr@denx.de>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-11-09 18:43:30 +00:00
|
|
|
unsigned has_amcc_usb23:1;
|
2009-07-13 09:30:41 +00:00
|
|
|
unsigned need_io_watchdog:1;
|
2011-03-01 06:57:05 +00:00
|
|
|
unsigned amd_pll_fix:1;
|
2010-11-08 09:58:35 +00:00
|
|
|
unsigned use_dummy_qh:1; /* AMD Frame List table quirk*/
|
2011-04-13 08:54:23 +00:00
|
|
|
unsigned has_synopsys_hc_bug:1; /* Synopsys HC */
|
2011-10-12 14:39:14 +00:00
|
|
|
unsigned frame_index_bug:1; /* MosChip (AKA NetMos) */
|
2013-04-03 10:18:51 +00:00
|
|
|
unsigned need_oc_pp_cycle:1; /* MPC834X port power */
|
2014-01-10 05:51:26 +00:00
|
|
|
unsigned imx28_write_fix:1; /* For Freescale i.MX28 */
|
USB: powerpc: Workaround for the PPC440EPX USBH_23 errata [take 3]
A published errata for ppc440epx states, that when running Linux with
both EHCI and OHCI modules loaded, the EHCI module experiences a fatal
error when a high-speed device is connected to the USB2.0, and
functions normally if OHCI module is not loaded.
There used to be recommendation to use only hi-speed or full-speed
devices with specific conditions, when respective module was unloaded.
Later, it was observed that ohci suspend is enough to keep things
going, and it was turned into workaround, as explained below.
Quote from original descriprion:
The 440EPx USB 2.0 Host controller is an EHCI compliant controller. In
USB 2.0 Host controllers, each EHCI controller has one or more companion
controllers, which may be OHCI or UHCI. An USB 2.0 Host controller will
contain one or more ports. For each port, only one of the controllers
is connected at any one time. In the 440EPx, there is only one OHCI
companion controller, and only one USB 2.0 Host port.
All ports on an USB 2.0 controller default to the companion
controller. If you load only an ohci driver, it will have control of
the ports and any deviceplugged in will operate, although high speed
devices will be forced to operate at full speed. When an ehci driver
is loaded, it explicitly takes control of the ports. If there is a
device connected, and / or every time there is a new device connected,
the ehci driver determines if the device is high speed or not. If it
is high speed, the driver retains control of the port. If it is not,
the driver explicitly gives the companion controller control of the
port.
The is a software workaround that uses
Initial version of the software workaround was posted to
linux-usb-devel:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg54019.html
and later available from amcc.com:
http://www.amcc.com/Embedded/Downloads/download.html?cat=1&family=15&ins=2
The patch below is generally based on the latter, but reworked to
powerpc/of_device USB drivers, and uses a few devicetree inquiries to
get rid of (some) hardcoded defines.
Signed-off-by: Vitaly Bordug <vitb@kernel.crashing.org>
Signed-off-by: Stefan Roese <sr@denx.de>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-11-09 18:43:30 +00:00
|
|
|
|
|
|
|
/* required for usb32 quirk */
|
|
|
|
#define OHCI_CTRL_HCFS (3 << 6)
|
|
|
|
#define OHCI_USB_OPER (2 << 6)
|
|
|
|
#define OHCI_USB_SUSPEND (3 << 6)
|
|
|
|
|
|
|
|
#define OHCI_HCCTRL_OFFSET 0x4
|
|
|
|
#define OHCI_HCCTRL_LEN 0x4
|
|
|
|
__hc32 *ohci_hcctrl_reg;
|
2009-07-13 04:41:20 +00:00
|
|
|
unsigned has_hostpc:1;
|
2013-08-12 13:06:49 +00:00
|
|
|
unsigned has_tdi_phy_lpm:1;
|
2010-06-04 07:47:56 +00:00
|
|
|
unsigned has_ppcd:1; /* support per-port change bits */
|
2006-01-20 21:55:14 +00:00
|
|
|
u8 sbrn; /* packed release number */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* irq statistics */
|
|
|
|
#ifdef EHCI_STATS
|
|
|
|
struct ehci_stats stats;
|
2016-01-26 01:44:47 +00:00
|
|
|
# define COUNT(x) ((x)++)
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
2016-01-26 01:44:47 +00:00
|
|
|
# define COUNT(x)
|
2007-09-11 21:07:31 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* debug files */
|
2013-11-18 12:23:16 +00:00
|
|
|
#ifdef CONFIG_DYNAMIC_DEBUG
|
2007-09-11 21:07:31 +00:00
|
|
|
struct dentry *debug_dir;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2013-01-22 17:00:26 +00:00
|
|
|
|
2013-10-11 15:29:13 +00:00
|
|
|
/* bandwidth usage */
|
|
|
|
#define EHCI_BANDWIDTH_SIZE 64
|
|
|
|
#define EHCI_BANDWIDTH_FRAMES (EHCI_BANDWIDTH_SIZE >> 3)
|
|
|
|
u8 bandwidth[EHCI_BANDWIDTH_SIZE];
|
|
|
|
/* us allocated per uframe */
|
2013-10-12 02:16:21 +00:00
|
|
|
u8 tt_budget[EHCI_BANDWIDTH_SIZE];
|
|
|
|
/* us budgeted per uframe */
|
|
|
|
struct list_head tt_list;
|
2013-10-11 15:29:13 +00:00
|
|
|
|
2013-01-22 17:00:26 +00:00
|
|
|
/* platform-specific data -- must come last */
|
|
|
|
unsigned long priv[0] __aligned(sizeof(s64));
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2006-08-30 21:50:06 +00:00
|
|
|
/* convert between an HCD pointer and the corresponding EHCI_HCD */
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline struct ehci_hcd *hcd_to_ehci(struct usb_hcd *hcd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return (struct ehci_hcd *) (hcd->hcd_priv);
|
|
|
|
}
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline struct usb_hcd *ehci_to_hcd(struct ehci_hcd *ehci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-01-26 01:44:45 +00:00
|
|
|
return container_of((void *) ehci, struct usb_hcd, hcd_priv);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2008-07-25 00:27:57 +00:00
|
|
|
#include <linux/usb/ehci_def.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
#define QTD_NEXT(ehci, dma) cpu_to_hc32(ehci, (u32)dma)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* EHCI Specification 0.95 Section 3.5
|
2006-08-30 21:50:06 +00:00
|
|
|
* QTD: describe data transfer components (buffer, direction, ...)
|
2005-04-16 22:20:36 +00:00
|
|
|
* See Fig 3-6 "Queue Element Transfer Descriptor Block Diagram".
|
|
|
|
*
|
|
|
|
* These are associated only with "QH" (Queue Head) structures,
|
|
|
|
* used with control, bulk, and interrupt transfers.
|
|
|
|
*/
|
|
|
|
struct ehci_qtd {
|
|
|
|
/* first part defined by EHCI spec */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_next; /* see EHCI 3.5.1 */
|
|
|
|
__hc32 hw_alt_next; /* see EHCI 3.5.2 */
|
|
|
|
__hc32 hw_token; /* see EHCI 3.5.3 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define QTD_TOGGLE (1 << 31) /* data toggle */
|
|
|
|
#define QTD_LENGTH(tok) (((tok)>>16) & 0x7fff)
|
|
|
|
#define QTD_IOC (1 << 15) /* interrupt on complete */
|
|
|
|
#define QTD_CERR(tok) (((tok)>>10) & 0x3)
|
|
|
|
#define QTD_PID(tok) (((tok)>>8) & 0x3)
|
|
|
|
#define QTD_STS_ACTIVE (1 << 7) /* HC may execute this */
|
|
|
|
#define QTD_STS_HALT (1 << 6) /* halted on error */
|
|
|
|
#define QTD_STS_DBE (1 << 5) /* data buffer error (in HC) */
|
|
|
|
#define QTD_STS_BABBLE (1 << 4) /* device was babbling (qtd halted) */
|
|
|
|
#define QTD_STS_XACT (1 << 3) /* device gave illegal response */
|
|
|
|
#define QTD_STS_MMF (1 << 2) /* incomplete split transaction */
|
|
|
|
#define QTD_STS_STS (1 << 1) /* split transaction state */
|
|
|
|
#define QTD_STS_PING (1 << 0) /* issue PING? */
|
2007-05-01 16:29:37 +00:00
|
|
|
|
|
|
|
#define ACTIVE_BIT(ehci) cpu_to_hc32(ehci, QTD_STS_ACTIVE)
|
|
|
|
#define HALT_BIT(ehci) cpu_to_hc32(ehci, QTD_STS_HALT)
|
|
|
|
#define STATUS_BIT(ehci) cpu_to_hc32(ehci, QTD_STS_STS)
|
|
|
|
|
2016-01-26 01:44:46 +00:00
|
|
|
__hc32 hw_buf[5]; /* see EHCI 3.5.4 */
|
|
|
|
__hc32 hw_buf_hi[5]; /* Appendix B */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* the rest is HCD-private */
|
|
|
|
dma_addr_t qtd_dma; /* qtd address */
|
|
|
|
struct list_head qtd_list; /* sw qtd list */
|
|
|
|
struct urb *urb; /* qtd's urb */
|
|
|
|
size_t length; /* length of buffer */
|
|
|
|
} __attribute__ ((aligned (32)));
|
|
|
|
|
|
|
|
/* mask NakCnt+T in qh->hw_alt_next */
|
2016-01-26 01:44:45 +00:00
|
|
|
#define QTD_MASK(ehci) cpu_to_hc32(ehci, ~0x1f)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-01-26 01:44:45 +00:00
|
|
|
#define IS_SHORT_READ(token) (QTD_LENGTH(token) != 0 && QTD_PID(token) == 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* type tag from {qh,itd,sitd,fstn}->hw_next */
|
2007-05-01 16:29:37 +00:00
|
|
|
#define Q_NEXT_TYPE(ehci,dma) ((dma) & cpu_to_hc32(ehci, 3 << 1))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
/*
|
|
|
|
* Now the following defines are not converted using the
|
2009-02-11 22:11:36 +00:00
|
|
|
* cpu_to_le32() macro anymore, since we have to support
|
2007-05-01 16:29:37 +00:00
|
|
|
* "dynamic" switching between be and le support, so that the driver
|
|
|
|
* can be used on one system with SoC EHCI controller using big-endian
|
|
|
|
* descriptors as well as a normal little-endian PCI EHCI controller.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
/* values for that type tag */
|
2007-05-01 16:29:37 +00:00
|
|
|
#define Q_TYPE_ITD (0 << 1)
|
|
|
|
#define Q_TYPE_QH (1 << 1)
|
|
|
|
#define Q_TYPE_SITD (2 << 1)
|
|
|
|
#define Q_TYPE_FSTN (3 << 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* next async queue entry, or pointer to interrupt/periodic QH */
|
2007-05-01 16:29:37 +00:00
|
|
|
#define QH_NEXT(ehci,dma) (cpu_to_hc32(ehci, (((u32)dma)&~0x01f)|Q_TYPE_QH))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* for periodic/async schedules and qtd lists, mark end of list */
|
2007-05-01 16:29:37 +00:00
|
|
|
#define EHCI_LIST_END(ehci) cpu_to_hc32(ehci, 1) /* "null pointer" to hw */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Entries in periodic shadow table are pointers to one of four kinds
|
|
|
|
* of data structure. That's dictated by the hardware; a type tag is
|
|
|
|
* encoded in the low bits of the hardware's periodic schedule. Use
|
|
|
|
* Q_NEXT_TYPE to get the tag.
|
|
|
|
*
|
|
|
|
* For entries in the async schedule, the type tag always says "qh".
|
|
|
|
*/
|
|
|
|
union ehci_shadow {
|
2006-08-30 21:50:06 +00:00
|
|
|
struct ehci_qh *qh; /* Q_TYPE_QH */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ehci_itd *itd; /* Q_TYPE_ITD */
|
|
|
|
struct ehci_sitd *sitd; /* Q_TYPE_SITD */
|
|
|
|
struct ehci_fstn *fstn; /* Q_TYPE_FSTN */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 *hw_next; /* (all types) */
|
2005-04-16 22:20:36 +00:00
|
|
|
void *ptr;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EHCI Specification 0.95 Section 3.6
|
|
|
|
* QH: describes control/bulk/interrupt endpoints
|
|
|
|
* See Fig 3-7 "Queue Head Structure Layout".
|
|
|
|
*
|
|
|
|
* These appear in both the async and (for interrupt) periodic schedules.
|
|
|
|
*/
|
|
|
|
|
2009-07-13 23:23:29 +00:00
|
|
|
/* first part defined by EHCI spec */
|
|
|
|
struct ehci_qh_hw {
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_next; /* see EHCI 3.6.1 */
|
|
|
|
__hc32 hw_info1; /* see EHCI 3.6.2 */
|
2012-07-11 15:21:32 +00:00
|
|
|
#define QH_CONTROL_EP (1 << 27) /* FS/LS control endpoint */
|
|
|
|
#define QH_HEAD (1 << 15) /* Head of async reclamation list */
|
|
|
|
#define QH_TOGGLE_CTL (1 << 14) /* Data toggle control */
|
|
|
|
#define QH_HIGH_SPEED (2 << 12) /* Endpoint speed */
|
|
|
|
#define QH_LOW_SPEED (1 << 12)
|
|
|
|
#define QH_FULL_SPEED (0 << 12)
|
|
|
|
#define QH_INACTIVATE (1 << 7) /* Inactivate on next transaction */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_info2; /* see EHCI 3.6.2 */
|
2005-08-05 01:06:41 +00:00
|
|
|
#define QH_SMASK 0x000000ff
|
|
|
|
#define QH_CMASK 0x0000ff00
|
|
|
|
#define QH_HUBADDR 0x007f0000
|
|
|
|
#define QH_HUBPORT 0x3f800000
|
|
|
|
#define QH_MULT 0xc0000000
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_current; /* qtd list - see EHCI 3.6.4 */
|
2006-08-30 21:50:06 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* qtd overlay (hardware parts of a struct ehci_qtd) */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_qtd_next;
|
|
|
|
__hc32 hw_alt_next;
|
|
|
|
__hc32 hw_token;
|
2016-01-26 01:44:46 +00:00
|
|
|
__hc32 hw_buf[5];
|
|
|
|
__hc32 hw_buf_hi[5];
|
2009-07-13 23:23:29 +00:00
|
|
|
} __attribute__ ((aligned(32)));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-13 23:23:29 +00:00
|
|
|
struct ehci_qh {
|
2012-07-11 15:22:39 +00:00
|
|
|
struct ehci_qh_hw *hw; /* Must come first */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* the rest is HCD-private */
|
|
|
|
dma_addr_t qh_dma; /* address of qh */
|
|
|
|
union ehci_shadow qh_next; /* ptr to qh; or periodic */
|
|
|
|
struct list_head qtd_list; /* sw qtd list */
|
2012-07-11 15:23:00 +00:00
|
|
|
struct list_head intr_node; /* list of intr QHs */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ehci_qtd *dummy;
|
2013-03-22 17:31:45 +00:00
|
|
|
struct list_head unlink_node;
|
2013-10-11 15:29:03 +00:00
|
|
|
struct ehci_per_sched ps; /* scheduling info */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-11 15:22:26 +00:00
|
|
|
unsigned unlink_cycle;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
u8 qh_state;
|
|
|
|
#define QH_STATE_LINKED 1 /* HC sees this */
|
|
|
|
#define QH_STATE_UNLINK 2 /* HC may still see this */
|
|
|
|
#define QH_STATE_IDLE 3 /* HC doesn't see this */
|
2012-07-11 15:21:38 +00:00
|
|
|
#define QH_STATE_UNLINK_WAIT 4 /* LINKED and on unlink q */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define QH_STATE_COMPLETING 5 /* don't touch token.HALT */
|
|
|
|
|
2009-02-10 15:16:58 +00:00
|
|
|
u8 xacterrs; /* XactErr retry counter */
|
|
|
|
#define QH_XACTERR_MAX 32 /* XactErr retry limit */
|
|
|
|
|
2016-01-25 20:42:04 +00:00
|
|
|
u8 unlink_reason;
|
|
|
|
#define QH_UNLINK_HALTED 0x01 /* Halt flag is set */
|
|
|
|
#define QH_UNLINK_SHORT_READ 0x02 /* Recover from a short read */
|
|
|
|
#define QH_UNLINK_DUMMY_OVERLAY 0x04 /* QH overlayed the dummy TD */
|
|
|
|
#define QH_UNLINK_SHUTDOWN 0x08 /* The HC isn't running */
|
|
|
|
#define QH_UNLINK_QUEUE_EMPTY 0x10 /* Reached end of the queue */
|
|
|
|
#define QH_UNLINK_REQUESTED 0x20 /* Disable, reset, or dequeue */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
u8 gap_uf; /* uframes split/csplit gap */
|
2009-06-29 14:47:30 +00:00
|
|
|
|
2011-07-19 18:01:23 +00:00
|
|
|
unsigned is_out:1; /* bulk or intr OUT */
|
2009-06-29 14:47:30 +00:00
|
|
|
unsigned clearing_tt:1; /* Clear-TT-Buf in progress */
|
2013-03-22 17:31:11 +00:00
|
|
|
unsigned dequeue_during_giveback:1;
|
2015-11-20 18:53:58 +00:00
|
|
|
unsigned should_be_inactive:1;
|
2009-07-13 23:23:29 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* description of one iso transaction (up to 3 KB data if highspeed) */
|
|
|
|
struct ehci_iso_packet {
|
|
|
|
/* These will be copied to iTD when scheduling */
|
|
|
|
u64 bufp; /* itd->hw_bufp{,_hi}[pg] |= */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 transaction; /* itd->hw_transaction[i] |= */
|
2005-04-16 22:20:36 +00:00
|
|
|
u8 cross; /* buf crosses pages */
|
|
|
|
/* for full speed OUT splits */
|
|
|
|
u32 buf1;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* temporary schedule data for packets from iso urbs (both speeds)
|
|
|
|
* each packet is one logical usb transaction to the device (not TT),
|
|
|
|
* beginning at stream->next_uframe
|
|
|
|
*/
|
|
|
|
struct ehci_iso_sched {
|
|
|
|
struct list_head td_list;
|
|
|
|
unsigned span;
|
2013-09-03 17:59:03 +00:00
|
|
|
unsigned first_packet;
|
2016-01-26 01:44:46 +00:00
|
|
|
struct ehci_iso_packet packet[0];
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ehci_iso_stream - groups all (s)itds for this endpoint.
|
|
|
|
* acts like a qh would, if EHCI had them for ISO.
|
|
|
|
*/
|
|
|
|
struct ehci_iso_stream {
|
2010-03-01 16:18:56 +00:00
|
|
|
/* first field matches ehci_hq, but is NULL */
|
|
|
|
struct ehci_qh_hw *hw;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
u8 bEndpointAddress;
|
|
|
|
u8 highspeed;
|
|
|
|
struct list_head td_list; /* queued itds/sitds */
|
|
|
|
struct list_head free_list; /* list of unused itds/sitds */
|
|
|
|
|
|
|
|
/* output of (re)scheduling */
|
2013-10-11 15:29:03 +00:00
|
|
|
struct ehci_per_sched ps; /* scheduling info */
|
2013-10-11 15:28:52 +00:00
|
|
|
unsigned next_uframe;
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 splits;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* the rest is derived from the endpoint descriptor,
|
|
|
|
* including the extra info for hw_bufp[0..2]
|
|
|
|
*/
|
2013-10-11 15:29:03 +00:00
|
|
|
u16 uperiod; /* period in uframes */
|
2005-04-16 22:20:36 +00:00
|
|
|
u16 maxp;
|
|
|
|
unsigned bandwidth;
|
|
|
|
|
|
|
|
/* This is used to initialize iTD's hw_bufp fields */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 buf0;
|
|
|
|
__hc32 buf1;
|
|
|
|
__hc32 buf2;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* this is used to initialize sITD's tt info */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 address;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EHCI Specification 0.95 Section 3.3
|
|
|
|
* Fig 3-4 "Isochronous Transaction Descriptor (iTD)"
|
|
|
|
*
|
|
|
|
* Schedule records for high speed iso xfers
|
|
|
|
*/
|
|
|
|
struct ehci_itd {
|
|
|
|
/* first part defined by EHCI spec */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_next; /* see EHCI 3.3.1 */
|
2016-01-26 01:44:46 +00:00
|
|
|
__hc32 hw_transaction[8]; /* see EHCI 3.3.2 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define EHCI_ISOC_ACTIVE (1<<31) /* activate transfer this slot */
|
|
|
|
#define EHCI_ISOC_BUF_ERR (1<<30) /* Data buffer error */
|
|
|
|
#define EHCI_ISOC_BABBLE (1<<29) /* babble detected */
|
|
|
|
#define EHCI_ISOC_XACTERR (1<<28) /* XactErr - transaction error */
|
|
|
|
#define EHCI_ITD_LENGTH(tok) (((tok)>>16) & 0x0fff)
|
|
|
|
#define EHCI_ITD_IOC (1 << 15) /* interrupt on complete */
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
#define ITD_ACTIVE(ehci) cpu_to_hc32(ehci, EHCI_ISOC_ACTIVE)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-01-26 01:44:46 +00:00
|
|
|
__hc32 hw_bufp[7]; /* see EHCI 3.3.3 */
|
|
|
|
__hc32 hw_bufp_hi[7]; /* Appendix B */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* the rest is HCD-private */
|
|
|
|
dma_addr_t itd_dma; /* for this itd */
|
|
|
|
union ehci_shadow itd_next; /* ptr to periodic q entry */
|
|
|
|
|
|
|
|
struct urb *urb;
|
|
|
|
struct ehci_iso_stream *stream; /* endpoint's queue */
|
|
|
|
struct list_head itd_list; /* list of stream's itds */
|
|
|
|
|
|
|
|
/* any/all hw_transactions here may be used by that urb */
|
|
|
|
unsigned frame; /* where scheduled */
|
|
|
|
unsigned pg;
|
|
|
|
unsigned index[8]; /* in urb->iso_frame_desc */
|
|
|
|
} __attribute__ ((aligned (32)));
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
2006-08-30 21:50:06 +00:00
|
|
|
* EHCI Specification 0.95 Section 3.4
|
2005-04-16 22:20:36 +00:00
|
|
|
* siTD, aka split-transaction isochronous Transfer Descriptor
|
|
|
|
* ... describe full speed iso xfers through TT in hubs
|
|
|
|
* see Figure 3-5 "Split-transaction Isochronous Transaction Descriptor (siTD)
|
|
|
|
*/
|
|
|
|
struct ehci_sitd {
|
|
|
|
/* first part defined by EHCI spec */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_next;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* uses bit field macros above - see EHCI 0.95 Table 3-8 */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_fullspeed_ep; /* EHCI table 3-9 */
|
|
|
|
__hc32 hw_uframe; /* EHCI table 3-10 */
|
|
|
|
__hc32 hw_results; /* EHCI table 3-11 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define SITD_IOC (1 << 31) /* interrupt on completion */
|
|
|
|
#define SITD_PAGE (1 << 30) /* buffer 0/1 */
|
|
|
|
#define SITD_LENGTH(x) (0x3ff & ((x)>>16))
|
|
|
|
#define SITD_STS_ACTIVE (1 << 7) /* HC may execute this */
|
|
|
|
#define SITD_STS_ERR (1 << 6) /* error from TT */
|
|
|
|
#define SITD_STS_DBE (1 << 5) /* data buffer error (in HC) */
|
|
|
|
#define SITD_STS_BABBLE (1 << 4) /* device was babbling */
|
|
|
|
#define SITD_STS_XACT (1 << 3) /* illegal IN response */
|
|
|
|
#define SITD_STS_MMF (1 << 2) /* incomplete split transaction */
|
|
|
|
#define SITD_STS_STS (1 << 1) /* split transaction state */
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
#define SITD_ACTIVE(ehci) cpu_to_hc32(ehci, SITD_STS_ACTIVE)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-01-26 01:44:46 +00:00
|
|
|
__hc32 hw_buf[2]; /* EHCI table 3-12 */
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_backpointer; /* EHCI table 3-13 */
|
2016-01-26 01:44:46 +00:00
|
|
|
__hc32 hw_buf_hi[2]; /* Appendix B */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* the rest is HCD-private */
|
|
|
|
dma_addr_t sitd_dma;
|
|
|
|
union ehci_shadow sitd_next; /* ptr to periodic q entry */
|
|
|
|
|
|
|
|
struct urb *urb;
|
|
|
|
struct ehci_iso_stream *stream; /* endpoint's queue */
|
|
|
|
struct list_head sitd_list; /* list of stream's sitds */
|
|
|
|
unsigned frame;
|
|
|
|
unsigned index;
|
|
|
|
} __attribute__ ((aligned (32)));
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EHCI Specification 0.96 Section 3.7
|
|
|
|
* Periodic Frame Span Traversal Node (FSTN)
|
|
|
|
*
|
|
|
|
* Manages split interrupt transactions (using TT) that span frame boundaries
|
|
|
|
* into uframes 0/1; see 4.12.2.2. In those uframes, a "save place" FSTN
|
|
|
|
* makes the HC jump (back) to a QH to scan for fs/ls QH completions until
|
|
|
|
* it hits a "restore" FSTN; then it returns to finish other uframe 0/1 work.
|
|
|
|
*/
|
|
|
|
struct ehci_fstn {
|
2007-05-01 16:29:37 +00:00
|
|
|
__hc32 hw_next; /* any periodic q entry */
|
|
|
|
__hc32 hw_prev; /* qh or EHCI_LIST_END */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* the rest is HCD-private */
|
|
|
|
dma_addr_t fstn_dma;
|
|
|
|
union ehci_shadow fstn_next; /* ptr to periodic q entry */
|
|
|
|
} __attribute__ ((aligned (32)));
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2013-10-12 02:16:21 +00:00
|
|
|
/*
|
|
|
|
* USB-2.0 Specification Sections 11.14 and 11.18
|
|
|
|
* Scheduling and budgeting split transactions using TTs
|
|
|
|
*
|
|
|
|
* A hub can have a single TT for all its ports, or multiple TTs (one for each
|
|
|
|
* port). The bandwidth and budgeting information for the full/low-speed bus
|
|
|
|
* below each TT is self-contained and independent of the other TTs or the
|
|
|
|
* high-speed bus.
|
|
|
|
*
|
|
|
|
* "Bandwidth" refers to the number of microseconds on the FS/LS bus allocated
|
|
|
|
* to an interrupt or isochronous endpoint for each frame. "Budget" refers to
|
|
|
|
* the best-case estimate of the number of full-speed bytes allocated to an
|
|
|
|
* endpoint for each microframe within an allocated frame.
|
|
|
|
*
|
|
|
|
* Removal of an endpoint invalidates a TT's budget. Instead of trying to
|
|
|
|
* keep an up-to-date record, we recompute the budget when it is needed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct ehci_tt {
|
|
|
|
u16 bandwidth[EHCI_BANDWIDTH_FRAMES];
|
|
|
|
|
|
|
|
struct list_head tt_list; /* List of all ehci_tt's */
|
|
|
|
struct list_head ps_list; /* Items using this TT */
|
|
|
|
struct usb_tt *usb_tt;
|
|
|
|
int tt_port; /* TT port number */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2010-05-12 22:21:35 +00:00
|
|
|
/* Prepare the PORTSC wakeup flags during controller suspend/resume */
|
|
|
|
|
2010-06-25 18:02:14 +00:00
|
|
|
#define ehci_prepare_ports_for_controller_suspend(ehci, do_wakeup) \
|
|
|
|
ehci_adjust_port_wakeup_flags(ehci, true, do_wakeup);
|
2010-05-12 22:21:35 +00:00
|
|
|
|
2010-06-25 18:02:14 +00:00
|
|
|
#define ehci_prepare_ports_for_controller_resume(ehci) \
|
|
|
|
ehci_adjust_port_wakeup_flags(ehci, false, false);
|
2010-05-12 22:21:35 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_ROOT_HUB_TT
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some EHCI controllers have a Transaction Translator built into the
|
|
|
|
* root hub. This is a non-standard feature. Each controller will need
|
|
|
|
* to add code to the following inline functions, and call them as
|
|
|
|
* needed (mostly in root hub code).
|
|
|
|
*/
|
|
|
|
|
2008-05-20 20:58:11 +00:00
|
|
|
#define ehci_is_TDI(e) (ehci_to_hcd(e)->has_tt)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Returns the speed of a device attached to a port on the root hub. */
|
|
|
|
static inline unsigned int
|
|
|
|
ehci_port_speed(struct ehci_hcd *ehci, unsigned int portsc)
|
|
|
|
{
|
|
|
|
if (ehci_is_TDI(ehci)) {
|
2009-07-13 04:41:20 +00:00
|
|
|
switch ((portsc >> (ehci->has_hostpc ? 25 : 26)) & 3) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case 0:
|
|
|
|
return 0;
|
|
|
|
case 1:
|
2010-03-04 16:32:30 +00:00
|
|
|
return USB_PORT_STAT_LOW_SPEED;
|
2005-04-16 22:20:36 +00:00
|
|
|
case 2:
|
|
|
|
default:
|
2010-03-04 16:32:30 +00:00
|
|
|
return USB_PORT_STAT_HIGH_SPEED;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2010-03-04 16:32:30 +00:00
|
|
|
return USB_PORT_STAT_HIGH_SPEED;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define ehci_is_TDI(e) (0)
|
|
|
|
|
2010-03-04 16:32:30 +00:00
|
|
|
#define ehci_port_speed(ehci, portsc) USB_PORT_STAT_HIGH_SPEED
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2006-01-20 21:57:52 +00:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_83xx
|
|
|
|
/* Some Freescale processors have an erratum in which the TT
|
|
|
|
* port number in the queue head was 0..N-1 instead of 1..N.
|
|
|
|
*/
|
|
|
|
#define ehci_has_fsl_portno_bug(e) ((e)->has_fsl_port_bug)
|
|
|
|
#else
|
|
|
|
#define ehci_has_fsl_portno_bug(e) (0)
|
|
|
|
#endif
|
|
|
|
|
2015-08-06 09:21:27 +00:00
|
|
|
#define PORTSC_FSL_PFSC 24 /* Port Force Full-Speed Connect */
|
|
|
|
|
|
|
|
#if defined(CONFIG_PPC_85xx)
|
|
|
|
/* Some Freescale processors have an erratum (USB A-005275) in which
|
|
|
|
* incoming packets get corrupted in HS mode
|
|
|
|
*/
|
|
|
|
#define ehci_has_fsl_hs_errata(e) ((e)->has_fsl_hs_errata)
|
|
|
|
#else
|
|
|
|
#define ehci_has_fsl_hs_errata(e) (0)
|
|
|
|
#endif
|
|
|
|
|
2006-12-14 19:54:08 +00:00
|
|
|
/*
|
|
|
|
* While most USB host controllers implement their registers in
|
|
|
|
* little-endian format, a minority (celleb companion chip) implement
|
|
|
|
* them in big endian format.
|
|
|
|
*
|
|
|
|
* This attempts to support either format at compile time without a
|
|
|
|
* runtime penalty, or both formats with the additional overhead
|
|
|
|
* of checking a flag bit.
|
2011-05-03 18:11:57 +00:00
|
|
|
*
|
|
|
|
* ehci_big_endian_capbase is a special quirk for controllers that
|
|
|
|
* implement the HC capability registers as separate registers and not
|
|
|
|
* as fields of a 32-bit register.
|
2006-12-14 19:54:08 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
|
|
|
|
#define ehci_big_endian_mmio(e) ((e)->big_endian_mmio)
|
2011-05-03 18:11:57 +00:00
|
|
|
#define ehci_big_endian_capbase(e) ((e)->big_endian_capbase)
|
2006-12-14 19:54:08 +00:00
|
|
|
#else
|
|
|
|
#define ehci_big_endian_mmio(e) 0
|
2011-05-03 18:11:57 +00:00
|
|
|
#define ehci_big_endian_capbase(e) 0
|
2006-12-14 19:54:08 +00:00
|
|
|
#endif
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
/*
|
|
|
|
* Big-endian read/write functions are arch-specific.
|
|
|
|
* Other arches can be added if/when they're needed.
|
|
|
|
*/
|
2007-12-30 23:21:11 +00:00
|
|
|
#if defined(CONFIG_ARM) && defined(CONFIG_ARCH_IXP4XX)
|
|
|
|
#define readl_be(addr) __raw_readl((__force unsigned *)addr)
|
|
|
|
#define writel_be(val, addr) __raw_writel(val, (__force unsigned *)addr)
|
|
|
|
#endif
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
static inline unsigned int ehci_readl(const struct ehci_hcd *ehci,
|
|
|
|
__u32 __iomem * regs)
|
2006-12-14 19:54:08 +00:00
|
|
|
{
|
2006-12-28 04:27:27 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
|
2006-12-14 19:54:08 +00:00
|
|
|
return ehci_big_endian_mmio(ehci) ?
|
2007-02-09 16:40:00 +00:00
|
|
|
readl_be(regs) :
|
|
|
|
readl(regs);
|
2006-12-28 04:27:27 +00:00
|
|
|
#else
|
2007-02-09 16:40:00 +00:00
|
|
|
return readl(regs);
|
2006-12-28 04:27:27 +00:00
|
|
|
#endif
|
2006-12-14 19:54:08 +00:00
|
|
|
}
|
|
|
|
|
2014-01-10 05:51:26 +00:00
|
|
|
#ifdef CONFIG_SOC_IMX28
|
|
|
|
static inline void imx28_ehci_writel(const unsigned int val,
|
|
|
|
volatile __u32 __iomem *addr)
|
|
|
|
{
|
|
|
|
__asm__ ("swp %0, %0, [%1]" : : "r"(val), "r"(addr));
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void imx28_ehci_writel(const unsigned int val,
|
|
|
|
volatile __u32 __iomem *addr)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
2007-05-01 16:29:37 +00:00
|
|
|
static inline void ehci_writel(const struct ehci_hcd *ehci,
|
|
|
|
const unsigned int val, __u32 __iomem *regs)
|
2006-12-14 19:54:08 +00:00
|
|
|
{
|
2006-12-28 04:27:27 +00:00
|
|
|
#ifdef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
|
2006-12-14 19:54:08 +00:00
|
|
|
ehci_big_endian_mmio(ehci) ?
|
2007-02-09 16:40:00 +00:00
|
|
|
writel_be(val, regs) :
|
|
|
|
writel(val, regs);
|
2006-12-28 04:27:27 +00:00
|
|
|
#else
|
2014-01-10 05:51:26 +00:00
|
|
|
if (ehci->imx28_write_fix)
|
|
|
|
imx28_ehci_writel(val, regs);
|
|
|
|
else
|
|
|
|
writel(val, regs);
|
2006-12-28 04:27:27 +00:00
|
|
|
#endif
|
2006-12-14 19:54:08 +00:00
|
|
|
}
|
2006-01-20 21:57:52 +00:00
|
|
|
|
USB: powerpc: Workaround for the PPC440EPX USBH_23 errata [take 3]
A published errata for ppc440epx states, that when running Linux with
both EHCI and OHCI modules loaded, the EHCI module experiences a fatal
error when a high-speed device is connected to the USB2.0, and
functions normally if OHCI module is not loaded.
There used to be recommendation to use only hi-speed or full-speed
devices with specific conditions, when respective module was unloaded.
Later, it was observed that ohci suspend is enough to keep things
going, and it was turned into workaround, as explained below.
Quote from original descriprion:
The 440EPx USB 2.0 Host controller is an EHCI compliant controller. In
USB 2.0 Host controllers, each EHCI controller has one or more companion
controllers, which may be OHCI or UHCI. An USB 2.0 Host controller will
contain one or more ports. For each port, only one of the controllers
is connected at any one time. In the 440EPx, there is only one OHCI
companion controller, and only one USB 2.0 Host port.
All ports on an USB 2.0 controller default to the companion
controller. If you load only an ohci driver, it will have control of
the ports and any deviceplugged in will operate, although high speed
devices will be forced to operate at full speed. When an ehci driver
is loaded, it explicitly takes control of the ports. If there is a
device connected, and / or every time there is a new device connected,
the ehci driver determines if the device is high speed or not. If it
is high speed, the driver retains control of the port. If it is not,
the driver explicitly gives the companion controller control of the
port.
The is a software workaround that uses
Initial version of the software workaround was posted to
linux-usb-devel:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg54019.html
and later available from amcc.com:
http://www.amcc.com/Embedded/Downloads/download.html?cat=1&family=15&ins=2
The patch below is generally based on the latter, but reworked to
powerpc/of_device USB drivers, and uses a few devicetree inquiries to
get rid of (some) hardcoded defines.
Signed-off-by: Vitaly Bordug <vitb@kernel.crashing.org>
Signed-off-by: Stefan Roese <sr@denx.de>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-11-09 18:43:30 +00:00
|
|
|
/*
|
|
|
|
* On certain ppc-44x SoC there is a HW issue, that could only worked around with
|
|
|
|
* explicit suspend/operate of OHCI. This function hereby makes sense only on that arch.
|
2011-03-31 01:57:33 +00:00
|
|
|
* Other common bits are dependent on has_amcc_usb23 quirk flag.
|
USB: powerpc: Workaround for the PPC440EPX USBH_23 errata [take 3]
A published errata for ppc440epx states, that when running Linux with
both EHCI and OHCI modules loaded, the EHCI module experiences a fatal
error when a high-speed device is connected to the USB2.0, and
functions normally if OHCI module is not loaded.
There used to be recommendation to use only hi-speed or full-speed
devices with specific conditions, when respective module was unloaded.
Later, it was observed that ohci suspend is enough to keep things
going, and it was turned into workaround, as explained below.
Quote from original descriprion:
The 440EPx USB 2.0 Host controller is an EHCI compliant controller. In
USB 2.0 Host controllers, each EHCI controller has one or more companion
controllers, which may be OHCI or UHCI. An USB 2.0 Host controller will
contain one or more ports. For each port, only one of the controllers
is connected at any one time. In the 440EPx, there is only one OHCI
companion controller, and only one USB 2.0 Host port.
All ports on an USB 2.0 controller default to the companion
controller. If you load only an ohci driver, it will have control of
the ports and any deviceplugged in will operate, although high speed
devices will be forced to operate at full speed. When an ehci driver
is loaded, it explicitly takes control of the ports. If there is a
device connected, and / or every time there is a new device connected,
the ehci driver determines if the device is high speed or not. If it
is high speed, the driver retains control of the port. If it is not,
the driver explicitly gives the companion controller control of the
port.
The is a software workaround that uses
Initial version of the software workaround was posted to
linux-usb-devel:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg54019.html
and later available from amcc.com:
http://www.amcc.com/Embedded/Downloads/download.html?cat=1&family=15&ins=2
The patch below is generally based on the latter, but reworked to
powerpc/of_device USB drivers, and uses a few devicetree inquiries to
get rid of (some) hardcoded defines.
Signed-off-by: Vitaly Bordug <vitb@kernel.crashing.org>
Signed-off-by: Stefan Roese <sr@denx.de>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-11-09 18:43:30 +00:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_44x
|
|
|
|
static inline void set_ohci_hcfs(struct ehci_hcd *ehci, int operational)
|
|
|
|
{
|
|
|
|
u32 hc_control;
|
|
|
|
|
|
|
|
hc_control = (readl_be(ehci->ohci_hcctrl_reg) & ~OHCI_CTRL_HCFS);
|
|
|
|
if (operational)
|
|
|
|
hc_control |= OHCI_USB_OPER;
|
|
|
|
else
|
|
|
|
hc_control |= OHCI_USB_SUSPEND;
|
|
|
|
|
|
|
|
writel_be(hc_control, ehci->ohci_hcctrl_reg);
|
|
|
|
(void) readl_be(ehci->ohci_hcctrl_reg);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void set_ohci_hcfs(struct ehci_hcd *ehci, int operational)
|
|
|
|
{ }
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-05-01 16:29:37 +00:00
|
|
|
/*
|
|
|
|
* The AMCC 440EPx not only implements its EHCI registers in big-endian
|
|
|
|
* format, but also its DMA data structures (descriptors).
|
|
|
|
*
|
|
|
|
* EHCI controllers accessed through PCI work normally (little-endian
|
|
|
|
* everywhere), so we won't bother supporting a BE-only mode for now.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
|
|
|
|
#define ehci_big_endian_desc(e) ((e)->big_endian_desc)
|
|
|
|
|
|
|
|
/* cpu to ehci */
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline __hc32 cpu_to_hc32(const struct ehci_hcd *ehci, const u32 x)
|
2007-05-01 16:29:37 +00:00
|
|
|
{
|
|
|
|
return ehci_big_endian_desc(ehci)
|
|
|
|
? (__force __hc32)cpu_to_be32(x)
|
|
|
|
: (__force __hc32)cpu_to_le32(x);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ehci to cpu */
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline u32 hc32_to_cpu(const struct ehci_hcd *ehci, const __hc32 x)
|
2007-05-01 16:29:37 +00:00
|
|
|
{
|
|
|
|
return ehci_big_endian_desc(ehci)
|
|
|
|
? be32_to_cpu((__force __be32)x)
|
|
|
|
: le32_to_cpu((__force __le32)x);
|
|
|
|
}
|
|
|
|
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline u32 hc32_to_cpup(const struct ehci_hcd *ehci, const __hc32 *x)
|
2007-05-01 16:29:37 +00:00
|
|
|
{
|
|
|
|
return ehci_big_endian_desc(ehci)
|
|
|
|
? be32_to_cpup((__force __be32 *)x)
|
|
|
|
: le32_to_cpup((__force __le32 *)x);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
/* cpu to ehci */
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline __hc32 cpu_to_hc32(const struct ehci_hcd *ehci, const u32 x)
|
2007-05-01 16:29:37 +00:00
|
|
|
{
|
|
|
|
return cpu_to_le32(x);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ehci to cpu */
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline u32 hc32_to_cpu(const struct ehci_hcd *ehci, const __hc32 x)
|
2007-05-01 16:29:37 +00:00
|
|
|
{
|
|
|
|
return le32_to_cpu(x);
|
|
|
|
}
|
|
|
|
|
2016-01-26 01:44:45 +00:00
|
|
|
static inline u32 hc32_to_cpup(const struct ehci_hcd *ehci, const __hc32 *x)
|
2007-05-01 16:29:37 +00:00
|
|
|
{
|
|
|
|
return le32_to_cpup(x);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2012-10-10 19:07:30 +00:00
|
|
|
#define ehci_dbg(ehci, fmt, args...) \
|
2016-01-26 01:44:44 +00:00
|
|
|
dev_dbg(ehci_to_hcd(ehci)->self.controller, fmt, ## args)
|
2012-10-10 19:07:30 +00:00
|
|
|
#define ehci_err(ehci, fmt, args...) \
|
2016-01-26 01:44:44 +00:00
|
|
|
dev_err(ehci_to_hcd(ehci)->self.controller, fmt, ## args)
|
2012-10-10 19:07:30 +00:00
|
|
|
#define ehci_info(ehci, fmt, args...) \
|
2016-01-26 01:44:44 +00:00
|
|
|
dev_info(ehci_to_hcd(ehci)->self.controller, fmt, ## args)
|
2012-10-10 19:07:30 +00:00
|
|
|
#define ehci_warn(ehci, fmt, args...) \
|
2016-01-26 01:44:44 +00:00
|
|
|
dev_warn(ehci_to_hcd(ehci)->self.controller, fmt, ## args)
|
2012-10-10 19:07:30 +00:00
|
|
|
|
|
|
|
|
2013-11-18 12:23:16 +00:00
|
|
|
#ifndef CONFIG_DYNAMIC_DEBUG
|
2005-04-16 22:20:36 +00:00
|
|
|
#define STUB_DEBUG_FILES
|
2013-11-18 12:23:16 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2012-11-01 15:12:58 +00:00
|
|
|
/* Declarations of things exported for use by ehci platform drivers */
|
|
|
|
|
|
|
|
struct ehci_driver_overrides {
|
|
|
|
size_t extra_priv_size;
|
|
|
|
int (*reset)(struct usb_hcd *hcd);
|
2014-10-13 01:53:03 +00:00
|
|
|
int (*port_power)(struct usb_hcd *hcd,
|
|
|
|
int portnum, bool enable);
|
2012-11-01 15:12:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
extern void ehci_init_driver(struct hc_driver *drv,
|
|
|
|
const struct ehci_driver_overrides *over);
|
|
|
|
extern int ehci_setup(struct usb_hcd *hcd);
|
2013-06-13 17:24:09 +00:00
|
|
|
extern int ehci_handshake(struct ehci_hcd *ehci, void __iomem *ptr,
|
|
|
|
u32 mask, u32 done, int usec);
|
2015-05-29 05:58:30 +00:00
|
|
|
extern int ehci_reset(struct ehci_hcd *ehci);
|
2012-11-01 15:12:58 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
extern int ehci_suspend(struct usb_hcd *hcd, bool do_wakeup);
|
2014-12-24 10:22:19 +00:00
|
|
|
extern int ehci_resume(struct usb_hcd *hcd, bool force_reset);
|
2015-05-29 05:58:30 +00:00
|
|
|
extern void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
|
|
|
|
bool suspending, bool do_wakeup);
|
2012-11-01 15:12:58 +00:00
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
2014-04-16 16:00:10 +00:00
|
|
|
extern int ehci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
|
|
|
|
u16 wIndex, char *buf, u16 wLength);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __LINUX_EHCI_HCD_H */
|