blob: 057cdda7a48978999ebf5ac4cbb8ecee7acc60e0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Alan Stern578333a2011-06-15 16:32:46 -04002 * Enhanced Host Controller Interface (EHCI) driver for USB.
3 *
4 * Maintainer: Alan Stern <stern@rowland.harvard.edu>
5 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright (c) 2000-2004 by David Brownell
David Brownell53bd6a62006-08-30 14:50:06 -07007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/module.h>
24#include <linux/pci.h>
25#include <linux/dmapool.h>
26#include <linux/kernel.h>
27#include <linux/delay.h>
28#include <linux/ioport.h>
29#include <linux/sched.h>
Ming Lei3c04e202008-09-18 23:06:21 +080030#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/errno.h>
32#include <linux/init.h>
33#include <linux/timer.h>
Oliver Neukumee4ecb82009-11-27 15:17:59 +010034#include <linux/ktime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/list.h>
36#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/usb.h>
Eric Lescouet27729aa2010-04-24 23:21:52 +020038#include <linux/usb/hcd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/moduleparam.h>
40#include <linux/dma-mapping.h>
Tony Jones694cc202007-09-11 14:07:31 -070041#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090042#include <linux/slab.h>
Alek Duaa4d8342010-06-04 15:47:54 +080043#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <asm/byteorder.h>
46#include <asm/io.h>
47#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <asm/unaligned.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Geoff Levanddf7c1ca2011-11-30 16:40:57 -080050#if defined(CONFIG_PPC_PS3)
51#include <asm/firmware.h>
52#endif
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054/*-------------------------------------------------------------------------*/
55
56/*
57 * EHCI hc_driver implementation ... experimental, incomplete.
58 * Based on the final 1.0 register interface specification.
59 *
60 * USB 2.0 shows up in upcoming www.pcmcia.org technology.
61 * First was PCMCIA, like ISA; then CardBus, which is PCI.
62 * Next comes "CardBay", using USB 2.0 signals.
63 *
64 * Contains additional contributions by Brad Hards, Rory Bolt, and others.
65 * Special thanks to Intel and VIA for providing host controllers to
66 * test this driver on, and Cypress (including In-System Design) for
67 * providing early devices for those host controllers to talk to!
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 */
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#define DRIVER_AUTHOR "David Brownell"
71#define DRIVER_DESC "USB 2.0 'Enhanced' Host Controller (EHCI) Driver"
72
73static const char hcd_name [] = "ehci_hcd";
74
75
David Brownell9776afc2008-02-01 11:42:05 -080076#undef VERBOSE_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#undef EHCI_URB_TRACE
78
79#ifdef DEBUG
80#define EHCI_STATS
81#endif
82
83/* magic numbers that can affect system performance */
84#define EHCI_TUNE_CERR 3 /* 0-3 qtd retries; 0 == don't stop */
85#define EHCI_TUNE_RL_HS 4 /* nak throttle; see 4.9 */
86#define EHCI_TUNE_RL_TT 0
87#define EHCI_TUNE_MULT_HS 1 /* 1-3 transactions/uframe; 4.10.3 */
88#define EHCI_TUNE_MULT_TT 1
Alan Sternffda0802010-07-14 11:03:46 -040089/*
90 * Some drivers think it's safe to schedule isochronous transfers more than
91 * 256 ms into the future (partly as a result of an old bug in the scheduling
92 * code). In an attempt to avoid trouble, we will use a minimum scheduling
93 * length of 512 frames instead of 256.
94 */
95#define EHCI_TUNE_FLS 1 /* (medium) 512-frame schedule */
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Alan Stern07d29b62007-12-11 16:05:30 -050097#define EHCI_IAA_MSECS 10 /* arbitrary */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#define EHCI_IO_JIFFIES (HZ/10) /* io watchdog > irq_thresh */
99#define EHCI_ASYNC_JIFFIES (HZ/20) /* async idle timeout */
Alan Stern004c1962011-07-05 12:34:05 -0400100#define EHCI_SHRINK_JIFFIES (DIV_ROUND_UP(HZ, 200) + 1)
Ming Leifcda37c2011-09-05 21:05:57 +0800101 /* 5-ms async qh unlink delay */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103/* Initial IRQ latency: faster than hw default */
104static int log2_irq_thresh = 0; // 0 to 6
105module_param (log2_irq_thresh, int, S_IRUGO);
106MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes");
107
108/* initial park setting: slower than hw default */
109static unsigned park = 0;
110module_param (park, uint, S_IRUGO);
111MODULE_PARM_DESC (park, "park setting; 1-3 back-to-back async packets");
112
David Brownell93f1a472006-11-16 23:34:58 -0800113/* for flakey hardware, ignore overcurrent indicators */
Rusty Russell90ab5ee2012-01-13 09:32:20 +1030114static bool ignore_oc = 0;
David Brownell93f1a472006-11-16 23:34:58 -0800115module_param (ignore_oc, bool, S_IRUGO);
116MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
117
Alek Du48f24972010-06-04 15:47:55 +0800118/* for link power management(LPM) feature */
119static unsigned int hird;
120module_param(hird, int, S_IRUGO);
Niels de Voscc556872011-05-31 23:00:10 +0100121MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us");
Alek Du48f24972010-06-04 15:47:55 +0800122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
124
125/*-------------------------------------------------------------------------*/
126
127#include "ehci.h"
128#include "ehci-dbg.c"
Andiry Xuad935622011-03-01 14:57:05 +0800129#include "pci-quirks.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131/*-------------------------------------------------------------------------*/
132
Alan Sternbc298472009-02-11 14:26:38 -0500133static void
134timer_action(struct ehci_hcd *ehci, enum ehci_timer_action action)
135{
136 /* Don't override timeouts which shrink or (later) disable
137 * the async ring; just the I/O watchdog. Note that if a
138 * SHRINK were pending, OFF would never be requested.
139 */
140 if (timer_pending(&ehci->watchdog)
141 && ((BIT(TIMER_ASYNC_SHRINK) | BIT(TIMER_ASYNC_OFF))
142 & ehci->actions))
143 return;
144
145 if (!test_and_set_bit(action, &ehci->actions)) {
146 unsigned long t;
147
148 switch (action) {
149 case TIMER_IO_WATCHDOG:
Alek Du403dbd32009-07-13 17:30:41 +0800150 if (!ehci->need_io_watchdog)
151 return;
Alan Sternbc298472009-02-11 14:26:38 -0500152 t = EHCI_IO_JIFFIES;
153 break;
154 case TIMER_ASYNC_OFF:
155 t = EHCI_ASYNC_JIFFIES;
156 break;
157 /* case TIMER_ASYNC_SHRINK: */
158 default:
Alan Stern004c1962011-07-05 12:34:05 -0400159 t = EHCI_SHRINK_JIFFIES;
Alan Sternbc298472009-02-11 14:26:38 -0500160 break;
161 }
162 mod_timer(&ehci->watchdog, t + jiffies);
163 }
164}
165
166/*-------------------------------------------------------------------------*/
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168/*
169 * handshake - spin reading hc until handshake completes or fails
170 * @ptr: address of hc register to be read
171 * @mask: bits to look at in result of read
172 * @done: value of those bits when handshake succeeds
173 * @usec: timeout in microseconds
174 *
175 * Returns negative errno, or zero on success
176 *
177 * Success happens when the "mask" bits have the specified value (hardware
178 * handshake done). There are two failure modes: "usec" have passed (major
179 * hardware flakeout), or the register reads as all-ones (hardware removed).
180 *
181 * That last failure should_only happen in cases like physical cardbus eject
182 * before driver shutdown. But it also seems to be caused by bugs in cardbus
183 * bridge shutdown: shutting down the bridge before the devices using it.
184 */
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100185static int handshake (struct ehci_hcd *ehci, void __iomem *ptr,
186 u32 mask, u32 done, int usec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
188 u32 result;
189
190 do {
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100191 result = ehci_readl(ehci, ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (result == ~(u32)0) /* card removed */
193 return -ENODEV;
194 result &= mask;
195 if (result == done)
196 return 0;
197 udelay (1);
198 usec--;
199 } while (usec > 0);
200 return -ETIMEDOUT;
201}
202
Matthieu CASTET65fd4272010-09-06 18:26:56 +0200203/* check TDI/ARC silicon is in host mode */
204static int tdi_in_host_mode (struct ehci_hcd *ehci)
205{
206 u32 __iomem *reg_ptr;
207 u32 tmp;
208
209 reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
210 tmp = ehci_readl(ehci, reg_ptr);
211 return (tmp & 3) == USBMODE_CM_HC;
212}
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214/* force HC to halt state from unknown (EHCI spec section 2.3) */
215static int ehci_halt (struct ehci_hcd *ehci)
216{
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100217 u32 temp = ehci_readl(ehci, &ehci->regs->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
David Brownell72f30b62005-09-27 10:19:39 -0700219 /* disable any irqs left enabled by previous code */
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100220 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
David Brownell72f30b62005-09-27 10:19:39 -0700221
Matthieu CASTET65fd4272010-09-06 18:26:56 +0200222 if (ehci_is_TDI(ehci) && tdi_in_host_mode(ehci) == 0) {
223 return 0;
224 }
225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 if ((temp & STS_HALT) != 0)
227 return 0;
228
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100229 temp = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 temp &= ~CMD_RUN;
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100231 ehci_writel(ehci, temp, &ehci->regs->command);
232 return handshake (ehci, &ehci->regs->status,
233 STS_HALT, STS_HALT, 16 * 125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
Geoff Levanddf7c1ca2011-11-30 16:40:57 -0800236#if defined(CONFIG_USB_SUSPEND) && defined(CONFIG_PPC_PS3)
237
238/*
239 * The EHCI controller of the Cell Super Companion Chip used in the
240 * PS3 will stop the root hub after all root hub ports are suspended.
241 * When in this condition handshake will return -ETIMEDOUT. The
242 * STS_HLT bit will not be set, so inspection of the frame index is
243 * used here to test for the condition. If the condition is found
244 * return success to allow the USB suspend to complete.
245 */
246
247static int handshake_for_broken_root_hub(struct ehci_hcd *ehci,
248 void __iomem *ptr, u32 mask, u32 done,
249 int usec)
250{
251 unsigned int old_index;
252 int error;
253
254 if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
255 return -ETIMEDOUT;
256
257 old_index = ehci_read_frame_index(ehci);
258
259 error = handshake(ehci, ptr, mask, done, usec);
260
261 if (error == -ETIMEDOUT && ehci_read_frame_index(ehci) == old_index)
262 return 0;
263
264 return error;
265}
266
267#else
268
269static int handshake_for_broken_root_hub(struct ehci_hcd *ehci,
270 void __iomem *ptr, u32 mask, u32 done,
271 int usec)
272{
273 return -ETIMEDOUT;
274}
275
276#endif
277
David Brownell0bcfeb32008-08-26 14:43:46 -0700278static int handshake_on_error_set_halt(struct ehci_hcd *ehci, void __iomem *ptr,
279 u32 mask, u32 done, int usec)
280{
281 int error;
282
283 error = handshake(ehci, ptr, mask, done, usec);
Geoff Levanddf7c1ca2011-11-30 16:40:57 -0800284 if (error == -ETIMEDOUT)
285 error = handshake_for_broken_root_hub(ehci, ptr, mask, done,
286 usec);
287
David Brownell0bcfeb32008-08-26 14:43:46 -0700288 if (error) {
289 ehci_halt(ehci);
Alan Sterne8799902011-08-18 16:31:30 -0400290 ehci->rh_state = EHCI_RH_HALTED;
Ozan Çağlayan65cb76b2009-10-13 08:37:09 +0300291 ehci_err(ehci, "force halt; handshake %p %08x %08x -> %d\n",
David Brownell0bcfeb32008-08-26 14:43:46 -0700292 ptr, mask, done, error);
293 }
294
295 return error;
296}
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298/* put TDI/ARC silicon into EHCI mode */
299static void tdi_reset (struct ehci_hcd *ehci)
300{
301 u32 __iomem *reg_ptr;
302 u32 tmp;
303
Vladimir Barinovd23a1372007-05-23 20:07:48 +0400304 reg_ptr = (u32 __iomem *)(((u8 __iomem *)ehci->regs) + USBMODE);
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100305 tmp = ehci_readl(ehci, reg_ptr);
Vladimir Barinovd23a1372007-05-23 20:07:48 +0400306 tmp |= USBMODE_CM_HC;
307 /* The default byte access to MMR space is LE after
308 * controller reset. Set the required endian mode
309 * for transfer buffers to match the host microprocessor
310 */
311 if (ehci_big_endian_mmio(ehci))
312 tmp |= USBMODE_BE;
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100313 ehci_writel(ehci, tmp, reg_ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314}
315
316/* reset a non-running (STS_HALT == 1) controller */
317static int ehci_reset (struct ehci_hcd *ehci)
318{
319 int retval;
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100320 u32 command = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Jason Wessel8d053c72009-08-20 15:39:54 -0500322 /* If the EHCI debug controller is active, special care must be
323 * taken before and after a host controller reset */
324 if (ehci->debug && !dbgp_reset_prep())
325 ehci->debug = NULL;
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 command |= CMD_RESET;
328 dbg_cmd (ehci, "reset", command);
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100329 ehci_writel(ehci, command, &ehci->regs->command);
Alan Sterne8799902011-08-18 16:31:30 -0400330 ehci->rh_state = EHCI_RH_HALTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 ehci->next_statechange = jiffies;
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100332 retval = handshake (ehci, &ehci->regs->command,
333 CMD_RESET, 0, 250 * 1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Alek Du331ac6b2009-07-13 12:41:20 +0800335 if (ehci->has_hostpc) {
336 ehci_writel(ehci, USBMODE_EX_HC | USBMODE_EX_VBPS,
337 (u32 __iomem *)(((u8 *)ehci->regs) + USBMODE_EX));
338 ehci_writel(ehci, TXFIFO_DEFAULT,
339 (u32 __iomem *)(((u8 *)ehci->regs) + TXFILLTUNING));
340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 if (retval)
342 return retval;
343
344 if (ehci_is_TDI(ehci))
345 tdi_reset (ehci);
346
Jason Wessel8d053c72009-08-20 15:39:54 -0500347 if (ehci->debug)
348 dbgp_external_startup();
349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return retval;
351}
352
353/* idle the controller (from running) */
354static void ehci_quiesce (struct ehci_hcd *ehci)
355{
356 u32 temp;
357
358#ifdef DEBUG
Alan Sterne8799902011-08-18 16:31:30 -0400359 if (ehci->rh_state != EHCI_RH_RUNNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 BUG ();
361#endif
362
363 /* wait for any schedule enables/disables to take effect */
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100364 temp = ehci_readl(ehci, &ehci->regs->command) << 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 temp &= STS_ASS | STS_PSS;
Karsten Wiesec765d4c2008-02-16 13:44:42 -0800366 if (handshake_on_error_set_halt(ehci, &ehci->regs->status,
367 STS_ASS | STS_PSS, temp, 16 * 125))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 /* then disable anything that's still active */
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100371 temp = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 temp &= ~(CMD_ASE | CMD_IAAD | CMD_PSE);
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100373 ehci_writel(ehci, temp, &ehci->regs->command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 /* hardware can take 16 microframes to turn off ... */
Karsten Wiesec765d4c2008-02-16 13:44:42 -0800376 handshake_on_error_set_halt(ehci, &ehci->regs->status,
377 STS_ASS | STS_PSS, 0, 16 * 125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378}
379
380/*-------------------------------------------------------------------------*/
381
Alan Stern07d29b62007-12-11 16:05:30 -0500382static void end_unlink_async(struct ehci_hcd *ehci);
David Howells7d12e782006-10-05 14:55:46 +0100383static void ehci_work(struct ehci_hcd *ehci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385#include "ehci-hub.c"
Alek Du48f24972010-06-04 15:47:55 +0800386#include "ehci-lpm.c"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387#include "ehci-mem.c"
388#include "ehci-q.c"
389#include "ehci-sched.c"
Kirill Smelkov4c670452011-07-03 20:36:56 +0400390#include "ehci-sysfs.c"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392/*-------------------------------------------------------------------------*/
393
Alan Stern07d29b62007-12-11 16:05:30 -0500394static void ehci_iaa_watchdog(unsigned long param)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
396 struct ehci_hcd *ehci = (struct ehci_hcd *) param;
397 unsigned long flags;
398
399 spin_lock_irqsave (&ehci->lock, flags);
400
David Brownelle82cc122008-03-07 13:49:42 -0800401 /* Lost IAA irqs wedge things badly; seen first with a vt8235.
402 * So we need this watchdog, but must protect it against both
403 * (a) SMP races against real IAA firing and retriggering, and
404 * (b) clean HC shutdown, when IAA watchdog was pending.
405 */
406 if (ehci->reclaim
407 && !timer_pending(&ehci->iaa_watchdog)
Alan Sterne8799902011-08-18 16:31:30 -0400408 && ehci->rh_state == EHCI_RH_RUNNING) {
David Brownelle82cc122008-03-07 13:49:42 -0800409 u32 cmd, status;
Alan Stern07d29b62007-12-11 16:05:30 -0500410
David Brownelle82cc122008-03-07 13:49:42 -0800411 /* If we get here, IAA is *REALLY* late. It's barely
412 * conceivable that the system is so busy that CMD_IAAD
413 * is still legitimately set, so let's be sure it's
414 * clear before we read STS_IAA. (The HC should clear
415 * CMD_IAAD when it sets STS_IAA.)
416 */
417 cmd = ehci_readl(ehci, &ehci->regs->command);
418 if (cmd & CMD_IAAD)
419 ehci_writel(ehci, cmd & ~CMD_IAAD,
420 &ehci->regs->command);
421
422 /* If IAA is set here it either legitimately triggered
423 * before we cleared IAAD above (but _way_ late, so we'll
424 * still count it as lost) ... or a silicon erratum:
425 * - VIA seems to set IAA without triggering the IRQ;
426 * - IAAD potentially cleared without setting IAA.
427 */
428 status = ehci_readl(ehci, &ehci->regs->status);
429 if ((status & STS_IAA) || !(cmd & CMD_IAAD)) {
Greg Kroah-Hartman64f89792006-10-17 13:57:18 -0700430 COUNT (ehci->stats.lost_iaa);
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100431 ehci_writel(ehci, STS_IAA, &ehci->regs->status);
Greg Kroah-Hartman64f89792006-10-17 13:57:18 -0700432 }
David Brownelle82cc122008-03-07 13:49:42 -0800433
434 ehci_vdbg(ehci, "IAA watchdog: status %x cmd %x\n",
435 status, cmd);
Alan Stern07d29b62007-12-11 16:05:30 -0500436 end_unlink_async(ehci);
Greg Kroah-Hartman64f89792006-10-17 13:57:18 -0700437 }
438
Alan Stern07d29b62007-12-11 16:05:30 -0500439 spin_unlock_irqrestore(&ehci->lock, flags);
440}
441
442static void ehci_watchdog(unsigned long param)
443{
444 struct ehci_hcd *ehci = (struct ehci_hcd *) param;
445 unsigned long flags;
446
447 spin_lock_irqsave(&ehci->lock, flags);
448
449 /* stop async processing after it's idled a bit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 if (test_bit (TIMER_ASYNC_OFF, &ehci->actions))
David Brownell26f953f2006-09-18 17:03:16 -0700451 start_unlink_async (ehci, ehci->async);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 /* ehci could run by timer, without IRQs ... */
David Howells7d12e782006-10-05 14:55:46 +0100454 ehci_work (ehci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 spin_unlock_irqrestore (&ehci->lock, flags);
457}
458
Alan Stern89037952007-02-13 14:55:27 -0500459/* On some systems, leaving remote wakeup enabled prevents system shutdown.
460 * The firmware seems to think that powering off is a wakeup event!
461 * This routine turns off remote wakeup and everything else, on all ports.
462 */
463static void ehci_turn_off_all_ports(struct ehci_hcd *ehci)
464{
465 int port = HCS_N_PORTS(ehci->hcs_params);
466
467 while (port--)
468 ehci_writel(ehci, PORT_RWC_BITS,
469 &ehci->regs->port_status[port]);
470}
471
Sarah Sharp21da84a2008-04-08 14:30:18 -0700472/*
473 * Halt HC, turn off all ports, and let the BIOS use the companion controllers.
474 * Should be called with ehci->lock held.
David Brownell72f30b62005-09-27 10:19:39 -0700475 */
Sarah Sharp21da84a2008-04-08 14:30:18 -0700476static void ehci_silence_controller(struct ehci_hcd *ehci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
Sarah Sharp21da84a2008-04-08 14:30:18 -0700478 ehci_halt(ehci);
Alan Stern89037952007-02-13 14:55:27 -0500479 ehci_turn_off_all_ports(ehci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
481 /* make BIOS/etc use companion controller during reboot */
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100482 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
Alan Stern89037952007-02-13 14:55:27 -0500483
484 /* unblock posted writes */
485 ehci_readl(ehci, &ehci->regs->configured_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486}
487
Sarah Sharp21da84a2008-04-08 14:30:18 -0700488/* ehci_shutdown kick in for silicon on any bus (not just pci, etc).
489 * This forcibly disables dma and IRQs, helping kexec and other cases
490 * where the next system software may expect clean state.
491 */
492static void ehci_shutdown(struct usb_hcd *hcd)
493{
494 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
495
496 del_timer_sync(&ehci->watchdog);
497 del_timer_sync(&ehci->iaa_watchdog);
498
499 spin_lock_irq(&ehci->lock);
500 ehci_silence_controller(ehci);
501 spin_unlock_irq(&ehci->lock);
502}
503
David Brownell56c1e262005-04-09 09:00:29 -0700504static void ehci_port_power (struct ehci_hcd *ehci, int is_on)
505{
506 unsigned port;
507
508 if (!HCS_PPC (ehci->hcs_params))
509 return;
510
511 ehci_dbg (ehci, "...power%s ports...\n", is_on ? "up" : "down");
512 for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; )
513 (void) ehci_hub_control(ehci_to_hcd(ehci),
514 is_on ? SetPortFeature : ClearPortFeature,
515 USB_PORT_FEAT_POWER,
516 port--, NULL, 0);
Alan Stern383975d2007-05-04 11:52:40 -0400517 /* Flush those writes */
518 ehci_readl(ehci, &ehci->regs->command);
David Brownell56c1e262005-04-09 09:00:29 -0700519 msleep(20);
520}
521
Matt Porter7ff71d62005-09-22 22:31:15 -0700522/*-------------------------------------------------------------------------*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Matt Porter7ff71d62005-09-22 22:31:15 -0700524/*
525 * ehci_work is called from some interrupts, timers, and so on.
526 * it calls driver completion functions, after dropping ehci->lock.
527 */
David Howells7d12e782006-10-05 14:55:46 +0100528static void ehci_work (struct ehci_hcd *ehci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
Matt Porter7ff71d62005-09-22 22:31:15 -0700530 timer_action_done (ehci, TIMER_IO_WATCHDOG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Matt Porter7ff71d62005-09-22 22:31:15 -0700532 /* another CPU may drop ehci->lock during a schedule scan while
533 * it reports urb completions. this flag guards against bogus
534 * attempts at re-entrant schedule scanning.
535 */
536 if (ehci->scanning)
537 return;
538 ehci->scanning = 1;
David Howells7d12e782006-10-05 14:55:46 +0100539 scan_async (ehci);
Matt Porter7ff71d62005-09-22 22:31:15 -0700540 if (ehci->next_uframe != -1)
David Howells7d12e782006-10-05 14:55:46 +0100541 scan_periodic (ehci);
Matt Porter7ff71d62005-09-22 22:31:15 -0700542 ehci->scanning = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Matt Porter7ff71d62005-09-22 22:31:15 -0700544 /* the IO watchdog guards against hardware or driver bugs that
545 * misplace IRQs, and should let us run completely without IRQs.
546 * such lossage has been observed on both VT6202 and VT8235.
547 */
Alan Sterne8799902011-08-18 16:31:30 -0400548 if (ehci->rh_state == EHCI_RH_RUNNING &&
Matt Porter7ff71d62005-09-22 22:31:15 -0700549 (ehci->async->qh_next.ptr != NULL ||
550 ehci->periodic_sched != 0))
551 timer_action (ehci, TIMER_IO_WATCHDOG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552}
553
Sarah Sharp21da84a2008-04-08 14:30:18 -0700554/*
555 * Called when the ehci_hcd module is removed.
556 */
Matt Porter7ff71d62005-09-22 22:31:15 -0700557static void ehci_stop (struct usb_hcd *hcd)
558{
559 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
560
561 ehci_dbg (ehci, "stop\n");
562
Matt Porter7ff71d62005-09-22 22:31:15 -0700563 /* no more interrupts ... */
564 del_timer_sync (&ehci->watchdog);
Alan Stern07d29b62007-12-11 16:05:30 -0500565 del_timer_sync(&ehci->iaa_watchdog);
Matt Porter7ff71d62005-09-22 22:31:15 -0700566
567 spin_lock_irq(&ehci->lock);
Alan Sterne8799902011-08-18 16:31:30 -0400568 if (ehci->rh_state == EHCI_RH_RUNNING)
Matt Porter7ff71d62005-09-22 22:31:15 -0700569 ehci_quiesce (ehci);
570
Sarah Sharp21da84a2008-04-08 14:30:18 -0700571 ehci_silence_controller(ehci);
Matt Porter7ff71d62005-09-22 22:31:15 -0700572 ehci_reset (ehci);
Matt Porter7ff71d62005-09-22 22:31:15 -0700573 spin_unlock_irq(&ehci->lock);
574
Kirill Smelkov4c670452011-07-03 20:36:56 +0400575 remove_sysfs_files(ehci);
Matt Porter7ff71d62005-09-22 22:31:15 -0700576 remove_debug_files (ehci);
577
578 /* root hub is shut down separately (first, when possible) */
579 spin_lock_irq (&ehci->lock);
580 if (ehci->async)
David Howells7d12e782006-10-05 14:55:46 +0100581 ehci_work (ehci);
Matt Porter7ff71d62005-09-22 22:31:15 -0700582 spin_unlock_irq (&ehci->lock);
583 ehci_mem_cleanup (ehci);
584
Andiry Xuad935622011-03-01 14:57:05 +0800585 if (ehci->amd_pll_fix == 1)
586 usb_amd_dev_put();
Alex He05570292010-12-07 10:10:08 +0800587
Matt Porter7ff71d62005-09-22 22:31:15 -0700588#ifdef EHCI_STATS
589 ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
590 ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
591 ehci->stats.lost_iaa);
592 ehci_dbg (ehci, "complete %ld unlink %ld\n",
593 ehci->stats.complete, ehci->stats.unlink);
594#endif
595
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100596 dbg_status (ehci, "ehci_stop completed",
597 ehci_readl(ehci, &ehci->regs->status));
Matt Porter7ff71d62005-09-22 22:31:15 -0700598}
599
David Brownell18807522005-11-23 15:45:37 -0800600/* one-time init, only for memory state */
601static int ehci_init(struct usb_hcd *hcd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
David Brownell18807522005-11-23 15:45:37 -0800603 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 u32 temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 int retval;
606 u32 hcc_params;
Alek Du3807e262009-07-14 07:23:29 +0800607 struct ehci_qh_hw *hw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
David Brownell18807522005-11-23 15:45:37 -0800609 spin_lock_init(&ehci->lock);
610
Alek Du403dbd32009-07-13 17:30:41 +0800611 /*
612 * keep io watchdog by default, those good HCDs could turn off it later
613 */
614 ehci->need_io_watchdog = 1;
David Brownell18807522005-11-23 15:45:37 -0800615 init_timer(&ehci->watchdog);
616 ehci->watchdog.function = ehci_watchdog;
617 ehci->watchdog.data = (unsigned long) ehci;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Alan Stern07d29b62007-12-11 16:05:30 -0500619 init_timer(&ehci->iaa_watchdog);
620 ehci->iaa_watchdog.function = ehci_iaa_watchdog;
621 ehci->iaa_watchdog.data = (unsigned long) ehci;
622
Alan Sternf75593c2011-01-06 10:17:09 -0500623 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /*
Kirill Smelkovcc62a7e2011-07-03 20:36:57 +0400626 * by default set standard 80% (== 100 usec/uframe) max periodic
627 * bandwidth as required by USB 2.0
628 */
629 ehci->uframe_periodic_max = 100;
630
631 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 * hw default: 1K periodic list heads, one per frame.
633 * periodic_size can shrink by USBCMD update if hcc_params allows.
634 */
635 ehci->periodic_size = DEFAULT_I_TDPS;
Karsten Wiese9aa09d22009-02-08 16:07:58 -0800636 INIT_LIST_HEAD(&ehci->cached_itd_list);
Alan Stern0e5f2312010-04-08 16:56:37 -0400637 INIT_LIST_HEAD(&ehci->cached_sitd_list);
Alan Sternf75593c2011-01-06 10:17:09 -0500638
639 if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
640 /* periodic schedule size can be smaller than default */
641 switch (EHCI_TUNE_FLS) {
642 case 0: ehci->periodic_size = 1024; break;
643 case 1: ehci->periodic_size = 512; break;
644 case 2: ehci->periodic_size = 256; break;
645 default: BUG();
646 }
647 }
David Brownell18807522005-11-23 15:45:37 -0800648 if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 return retval;
650
651 /* controllers may cache some of the periodic schedule ... */
David Brownell53bd6a62006-08-30 14:50:06 -0700652 if (HCC_ISOC_CACHE(hcc_params)) // full frame cache
Sarah Sharpdccd5742009-10-27 10:55:05 -0700653 ehci->i_thresh = 2 + 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 else // N microframes cached
David Brownell18807522005-11-23 15:45:37 -0800655 ehci->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
657 ehci->reclaim = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 ehci->next_uframe = -1;
Karsten Wiese9aa09d22009-02-08 16:07:58 -0800659 ehci->clock_frame = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 /*
662 * dedicate a qh for the async ring head, since we couldn't unlink
663 * a 'real' qh without stopping the async schedule [4.8]. use it
664 * as the 'reclamation list head' too.
665 * its dummy is used in hw_alt_next of many tds, to prevent the qh
666 * from automatically advancing to the next td after short reads.
667 */
David Brownell18807522005-11-23 15:45:37 -0800668 ehci->async->qh_next.qh = NULL;
Alek Du3807e262009-07-14 07:23:29 +0800669 hw = ehci->async->hw;
670 hw->hw_next = QH_NEXT(ehci, ehci->async->qh_dma);
671 hw->hw_info1 = cpu_to_hc32(ehci, QH_HEAD);
Geoff Levandaaa0ef22011-11-08 16:01:18 -0800672 hw->hw_info1 |= cpu_to_hc32(ehci, (1 << 7)); /* I = 1 */
Alek Du3807e262009-07-14 07:23:29 +0800673 hw->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
674 hw->hw_qtd_next = EHCI_LIST_END(ehci);
David Brownell18807522005-11-23 15:45:37 -0800675 ehci->async->qh_state = QH_STATE_LINKED;
Alek Du3807e262009-07-14 07:23:29 +0800676 hw->hw_alt_next = QTD_NEXT(ehci, ehci->async->dummy->qtd_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 /* clear interrupt enables, set irq latency */
679 if (log2_irq_thresh < 0 || log2_irq_thresh > 6)
680 log2_irq_thresh = 0;
681 temp = 1 << (16 + log2_irq_thresh);
Alek Du5a9cdf32010-06-04 15:47:56 +0800682 if (HCC_PER_PORT_CHANGE_EVENT(hcc_params)) {
683 ehci->has_ppcd = 1;
684 ehci_dbg(ehci, "enable per-port change event\n");
685 temp |= CMD_PPCEE;
686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 if (HCC_CANPARK(hcc_params)) {
688 /* HW default park == 3, on hardware that supports it (like
689 * NVidia and ALI silicon), maximizes throughput on the async
690 * schedule by avoiding QH fetches between transfers.
691 *
692 * With fast usb storage devices and NForce2, "park" seems to
693 * make problems: throughput reduction (!), data errors...
694 */
695 if (park) {
David Brownell18807522005-11-23 15:45:37 -0800696 park = min(park, (unsigned) 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 temp |= CMD_PARK;
698 temp |= park << 8;
699 }
David Brownell18807522005-11-23 15:45:37 -0800700 ehci_dbg(ehci, "park %d\n", park);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 }
David Brownell18807522005-11-23 15:45:37 -0800702 if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 /* periodic schedule size can be smaller than default */
704 temp &= ~(3 << 2);
705 temp |= (EHCI_TUNE_FLS << 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 }
Alek Du48f24972010-06-04 15:47:55 +0800707 if (HCC_LPM(hcc_params)) {
708 /* support link power management EHCI 1.1 addendum */
709 ehci_dbg(ehci, "support lpm\n");
710 ehci->has_lpm = 1;
711 if (hird > 0xf) {
712 ehci_dbg(ehci, "hird %d invalid, use default 0",
713 hird);
714 hird = 0;
715 }
716 temp |= hird << 24;
717 }
David Brownell18807522005-11-23 15:45:37 -0800718 ehci->command = temp;
719
Alan Stern40f8db82009-11-06 12:29:40 -0500720 /* Accept arbitrarily long scatter-gather lists */
Andrea Righi4307a282010-06-28 16:56:45 +0200721 if (!(hcd->driver->flags & HCD_LOCAL_MEM))
722 hcd->self.sg_tablesize = ~0;
David Brownell18807522005-11-23 15:45:37 -0800723 return 0;
724}
725
726/* start HC running; it's halted, ehci_init() has been run (once) */
727static int ehci_run (struct usb_hcd *hcd)
728{
729 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
David Brownell18807522005-11-23 15:45:37 -0800730 u32 temp;
731 u32 hcc_params;
732
Marcelo Tosatti1d619f12007-01-21 19:45:59 -0200733 hcd->uses_new_polling = 1;
Marcelo Tosatti1d619f12007-01-21 19:45:59 -0200734
David Brownell18807522005-11-23 15:45:37 -0800735 /* EHCI spec section 4.1 */
Geoff Levand876e0df2011-11-22 18:04:45 -0800736
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100737 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
738 ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
David Brownell18807522005-11-23 15:45:37 -0800739
740 /*
741 * hcc_params controls whether ehci->regs->segment must (!!!)
742 * be used; it constrains QH/ITD/SITD and QTD locations.
743 * pci_pool consistent memory always uses segment zero.
744 * streaming mappings for I/O buffers, like pci_map_single(),
745 * can return segments above 4GB, if the device allows.
746 *
747 * NOTE: the dma mask is visible through dma_supported(), so
748 * drivers can pass this info along ... like NETIF_F_HIGHDMA,
749 * Scsi_Host.highmem_io, and so forth. It's readonly to all
750 * host side drivers though.
751 */
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100752 hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
David Brownell18807522005-11-23 15:45:37 -0800753 if (HCC_64BIT_ADDR(hcc_params)) {
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100754 ehci_writel(ehci, 0, &ehci->regs->segment);
David Brownell18807522005-11-23 15:45:37 -0800755#if 0
756// this is deeply broken on almost all architectures
Yang Hongyang6a355282009-04-06 19:01:13 -0700757 if (!dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64)))
David Brownell18807522005-11-23 15:45:37 -0800758 ehci_info(ehci, "enabled 64bit DMA\n");
759#endif
760 }
761
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 // Philips, Intel, and maybe others need CMD_RUN before the
764 // root hub will detect new devices (why?); NEC doesn't
David Brownell18807522005-11-23 15:45:37 -0800765 ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
766 ehci->command |= CMD_RUN;
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100767 ehci_writel(ehci, ehci->command, &ehci->regs->command);
David Brownell18807522005-11-23 15:45:37 -0800768 dbg_cmd (ehci, "init", ehci->command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 /*
771 * Start, enabling full USB 2.0 functionality ... usb 1.1 devices
772 * are explicitly handed to companion controller(s), so no TT is
773 * involved with the root hub. (Except where one is integrated,
774 * and there's no companion controller unless maybe for USB OTG.)
Alan Stern32fe0192007-10-10 16:27:07 -0400775 *
776 * Turning on the CF flag will transfer ownership of all ports
777 * from the companions to the EHCI controller. If any of the
778 * companions are in the middle of a port reset at the time, it
779 * could cause trouble. Write-locking ehci_cf_port_reset_rwsem
David Brownell1cb52652007-11-13 16:22:30 -0800780 * guarantees that no resets are in progress. After we set CF,
781 * a short delay lets the hardware catch up; new resets shouldn't
782 * be started before the port switching actions could complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 */
Alan Stern32fe0192007-10-10 16:27:07 -0400784 down_write(&ehci_cf_port_reset_rwsem);
Alan Sterne8799902011-08-18 16:31:30 -0400785 ehci->rh_state = EHCI_RH_RUNNING;
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100786 ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
787 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
David Brownell1cb52652007-11-13 16:22:30 -0800788 msleep(5);
Alan Stern32fe0192007-10-10 16:27:07 -0400789 up_write(&ehci_cf_port_reset_rwsem);
Oliver Neukumee4ecb82009-11-27 15:17:59 +0100790 ehci->last_periodic_enable = ktime_get_real();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Jan Anderssonc4301312011-05-03 20:11:57 +0200792 temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 ehci_info (ehci,
Alan Stern2b70f072008-10-02 11:47:15 -0400794 "USB %x.%x started, EHCI %x.%02x%s\n",
Matt Porter7ff71d62005-09-22 22:31:15 -0700795 ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
Alan Stern2b70f072008-10-02 11:47:15 -0400796 temp >> 8, temp & 0xff,
David Brownell93f1a472006-11-16 23:34:58 -0800797 ignore_oc ? ", overcurrent ignored" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100799 ehci_writel(ehci, INTR_MASK,
800 &ehci->regs->intr_enable); /* Turn On Interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
David Brownell18807522005-11-23 15:45:37 -0800802 /* GRR this is run-once init(), being done every time the HC starts.
803 * So long as they're part of class devices, we can't do it init()
804 * since the class device isn't created that early.
805 */
806 create_debug_files(ehci);
Kirill Smelkov4c670452011-07-03 20:36:56 +0400807 create_sysfs_files(ehci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
809 return 0;
810}
811
Matthieu CASTET2093c6b2011-07-02 19:47:33 +0200812static int __maybe_unused ehci_setup (struct usb_hcd *hcd)
813{
814 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
815 int retval;
816
817 ehci->regs = (void __iomem *)ehci->caps +
818 HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
819 dbg_hcs_params(ehci, "reset");
820 dbg_hcc_params(ehci, "reset");
821
822 /* cache this readonly data; minimize chip reads */
823 ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
824
825 ehci->sbrn = HCD_USB2;
826
827 retval = ehci_halt(ehci);
828 if (retval)
829 return retval;
830
831 /* data structure init */
832 retval = ehci_init(hcd);
833 if (retval)
834 return retval;
835
836 ehci_reset(ehci);
837
838 return 0;
839}
840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841/*-------------------------------------------------------------------------*/
842
David Howells7d12e782006-10-05 14:55:46 +0100843static irqreturn_t ehci_irq (struct usb_hcd *hcd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844{
845 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
Alan Stern67b2e022008-11-12 17:04:53 -0500846 u32 status, masked_status, pcd_status = 0, cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 int bh;
848
849 spin_lock (&ehci->lock);
850
Benjamin Herrenschmidt083522d2006-12-15 06:54:08 +1100851 status = ehci_readl(ehci, &ehci->regs->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853 /* e.g. cardbus physical eject */
854 if (status == ~(u32) 0) {
855 ehci_dbg (ehci, "device removed\n");
856 goto dead;
857 }
858
Alan Stern69fff592011-05-17 17:27:12 -0400859 /* Shared IRQ? */
Alan Stern67b2e022008-11-12 17:04:53 -0500860 masked_status = status & INTR_MASK;
Alan Sterne8799902011-08-18 16:31:30 -0400861 if (!masked_status || unlikely(ehci->rh_state == EHCI_RH_HALTED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 spin_unlock(&ehci->lock);
863 return IRQ_NONE;
864 }
865
866 /* clear (just) interrupts */
Alan Stern67b2e022008-11-12 17:04:53 -0500867 ehci_writel(ehci, masked_status, &ehci->regs->status);
David Brownelle82cc122008-03-07 13:49:42 -0800868 cmd = ehci_readl(ehci, &ehci->regs->command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 bh = 0;
870
David Brownell9776afc2008-02-01 11:42:05 -0800871#ifdef VERBOSE_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 /* unrequested/ignored: Frame List Rollover */
873 dbg_status (ehci, "irq", status);
874#endif
875
876 /* INT, ERR, and IAA interrupt rates can be throttled */
877
878 /* normal [4.15.1.2] or error [4.15.1.1] completion */
879 if (likely ((status & (STS_INT|STS_ERR)) != 0)) {
880 if (likely ((status & STS_ERR) == 0))
881 COUNT (ehci->stats.normal);
882 else
883 COUNT (ehci->stats.error);
884 bh = 1;
885 }
886
887 /* complete the unlinking of some qh [4.15.2.3] */
888 if (status & STS_IAA) {
David Brownelle82cc122008-03-07 13:49:42 -0800889 /* guard against (alleged) silicon errata */
890 if (cmd & CMD_IAAD) {
891 ehci_writel(ehci, cmd & ~CMD_IAAD,
892 &ehci->regs->command);
893 ehci_dbg(ehci, "IAA with IAAD still set?\n");
894 }
895 if (ehci->reclaim) {
896 COUNT(ehci->stats.reclaim);
897 end_unlink_async(ehci);
898 } else
899 ehci_dbg(ehci, "IAA with nothing to reclaim?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 }
901
902 /* remote wakeup [4.3.1] */
David Brownelld97cc2f2005-12-22 17:05:18 -0800903 if (status & STS_PCD) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 unsigned i = HCS_N_PORTS (ehci->hcs_params);
Alek Du5a9cdf32010-06-04 15:47:56 +0800905 u32 ppcd = 0;
David Brownelld1b18422008-03-05 23:37:52 -0800906
907 /* kick root hub later */
Marcelo Tosatti1d619f12007-01-21 19:45:59 -0200908 pcd_status = status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
910 /* resume root hub? */
Alan Sterneafe5b92008-10-06 11:25:53 -0400911 if (!(cmd & CMD_RUN))
Alan Stern8c033562006-11-09 14:42:16 -0500912 usb_hcd_resume_root_hub(hcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Alek Du5a9cdf32010-06-04 15:47:56 +0800914 /* get per-port change detect bits */
915 if (ehci->has_ppcd)
916 ppcd = status >> 16;
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 while (i--) {
Alek Du5a9cdf32010-06-04 15:47:56 +0800919 int pstatus;
920
921 /* leverage per-port change bits feature */
922 if (ehci->has_ppcd && !(ppcd & (1 << i)))
923 continue;
924 pstatus = ehci_readl(ehci,
925 &ehci->regs->port_status[i]);
David Brownellb972b682006-06-30 02:34:42 -0700926
927 if (pstatus & PORT_OWNER)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 continue;
Alan Sterneafe5b92008-10-06 11:25:53 -0400929 if (!(test_bit(i, &ehci->suspended_ports) &&
930 ((pstatus & PORT_RESUME) ||
931 !(pstatus & PORT_SUSPEND)) &&
932 (pstatus & PORT_PE) &&
933 ehci->reset_done[i] == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 continue;
935
936 /* start 20 msec resume signaling from this port,
937 * and make khubd collect PORT_STAT_C_SUSPEND to
Alan Stern49d0f072010-01-08 11:18:38 -0500938 * stop that signaling. Use 5 ms extra for safety,
939 * like usb_port_resume() does.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 */
Alan Stern49d0f072010-01-08 11:18:38 -0500941 ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
Alan Stern61e8b852007-04-09 11:52:31 -0400943 mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 }
945 }
946
947 /* PCI errors [4.15.2.4] */
948 if (unlikely ((status & STS_FATAL) != 0)) {
Alan Stern67b2e022008-11-12 17:04:53 -0500949 ehci_err(ehci, "fatal error\n");
Alan Sterneafe5b92008-10-06 11:25:53 -0400950 dbg_cmd(ehci, "fatal", cmd);
951 dbg_status(ehci, "fatal", status);
Alan Stern67b2e022008-11-12 17:04:53 -0500952 ehci_halt(ehci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953dead:
Alan Stern67b2e022008-11-12 17:04:53 -0500954 ehci_reset(ehci);
955 ehci_writel(ehci, 0, &ehci->regs->configured_flag);
Alan Stern69fff592011-05-17 17:27:12 -0400956 usb_hc_died(hcd);
Alan Stern67b2e022008-11-12 17:04:53 -0500957 /* generic layer kills/unlinks all urbs, then
958 * uses ehci_stop to clean up the rest
959 */
960 bh = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 }
962
963 if (bh)
David Howells7d12e782006-10-05 14:55:46 +0100964 ehci_work (ehci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 spin_unlock (&ehci->lock);
David Brownelld1b18422008-03-05 23:37:52 -0800966 if (pcd_status)
Marcelo Tosatti1d619f12007-01-21 19:45:59 -0200967 usb_hcd_poll_rh_status(hcd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 return IRQ_HANDLED;
969}
970
971/*-------------------------------------------------------------------------*/
972
973/*
974 * non-error returns are a promise to giveback() the urb later
975 * we drop ownership so next owner (or urb unlink) can get it
976 *
977 * urb + dev is in hcd.self.controller.urb_list
978 * we're queueing TDs onto software and hardware lists
979 *
980 * hcd-specific init for hcpriv hasn't been done yet
981 *
982 * NOTE: control, bulk, and interrupt share the same code to append TDs
983 * to a (possibly active) QH, and the same QH scanning code.
984 */
985static int ehci_urb_enqueue (
986 struct usb_hcd *hcd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 struct urb *urb,
Al Viro55016f12005-10-21 03:21:58 -0400988 gfp_t mem_flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989) {
990 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
991 struct list_head qtd_list;
992
993 INIT_LIST_HEAD (&qtd_list);
994
995 switch (usb_pipetype (urb->pipe)) {
David Brownell25b70a82008-03-04 15:11:07 -0800996 case PIPE_CONTROL:
997 /* qh_completions() code doesn't handle all the fault cases
998 * in multi-TD control transfers. Even 1KB is rare anyway.
999 */
1000 if (urb->transfer_buffer_length > (16 * 1024))
1001 return -EMSGSIZE;
1002 /* FALLTHROUGH */
1003 /* case PIPE_BULK: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 default:
1005 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
1006 return -ENOMEM;
Alan Sterne9df41c2007-08-08 11:48:02 -04001007 return submit_async(ehci, urb, &qtd_list, mem_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
1009 case PIPE_INTERRUPT:
1010 if (!qh_urb_transaction (ehci, urb, &qtd_list, mem_flags))
1011 return -ENOMEM;
Alan Sterne9df41c2007-08-08 11:48:02 -04001012 return intr_submit(ehci, urb, &qtd_list, mem_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
1014 case PIPE_ISOCHRONOUS:
1015 if (urb->dev->speed == USB_SPEED_HIGH)
1016 return itd_submit (ehci, urb, mem_flags);
1017 else
1018 return sitd_submit (ehci, urb, mem_flags);
1019 }
1020}
1021
1022static void unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
1023{
Alan Stern07d29b62007-12-11 16:05:30 -05001024 /* failfast */
Alan Sterne8799902011-08-18 16:31:30 -04001025 if (ehci->rh_state != EHCI_RH_RUNNING && ehci->reclaim)
Alan Stern07d29b62007-12-11 16:05:30 -05001026 end_unlink_async(ehci);
1027
Alan Stern3a444942009-08-19 12:22:06 -04001028 /* If the QH isn't linked then there's nothing we can do
1029 * unless we were called during a giveback, in which case
1030 * qh_completions() has to deal with it.
1031 */
1032 if (qh->qh_state != QH_STATE_LINKED) {
1033 if (qh->qh_state == QH_STATE_COMPLETING)
1034 qh->needs_rescan = 1;
1035 return;
1036 }
Alan Stern07d29b62007-12-11 16:05:30 -05001037
1038 /* defer till later if busy */
Alan Stern3a444942009-08-19 12:22:06 -04001039 if (ehci->reclaim) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 struct ehci_qh *last;
1041
1042 for (last = ehci->reclaim;
1043 last->reclaim;
1044 last = last->reclaim)
1045 continue;
1046 qh->qh_state = QH_STATE_UNLINK_WAIT;
1047 last->reclaim = qh;
1048
Alan Stern07d29b62007-12-11 16:05:30 -05001049 /* start IAA cycle */
1050 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 start_unlink_async (ehci, qh);
1052}
1053
1054/* remove from hardware lists
1055 * completions normally happen asynchronously
1056 */
1057
Alan Sterne9df41c2007-08-08 11:48:02 -04001058static int ehci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059{
1060 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1061 struct ehci_qh *qh;
1062 unsigned long flags;
Alan Sterne9df41c2007-08-08 11:48:02 -04001063 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
1065 spin_lock_irqsave (&ehci->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001066 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1067 if (rc)
1068 goto done;
1069
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 switch (usb_pipetype (urb->pipe)) {
1071 // case PIPE_CONTROL:
1072 // case PIPE_BULK:
1073 default:
1074 qh = (struct ehci_qh *) urb->hcpriv;
1075 if (!qh)
1076 break;
Alan Stern07d29b62007-12-11 16:05:30 -05001077 switch (qh->qh_state) {
1078 case QH_STATE_LINKED:
1079 case QH_STATE_COMPLETING:
1080 unlink_async(ehci, qh);
1081 break;
1082 case QH_STATE_UNLINK:
1083 case QH_STATE_UNLINK_WAIT:
1084 /* already started */
1085 break;
1086 case QH_STATE_IDLE:
Alan Stern7a0f0d92009-07-31 10:40:22 -04001087 /* QH might be waiting for a Clear-TT-Buffer */
1088 qh_completions(ehci, qh);
Alan Stern07d29b62007-12-11 16:05:30 -05001089 break;
1090 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 break;
1092
1093 case PIPE_INTERRUPT:
1094 qh = (struct ehci_qh *) urb->hcpriv;
1095 if (!qh)
1096 break;
1097 switch (qh->qh_state) {
1098 case QH_STATE_LINKED:
Alan Sterna448c9d2009-08-19 12:22:44 -04001099 case QH_STATE_COMPLETING:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 intr_deschedule (ehci, qh);
Alan Sterna448c9d2009-08-19 12:22:44 -04001101 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 case QH_STATE_IDLE:
David Howells7d12e782006-10-05 14:55:46 +01001103 qh_completions (ehci, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 break;
1105 default:
1106 ehci_dbg (ehci, "bogus qh %p state %d\n",
1107 qh, qh->qh_state);
1108 goto done;
1109 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 break;
1111
1112 case PIPE_ISOCHRONOUS:
1113 // itd or sitd ...
1114
1115 // wait till next completion, do it then.
1116 // completion irqs can wait up to 1024 msec,
1117 break;
1118 }
1119done:
1120 spin_unlock_irqrestore (&ehci->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001121 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122}
1123
1124/*-------------------------------------------------------------------------*/
1125
1126// bulk qh holds the data toggle
1127
1128static void
1129ehci_endpoint_disable (struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1130{
1131 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
1132 unsigned long flags;
1133 struct ehci_qh *qh, *tmp;
1134
1135 /* ASSERT: any requests/urbs are being unlinked */
1136 /* ASSERT: nobody can be submitting urbs for this any more */
1137
1138rescan:
1139 spin_lock_irqsave (&ehci->lock, flags);
1140 qh = ep->hcpriv;
1141 if (!qh)
1142 goto done;
1143
1144 /* endpoints can be iso streams. for now, we don't
1145 * accelerate iso completions ... so spin a while.
1146 */
Clemens Ladisch1082f572010-03-01 17:18:56 +01001147 if (qh->hw == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 ehci_vdbg (ehci, "iso delay\n");
1149 goto idle_timeout;
1150 }
1151
Alan Sterne8799902011-08-18 16:31:30 -04001152 if (ehci->rh_state != EHCI_RH_RUNNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 qh->qh_state = QH_STATE_IDLE;
1154 switch (qh->qh_state) {
1155 case QH_STATE_LINKED:
Alan Stern3a444942009-08-19 12:22:06 -04001156 case QH_STATE_COMPLETING:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 for (tmp = ehci->async->qh_next.qh;
1158 tmp && tmp != qh;
1159 tmp = tmp->qh_next.qh)
1160 continue;
Alan Stern02e2c512010-11-16 10:57:37 -05001161 /* periodic qh self-unlinks on empty, and a COMPLETING qh
1162 * may already be unlinked.
1163 */
1164 if (tmp)
1165 unlink_async(ehci, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 /* FALL THROUGH */
1167 case QH_STATE_UNLINK: /* wait for hw to finish? */
Alan Stern07d29b62007-12-11 16:05:30 -05001168 case QH_STATE_UNLINK_WAIT:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169idle_timeout:
1170 spin_unlock_irqrestore (&ehci->lock, flags);
Nishanth Aravamudan22c43862005-08-15 11:30:11 -07001171 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 goto rescan;
1173 case QH_STATE_IDLE: /* fully unlinked */
Alan Stern914b7012009-06-29 10:47:30 -04001174 if (qh->clearing_tt)
1175 goto idle_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 if (list_empty (&qh->qtd_list)) {
1177 qh_put (qh);
1178 break;
1179 }
1180 /* else FALL THROUGH */
1181 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 /* caller was supposed to have unlinked any requests;
1183 * that's not our job. just leak this memory.
1184 */
1185 ehci_err (ehci, "qh %p (#%02x) state %d%s\n",
1186 qh, ep->desc.bEndpointAddress, qh->qh_state,
1187 list_empty (&qh->qtd_list) ? "" : "(has tds)");
1188 break;
1189 }
1190 ep->hcpriv = NULL;
1191done:
1192 spin_unlock_irqrestore (&ehci->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193}
1194
Alan Sternb18ffd42009-05-27 18:21:56 -04001195static void
1196ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1197{
1198 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1199 struct ehci_qh *qh;
1200 int eptype = usb_endpoint_type(&ep->desc);
Alan Sterna455212d2009-06-11 14:56:22 -04001201 int epnum = usb_endpoint_num(&ep->desc);
1202 int is_out = usb_endpoint_dir_out(&ep->desc);
1203 unsigned long flags;
Alan Sternb18ffd42009-05-27 18:21:56 -04001204
1205 if (eptype != USB_ENDPOINT_XFER_BULK && eptype != USB_ENDPOINT_XFER_INT)
1206 return;
1207
Alan Sterna455212d2009-06-11 14:56:22 -04001208 spin_lock_irqsave(&ehci->lock, flags);
Alan Sternb18ffd42009-05-27 18:21:56 -04001209 qh = ep->hcpriv;
1210
1211 /* For Bulk and Interrupt endpoints we maintain the toggle state
1212 * in the hardware; the toggle bits in udev aren't used at all.
1213 * When an endpoint is reset by usb_clear_halt() we must reset
1214 * the toggle bit in the QH.
1215 */
1216 if (qh) {
Alan Sterna455212d2009-06-11 14:56:22 -04001217 usb_settoggle(qh->dev, epnum, is_out, 0);
Alan Sternb18ffd42009-05-27 18:21:56 -04001218 if (!list_empty(&qh->qtd_list)) {
1219 WARN_ONCE(1, "clear_halt for a busy endpoint\n");
Alan Stern3a444942009-08-19 12:22:06 -04001220 } else if (qh->qh_state == QH_STATE_LINKED ||
1221 qh->qh_state == QH_STATE_COMPLETING) {
Alan Sterna455212d2009-06-11 14:56:22 -04001222
1223 /* The toggle value in the QH can't be updated
1224 * while the QH is active. Unlink it now;
1225 * re-linking will call qh_refresh().
Alan Sternb18ffd42009-05-27 18:21:56 -04001226 */
Alan Sterna448c9d2009-08-19 12:22:44 -04001227 if (eptype == USB_ENDPOINT_XFER_BULK)
Alan Sterna455212d2009-06-11 14:56:22 -04001228 unlink_async(ehci, qh);
Alan Sterna448c9d2009-08-19 12:22:44 -04001229 else
Alan Sterna455212d2009-06-11 14:56:22 -04001230 intr_deschedule(ehci, qh);
Alan Sternb18ffd42009-05-27 18:21:56 -04001231 }
1232 }
Alan Sterna455212d2009-06-11 14:56:22 -04001233 spin_unlock_irqrestore(&ehci->lock, flags);
Alan Sternb18ffd42009-05-27 18:21:56 -04001234}
1235
Matt Porter7ff71d62005-09-22 22:31:15 -07001236static int ehci_get_frame (struct usb_hcd *hcd)
1237{
1238 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
Alan Stern68aa95d2011-10-12 10:39:14 -04001239 return (ehci_read_frame_index(ehci) >> 3) % ehci->periodic_size;
Matt Porter7ff71d62005-09-22 22:31:15 -07001240}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
1242/*-------------------------------------------------------------------------*/
1243
Alan Stern2b70f072008-10-02 11:47:15 -04001244MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245MODULE_AUTHOR (DRIVER_AUTHOR);
1246MODULE_LICENSE ("GPL");
1247
Matt Porter7ff71d62005-09-22 22:31:15 -07001248#ifdef CONFIG_PCI
1249#include "ehci-pci.c"
Kumar Gala01cced22006-04-11 10:07:16 -05001250#define PCI_DRIVER ehci_pci_driver
Matt Porter7ff71d62005-09-22 22:31:15 -07001251#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252
Li Yangba029782007-05-11 17:09:55 +08001253#ifdef CONFIG_USB_EHCI_FSL
Randy Vinson80cb9ae2006-01-20 13:53:38 -08001254#include "ehci-fsl.c"
Kumar Gala01cced22006-04-11 10:07:16 -05001255#define PLATFORM_DRIVER ehci_fsl_driver
Randy Vinson80cb9ae2006-01-20 13:53:38 -08001256#endif
1257
Daniel Mack7e8d5cd2009-10-28 01:14:59 +01001258#ifdef CONFIG_USB_EHCI_MXC
1259#include "ehci-mxc.c"
1260#define PLATFORM_DRIVER ehci_mxc_driver
1261#endif
1262
Yoshihiro Shimoda60b0bf02011-03-01 16:58:37 +09001263#ifdef CONFIG_USB_EHCI_SH
Paul Mundt63c84552010-11-01 17:03:27 -04001264#include "ehci-sh.c"
1265#define PLATFORM_DRIVER ehci_hcd_sh_driver
1266#endif
1267
Manuel Lauss3766386032011-08-12 11:39:45 +02001268#ifdef CONFIG_MIPS_ALCHEMY
Jordan Crouse76fa9a22006-01-20 14:06:09 -08001269#include "ehci-au1xxx.c"
Kumar Gala01cced22006-04-11 10:07:16 -05001270#define PLATFORM_DRIVER ehci_hcd_au1xxx_driver
Jordan Crouse76fa9a22006-01-20 14:06:09 -08001271#endif
1272
Keshava Munegowda7f124f42010-11-21 23:23:41 +05301273#ifdef CONFIG_USB_EHCI_HCD_OMAP
Felipe Balbi54ab2b02009-10-14 11:44:14 +03001274#include "ehci-omap.c"
1275#define PLATFORM_DRIVER ehci_hcd_omap_driver
1276#endif
1277
Geoff Levandad75a412007-01-15 20:11:47 -08001278#ifdef CONFIG_PPC_PS3
1279#include "ehci-ps3.c"
Geoff Levand7a4eb7f2007-06-05 20:04:35 -07001280#define PS3_SYSTEM_BUS_DRIVER ps3_ehci_driver
Geoff Levandad75a412007-01-15 20:11:47 -08001281#endif
1282
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001283#ifdef CONFIG_USB_EHCI_HCD_PPC_OF
1284#include "ehci-ppc-of.c"
1285#define OF_PLATFORM_DRIVER ehci_hcd_ppc_of_driver
1286#endif
1287
Julie Zhu08d3c182009-09-21 16:08:19 -06001288#ifdef CONFIG_XPS_USB_HCD_XILINX
1289#include "ehci-xilinx-of.c"
Grant Likely1f23b2d2010-06-02 13:53:17 -06001290#define XILINX_OF_PLATFORM_DRIVER ehci_hcd_xilinx_of_driver
Julie Zhu08d3c182009-09-21 16:08:19 -06001291#endif
1292
Lennert Buytenhek705a7522008-03-27 14:51:40 -04001293#ifdef CONFIG_PLAT_ORION
Tzachi Perelsteine96ffe22007-12-01 11:07:04 -05001294#include "ehci-orion.c"
1295#define PLATFORM_DRIVER ehci_orion_driver
1296#endif
1297
Vladimir Barinov91bc4d32007-12-30 15:21:11 -08001298#ifdef CONFIG_ARCH_IXP4XX
1299#include "ehci-ixp4xx.c"
1300#define PLATFORM_DRIVER ixp4xx_ehci_driver
1301#endif
1302
Wan ZongShun586dfc82009-06-13 09:14:28 +08001303#ifdef CONFIG_USB_W90X900_EHCI
1304#include "ehci-w90x900.c"
1305#define PLATFORM_DRIVER ehci_hcd_w90x900_driver
1306#endif
1307
Nicolas Ferre501c9c02009-07-27 14:47:40 -07001308#ifdef CONFIG_ARCH_AT91
1309#include "ehci-atmel.c"
1310#define PLATFORM_DRIVER ehci_atmel_driver
1311#endif
1312
David Daney1643acc2010-10-08 14:47:52 -07001313#ifdef CONFIG_USB_OCTEON_EHCI
1314#include "ehci-octeon.c"
1315#define PLATFORM_DRIVER ehci_octeon_driver
1316#endif
1317
Mac Lin760efe62010-11-25 23:58:00 +08001318#ifdef CONFIG_USB_CNS3XXX_EHCI
1319#include "ehci-cns3xxx.c"
1320#define PLATFORM_DRIVER cns3xxx_ehci_driver
1321#endif
1322
Alexey Charkovad78aca2010-11-07 19:28:55 +03001323#ifdef CONFIG_ARCH_VT8500
1324#include "ehci-vt8500.c"
1325#define PLATFORM_DRIVER vt8500_ehci_driver
1326#endif
1327
Deepak Sikric8c38de2010-11-10 14:33:18 +05301328#ifdef CONFIG_PLAT_SPEAR
1329#include "ehci-spear.c"
1330#define PLATFORM_DRIVER spear_ehci_hcd_driver
1331#endif
1332
Pavankumar Kondetib0848ae2010-12-07 17:53:56 +05301333#ifdef CONFIG_USB_EHCI_MSM
1334#include "ehci-msm.c"
1335#define PLATFORM_DRIVER ehci_msm_driver
1336#endif
1337
Anoop22ced6872011-02-24 19:26:28 +05301338#ifdef CONFIG_USB_EHCI_HCD_PMC_MSP
1339#include "ehci-pmcmsp.c"
1340#define PLATFORM_DRIVER ehci_hcd_msp_driver
1341#endif
1342
Benoit Goby79ad3b52011-03-09 16:28:56 -08001343#ifdef CONFIG_USB_EHCI_TEGRA
1344#include "ehci-tegra.c"
1345#define PLATFORM_DRIVER tegra_ehci_driver
1346#endif
1347
Joonyoung Shim1bcc5aa2011-04-08 14:08:50 +09001348#ifdef CONFIG_USB_EHCI_S5P
1349#include "ehci-s5p.c"
1350#define PLATFORM_DRIVER s5p_ehci_driver
1351#endif
1352
Jan Andersson9be03922011-05-03 20:11:58 +02001353#ifdef CONFIG_SPARC_LEON
1354#include "ehci-grlib.c"
1355#define PLATFORM_DRIVER ehci_grlib_driver
1356#endif
1357
Jayachandran C3af51542011-11-18 12:12:42 +05301358#ifdef CONFIG_CPU_XLR
Jayachandran C23106342011-08-05 01:28:22 +05301359#include "ehci-xls.c"
1360#define PLATFORM_DRIVER ehci_xls_driver
1361#endif
1362
Neil Zhang3a082ec2011-12-20 13:20:23 +08001363#ifdef CONFIG_USB_EHCI_MV
1364#include "ehci-mv.c"
1365#define PLATFORM_DRIVER ehci_mv_driver
1366#endif
1367
Kelvin Cheungf30cdbc2012-01-18 14:41:16 +08001368#ifdef CONFIG_MACH_LOONGSON1
1369#include "ehci-ls1x.c"
1370#define PLATFORM_DRIVER ehci_ls1x_driver
1371#endif
1372
Hauke Mehrtens7a7a4a592012-03-13 01:04:48 +01001373#ifdef CONFIG_USB_EHCI_HCD_PLATFORM
1374#include "ehci-platform.c"
1375#define PLATFORM_DRIVER ehci_platform_driver
1376#endif
1377
Geoff Levandad75a412007-01-15 20:11:47 -08001378#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
Grant Likely1f23b2d2010-06-02 13:53:17 -06001379 !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
1380 !defined(XILINX_OF_PLATFORM_DRIVER)
Matt Porter7ff71d62005-09-22 22:31:15 -07001381#error "missing bus glue for ehci-hcd"
1382#endif
Kumar Gala01cced22006-04-11 10:07:16 -05001383
1384static int __init ehci_hcd_init(void)
1385{
1386 int retval = 0;
1387
Alan Stern2b70f072008-10-02 11:47:15 -04001388 if (usb_disabled())
1389 return -ENODEV;
1390
1391 printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name);
Alan Stern9beeee62008-10-02 11:48:13 -04001392 set_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
1393 if (test_bit(USB_UHCI_LOADED, &usb_hcds_loaded) ||
1394 test_bit(USB_OHCI_LOADED, &usb_hcds_loaded))
1395 printk(KERN_WARNING "Warning! ehci_hcd should always be loaded"
1396 " before uhci_hcd and ohci_hcd, not after\n");
1397
Kumar Gala01cced22006-04-11 10:07:16 -05001398 pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
1399 hcd_name,
1400 sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
1401 sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
1402
Tony Jones694cc202007-09-11 14:07:31 -07001403#ifdef DEBUG
Greg Kroah-Hartman08f4e582009-04-24 15:13:18 -07001404 ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);
Alan Stern9beeee62008-10-02 11:48:13 -04001405 if (!ehci_debug_root) {
1406 retval = -ENOENT;
1407 goto err_debug;
1408 }
Tony Jones694cc202007-09-11 14:07:31 -07001409#endif
1410
Kumar Gala01cced22006-04-11 10:07:16 -05001411#ifdef PLATFORM_DRIVER
1412 retval = platform_driver_register(&PLATFORM_DRIVER);
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001413 if (retval < 0)
1414 goto clean0;
Kumar Gala01cced22006-04-11 10:07:16 -05001415#endif
1416
1417#ifdef PCI_DRIVER
1418 retval = pci_register_driver(&PCI_DRIVER);
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001419 if (retval < 0)
1420 goto clean1;
Geoff Levandad75a412007-01-15 20:11:47 -08001421#endif
1422
1423#ifdef PS3_SYSTEM_BUS_DRIVER
Geoff Levand7a4eb7f2007-06-05 20:04:35 -07001424 retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001425 if (retval < 0)
1426 goto clean2;
Kumar Gala01cced22006-04-11 10:07:16 -05001427#endif
1428
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001429#ifdef OF_PLATFORM_DRIVER
Grant Likelyd35fb642011-02-22 21:08:34 -07001430 retval = platform_driver_register(&OF_PLATFORM_DRIVER);
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001431 if (retval < 0)
1432 goto clean3;
1433#endif
Grant Likely1f23b2d2010-06-02 13:53:17 -06001434
1435#ifdef XILINX_OF_PLATFORM_DRIVER
Grant Likelyd35fb642011-02-22 21:08:34 -07001436 retval = platform_driver_register(&XILINX_OF_PLATFORM_DRIVER);
Grant Likely1f23b2d2010-06-02 13:53:17 -06001437 if (retval < 0)
1438 goto clean4;
1439#endif
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001440 return retval;
1441
Grant Likely1f23b2d2010-06-02 13:53:17 -06001442#ifdef XILINX_OF_PLATFORM_DRIVER
Grant Likelyd35fb642011-02-22 21:08:34 -07001443 /* platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER); */
Grant Likely1f23b2d2010-06-02 13:53:17 -06001444clean4:
1445#endif
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001446#ifdef OF_PLATFORM_DRIVER
Grant Likelyd35fb642011-02-22 21:08:34 -07001447 platform_driver_unregister(&OF_PLATFORM_DRIVER);
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001448clean3:
1449#endif
1450#ifdef PS3_SYSTEM_BUS_DRIVER
1451 ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
1452clean2:
1453#endif
1454#ifdef PCI_DRIVER
1455 pci_unregister_driver(&PCI_DRIVER);
1456clean1:
1457#endif
1458#ifdef PLATFORM_DRIVER
1459 platform_driver_unregister(&PLATFORM_DRIVER);
1460clean0:
1461#endif
1462#ifdef DEBUG
1463 debugfs_remove(ehci_debug_root);
1464 ehci_debug_root = NULL;
Alan Stern9beeee62008-10-02 11:48:13 -04001465err_debug:
Linus Torvaldsa9b61482008-10-20 14:23:29 -07001466#endif
Alan Stern9beeee62008-10-02 11:48:13 -04001467 clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
Kumar Gala01cced22006-04-11 10:07:16 -05001468 return retval;
1469}
1470module_init(ehci_hcd_init);
1471
1472static void __exit ehci_hcd_cleanup(void)
1473{
Grant Likely1f23b2d2010-06-02 13:53:17 -06001474#ifdef XILINX_OF_PLATFORM_DRIVER
Grant Likelyd35fb642011-02-22 21:08:34 -07001475 platform_driver_unregister(&XILINX_OF_PLATFORM_DRIVER);
Grant Likely1f23b2d2010-06-02 13:53:17 -06001476#endif
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001477#ifdef OF_PLATFORM_DRIVER
Grant Likelyd35fb642011-02-22 21:08:34 -07001478 platform_driver_unregister(&OF_PLATFORM_DRIVER);
Valentine Barshakda0e8fb2007-12-30 15:28:50 -08001479#endif
Kumar Gala01cced22006-04-11 10:07:16 -05001480#ifdef PLATFORM_DRIVER
1481 platform_driver_unregister(&PLATFORM_DRIVER);
1482#endif
1483#ifdef PCI_DRIVER
1484 pci_unregister_driver(&PCI_DRIVER);
1485#endif
Geoff Levandad75a412007-01-15 20:11:47 -08001486#ifdef PS3_SYSTEM_BUS_DRIVER
Geoff Levand7a4eb7f2007-06-05 20:04:35 -07001487 ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
Geoff Levandad75a412007-01-15 20:11:47 -08001488#endif
Tony Jones694cc202007-09-11 14:07:31 -07001489#ifdef DEBUG
1490 debugfs_remove(ehci_debug_root);
1491#endif
Alan Stern9beeee62008-10-02 11:48:13 -04001492 clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
Kumar Gala01cced22006-04-11 10:07:16 -05001493}
1494module_exit(ehci_hcd_cleanup);
1495