1/*
2 * (C) Copyright David Brownell 2000-2002
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/pci.h>
22#include <linux/usb.h>
23#include <linux/usb/hcd.h>
24
25#include <asm/io.h>
26#include <asm/irq.h>
27
28#ifdef CONFIG_PPC_PMAC
29#include <asm/machdep.h>
30#include <asm/pmac_feature.h>
31#include <asm/pci-bridge.h>
32#include <asm/prom.h>
33#endif
34
35#include "usb.h"
36
37
38/* PCI-based HCs are common, but plenty of non-PCI HCs are used too */
39
40/*
41 * Coordinate handoffs between EHCI and companion controllers
42 * during EHCI probing and system resume.
43 */
44
45static DECLARE_RWSEM(companions_rwsem);
46
47#define CL_UHCI		PCI_CLASS_SERIAL_USB_UHCI
48#define CL_OHCI		PCI_CLASS_SERIAL_USB_OHCI
49#define CL_EHCI		PCI_CLASS_SERIAL_USB_EHCI
50
51static inline int is_ohci_or_uhci(struct pci_dev *pdev)
52{
53	return pdev->class == CL_OHCI || pdev->class == CL_UHCI;
54}
55
56typedef void (*companion_fn)(struct pci_dev *pdev, struct usb_hcd *hcd,
57		struct pci_dev *companion, struct usb_hcd *companion_hcd);
58
59/* Iterate over PCI devices in the same slot as pdev and call fn for each */
60static void for_each_companion(struct pci_dev *pdev, struct usb_hcd *hcd,
61		companion_fn fn)
62{
63	struct pci_dev		*companion;
64	struct usb_hcd		*companion_hcd;
65	unsigned int		slot = PCI_SLOT(pdev->devfn);
66
67	/*
68	 * Iterate through other PCI functions in the same slot.
69	 * If the function's drvdata isn't set then it isn't bound to
70	 * a USB host controller driver, so skip it.
71	 */
72	companion = NULL;
73	for_each_pci_dev(companion) {
74		if (companion->bus != pdev->bus ||
75				PCI_SLOT(companion->devfn) != slot)
76			continue;
77
78		/*
79		 * Companion device should be either UHCI,OHCI or EHCI host
80		 * controller, otherwise skip.
81		 */
82		if (companion->class != CL_UHCI && companion->class != CL_OHCI &&
83				companion->class != CL_EHCI)
84			continue;
85
86		companion_hcd = pci_get_drvdata(companion);
87		if (!companion_hcd || !companion_hcd->self.root_hub)
88			continue;
89		fn(pdev, hcd, companion, companion_hcd);
90	}
91}
92
93/*
94 * We're about to add an EHCI controller, which will unceremoniously grab
95 * all the port connections away from its companions.  To prevent annoying
96 * error messages, lock the companion's root hub and gracefully unconfigure
97 * it beforehand.  Leave it locked until the EHCI controller is all set.
98 */
99static void ehci_pre_add(struct pci_dev *pdev, struct usb_hcd *hcd,
100		struct pci_dev *companion, struct usb_hcd *companion_hcd)
101{
102	struct usb_device *udev;
103
104	if (is_ohci_or_uhci(companion)) {
105		udev = companion_hcd->self.root_hub;
106		usb_lock_device(udev);
107		usb_set_configuration(udev, 0);
108	}
109}
110
111/*
112 * Adding the EHCI controller has either succeeded or failed.  Set the
113 * companion pointer accordingly, and in either case, reconfigure and
114 * unlock the root hub.
115 */
116static void ehci_post_add(struct pci_dev *pdev, struct usb_hcd *hcd,
117		struct pci_dev *companion, struct usb_hcd *companion_hcd)
118{
119	struct usb_device *udev;
120
121	if (is_ohci_or_uhci(companion)) {
122		if (dev_get_drvdata(&pdev->dev)) {	/* Succeeded */
123			dev_dbg(&pdev->dev, "HS companion for %s\n",
124					dev_name(&companion->dev));
125			companion_hcd->self.hs_companion = &hcd->self;
126		}
127		udev = companion_hcd->self.root_hub;
128		usb_set_configuration(udev, 1);
129		usb_unlock_device(udev);
130	}
131}
132
133/*
134 * We just added a non-EHCI controller.  Find the EHCI controller to
135 * which it is a companion, and store a pointer to the bus structure.
136 */
137static void non_ehci_add(struct pci_dev *pdev, struct usb_hcd *hcd,
138		struct pci_dev *companion, struct usb_hcd *companion_hcd)
139{
140	if (is_ohci_or_uhci(pdev) && companion->class == CL_EHCI) {
141		dev_dbg(&pdev->dev, "FS/LS companion for %s\n",
142				dev_name(&companion->dev));
143		hcd->self.hs_companion = &companion_hcd->self;
144	}
145}
146
147/* We are removing an EHCI controller.  Clear the companions' pointers. */
148static void ehci_remove(struct pci_dev *pdev, struct usb_hcd *hcd,
149		struct pci_dev *companion, struct usb_hcd *companion_hcd)
150{
151	if (is_ohci_or_uhci(companion))
152		companion_hcd->self.hs_companion = NULL;
153}
154
155#ifdef	CONFIG_PM
156
157/* An EHCI controller must wait for its companions before resuming. */
158static void ehci_wait_for_companions(struct pci_dev *pdev, struct usb_hcd *hcd,
159		struct pci_dev *companion, struct usb_hcd *companion_hcd)
160{
161	if (is_ohci_or_uhci(companion))
162		device_pm_wait_for_dev(&pdev->dev, &companion->dev);
163}
164
165#endif	/* CONFIG_PM */
166
167/*-------------------------------------------------------------------------*/
168
169/* configure so an HC device and id are always provided */
170/* always called with process context; sleeping is OK */
171
172/**
173 * usb_hcd_pci_probe - initialize PCI-based HCDs
174 * @dev: USB Host Controller being probed
175 * @id: pci hotplug id connecting controller to HCD framework
176 * Context: !in_interrupt()
177 *
178 * Allocates basic PCI resources for this USB host controller, and
179 * then invokes the start() method for the HCD associated with it
180 * through the hotplug entry's driver_data.
181 *
182 * Store this function in the HCD's struct pci_driver as probe().
183 *
184 * Return: 0 if successful.
185 */
186int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
187{
188	struct hc_driver	*driver;
189	struct usb_hcd		*hcd;
190	int			retval;
191	int			hcd_irq = 0;
192
193	if (usb_disabled())
194		return -ENODEV;
195
196	if (!id)
197		return -EINVAL;
198	driver = (struct hc_driver *)id->driver_data;
199	if (!driver)
200		return -EINVAL;
201
202	if (pci_enable_device(dev) < 0)
203		return -ENODEV;
204
205	/*
206	 * The xHCI driver has its own irq management
207	 * make sure irq setup is not touched for xhci in generic hcd code
208	 */
209	if ((driver->flags & HCD_MASK) != HCD_USB3) {
210		if (!dev->irq) {
211			dev_err(&dev->dev,
212			"Found HC with no IRQ. Check BIOS/PCI %s setup!\n",
213				pci_name(dev));
214			retval = -ENODEV;
215			goto disable_pci;
216		}
217		hcd_irq = dev->irq;
218	}
219
220	hcd = usb_create_hcd(driver, &dev->dev, pci_name(dev));
221	if (!hcd) {
222		retval = -ENOMEM;
223		goto disable_pci;
224	}
225
226	hcd->amd_resume_bug = (usb_hcd_amd_remote_wakeup_quirk(dev) &&
227			driver->flags & (HCD_USB11 | HCD_USB3)) ? 1 : 0;
228
229	if (driver->flags & HCD_MEMORY) {
230		/* EHCI, OHCI */
231		hcd->rsrc_start = pci_resource_start(dev, 0);
232		hcd->rsrc_len = pci_resource_len(dev, 0);
233		if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
234				driver->description)) {
235			dev_dbg(&dev->dev, "controller already in use\n");
236			retval = -EBUSY;
237			goto put_hcd;
238		}
239		hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
240		if (hcd->regs == NULL) {
241			dev_dbg(&dev->dev, "error mapping memory\n");
242			retval = -EFAULT;
243			goto release_mem_region;
244		}
245
246	} else {
247		/* UHCI */
248		int	region;
249
250		for (region = 0; region < PCI_ROM_RESOURCE; region++) {
251			if (!(pci_resource_flags(dev, region) &
252					IORESOURCE_IO))
253				continue;
254
255			hcd->rsrc_start = pci_resource_start(dev, region);
256			hcd->rsrc_len = pci_resource_len(dev, region);
257			if (request_region(hcd->rsrc_start, hcd->rsrc_len,
258					driver->description))
259				break;
260		}
261		if (region == PCI_ROM_RESOURCE) {
262			dev_dbg(&dev->dev, "no i/o regions available\n");
263			retval = -EBUSY;
264			goto put_hcd;
265		}
266	}
267
268	pci_set_master(dev);
269
270	/* Note: dev_set_drvdata must be called while holding the rwsem */
271	if (dev->class == CL_EHCI) {
272		down_write(&companions_rwsem);
273		dev_set_drvdata(&dev->dev, hcd);
274		for_each_companion(dev, hcd, ehci_pre_add);
275		retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
276		if (retval != 0)
277			dev_set_drvdata(&dev->dev, NULL);
278		for_each_companion(dev, hcd, ehci_post_add);
279		up_write(&companions_rwsem);
280	} else {
281		down_read(&companions_rwsem);
282		dev_set_drvdata(&dev->dev, hcd);
283		retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
284		if (retval != 0)
285			dev_set_drvdata(&dev->dev, NULL);
286		else
287			for_each_companion(dev, hcd, non_ehci_add);
288		up_read(&companions_rwsem);
289	}
290
291	if (retval != 0)
292		goto unmap_registers;
293	device_wakeup_enable(hcd->self.controller);
294
295	if (pci_dev_run_wake(dev))
296		pm_runtime_put_noidle(&dev->dev);
297	return retval;
298
299unmap_registers:
300	if (driver->flags & HCD_MEMORY) {
301		iounmap(hcd->regs);
302release_mem_region:
303		release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
304	} else
305		release_region(hcd->rsrc_start, hcd->rsrc_len);
306put_hcd:
307	usb_put_hcd(hcd);
308disable_pci:
309	pci_disable_device(dev);
310	dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval);
311	return retval;
312}
313EXPORT_SYMBOL_GPL(usb_hcd_pci_probe);
314
315
316/* may be called without controller electrically present */
317/* may be called with controller, bus, and devices active */
318
319/**
320 * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs
321 * @dev: USB Host Controller being removed
322 * Context: !in_interrupt()
323 *
324 * Reverses the effect of usb_hcd_pci_probe(), first invoking
325 * the HCD's stop() method.  It is always called from a thread
326 * context, normally "rmmod", "apmd", or something similar.
327 *
328 * Store this function in the HCD's struct pci_driver as remove().
329 */
330void usb_hcd_pci_remove(struct pci_dev *dev)
331{
332	struct usb_hcd		*hcd;
333
334	hcd = pci_get_drvdata(dev);
335	if (!hcd)
336		return;
337
338	if (pci_dev_run_wake(dev))
339		pm_runtime_get_noresume(&dev->dev);
340
341	/* Fake an interrupt request in order to give the driver a chance
342	 * to test whether the controller hardware has been removed (e.g.,
343	 * cardbus physical eject).
344	 */
345	local_irq_disable();
346	usb_hcd_irq(0, hcd);
347	local_irq_enable();
348
349	/* Note: dev_set_drvdata must be called while holding the rwsem */
350	if (dev->class == CL_EHCI) {
351		down_write(&companions_rwsem);
352		for_each_companion(dev, hcd, ehci_remove);
353		usb_remove_hcd(hcd);
354		dev_set_drvdata(&dev->dev, NULL);
355		up_write(&companions_rwsem);
356	} else {
357		/* Not EHCI; just clear the companion pointer */
358		down_read(&companions_rwsem);
359		hcd->self.hs_companion = NULL;
360		usb_remove_hcd(hcd);
361		dev_set_drvdata(&dev->dev, NULL);
362		up_read(&companions_rwsem);
363	}
364
365	if (hcd->driver->flags & HCD_MEMORY) {
366		iounmap(hcd->regs);
367		release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
368	} else {
369		release_region(hcd->rsrc_start, hcd->rsrc_len);
370	}
371
372	usb_put_hcd(hcd);
373	pci_disable_device(dev);
374}
375EXPORT_SYMBOL_GPL(usb_hcd_pci_remove);
376
377/**
378 * usb_hcd_pci_shutdown - shutdown host controller
379 * @dev: USB Host Controller being shutdown
380 */
381void usb_hcd_pci_shutdown(struct pci_dev *dev)
382{
383	struct usb_hcd		*hcd;
384
385	hcd = pci_get_drvdata(dev);
386	if (!hcd)
387		return;
388
389	if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) &&
390			hcd->driver->shutdown) {
391		hcd->driver->shutdown(hcd);
392		if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
393			free_irq(hcd->irq, hcd);
394		pci_disable_device(dev);
395	}
396}
397EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown);
398
399#ifdef	CONFIG_PM
400
401#ifdef	CONFIG_PPC_PMAC
402static void powermac_set_asic(struct pci_dev *pci_dev, int enable)
403{
404	/* Enanble or disable ASIC clocks for USB */
405	if (machine_is(powermac)) {
406		struct device_node	*of_node;
407
408		of_node = pci_device_to_OF_node(pci_dev);
409		if (of_node)
410			pmac_call_feature(PMAC_FTR_USB_ENABLE,
411					of_node, 0, enable);
412	}
413}
414
415#else
416
417static inline void powermac_set_asic(struct pci_dev *pci_dev, int enable)
418{}
419
420#endif	/* CONFIG_PPC_PMAC */
421
422static int check_root_hub_suspended(struct device *dev)
423{
424	struct pci_dev		*pci_dev = to_pci_dev(dev);
425	struct usb_hcd		*hcd = pci_get_drvdata(pci_dev);
426
427	if (HCD_RH_RUNNING(hcd)) {
428		dev_warn(dev, "Root hub is not suspended\n");
429		return -EBUSY;
430	}
431	if (hcd->shared_hcd) {
432		hcd = hcd->shared_hcd;
433		if (HCD_RH_RUNNING(hcd)) {
434			dev_warn(dev, "Secondary root hub is not suspended\n");
435			return -EBUSY;
436		}
437	}
438	return 0;
439}
440
441static int suspend_common(struct device *dev, bool do_wakeup)
442{
443	struct pci_dev		*pci_dev = to_pci_dev(dev);
444	struct usb_hcd		*hcd = pci_get_drvdata(pci_dev);
445	int			retval;
446
447	/* Root hub suspend should have stopped all downstream traffic,
448	 * and all bus master traffic.  And done so for both the interface
449	 * and the stub usb_device (which we check here).  But maybe it
450	 * didn't; writing sysfs power/state files ignores such rules...
451	 */
452	retval = check_root_hub_suspended(dev);
453	if (retval)
454		return retval;
455
456	if (hcd->driver->pci_suspend && !HCD_DEAD(hcd)) {
457		/* Optimization: Don't suspend if a root-hub wakeup is
458		 * pending and it would cause the HCD to wake up anyway.
459		 */
460		if (do_wakeup && HCD_WAKEUP_PENDING(hcd))
461			return -EBUSY;
462		if (do_wakeup && hcd->shared_hcd &&
463				HCD_WAKEUP_PENDING(hcd->shared_hcd))
464			return -EBUSY;
465		retval = hcd->driver->pci_suspend(hcd, do_wakeup);
466		suspend_report_result(hcd->driver->pci_suspend, retval);
467
468		/* Check again in case wakeup raced with pci_suspend */
469		if ((retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) ||
470				(retval == 0 && do_wakeup && hcd->shared_hcd &&
471				 HCD_WAKEUP_PENDING(hcd->shared_hcd))) {
472			if (hcd->driver->pci_resume)
473				hcd->driver->pci_resume(hcd, false);
474			retval = -EBUSY;
475		}
476		if (retval)
477			return retval;
478	}
479
480	/* If MSI-X is enabled, the driver will have synchronized all vectors
481	 * in pci_suspend(). If MSI or legacy PCI is enabled, that will be
482	 * synchronized here.
483	 */
484	if (!hcd->msix_enabled)
485		synchronize_irq(pci_dev->irq);
486
487	/* Downstream ports from this root hub should already be quiesced, so
488	 * there will be no DMA activity.  Now we can shut down the upstream
489	 * link (except maybe for PME# resume signaling).  We'll enter a
490	 * low power state during suspend_noirq, if the hardware allows.
491	 */
492	pci_disable_device(pci_dev);
493	return retval;
494}
495
496static int resume_common(struct device *dev, int event)
497{
498	struct pci_dev		*pci_dev = to_pci_dev(dev);
499	struct usb_hcd		*hcd = pci_get_drvdata(pci_dev);
500	int			retval;
501
502	if (HCD_RH_RUNNING(hcd) ||
503			(hcd->shared_hcd &&
504			 HCD_RH_RUNNING(hcd->shared_hcd))) {
505		dev_dbg(dev, "can't resume, not suspended!\n");
506		return 0;
507	}
508
509	retval = pci_enable_device(pci_dev);
510	if (retval < 0) {
511		dev_err(dev, "can't re-enable after resume, %d!\n", retval);
512		return retval;
513	}
514
515	pci_set_master(pci_dev);
516
517	if (hcd->driver->pci_resume && !HCD_DEAD(hcd)) {
518
519		/*
520		 * Only EHCI controllers have to wait for their companions.
521		 * No locking is needed because PCI controller drivers do not
522		 * get unbound during system resume.
523		 */
524		if (pci_dev->class == CL_EHCI && event != PM_EVENT_AUTO_RESUME)
525			for_each_companion(pci_dev, hcd,
526					ehci_wait_for_companions);
527
528		retval = hcd->driver->pci_resume(hcd,
529				event == PM_EVENT_RESTORE);
530		if (retval) {
531			dev_err(dev, "PCI post-resume error %d!\n", retval);
532			if (hcd->shared_hcd)
533				usb_hc_died(hcd->shared_hcd);
534			usb_hc_died(hcd);
535		}
536	}
537	return retval;
538}
539
540#ifdef	CONFIG_PM_SLEEP
541
542static int hcd_pci_suspend(struct device *dev)
543{
544	return suspend_common(dev, device_may_wakeup(dev));
545}
546
547static int hcd_pci_suspend_noirq(struct device *dev)
548{
549	struct pci_dev		*pci_dev = to_pci_dev(dev);
550	struct usb_hcd		*hcd = pci_get_drvdata(pci_dev);
551	int			retval;
552
553	retval = check_root_hub_suspended(dev);
554	if (retval)
555		return retval;
556
557	pci_save_state(pci_dev);
558
559	/* If the root hub is dead rather than suspended, disallow remote
560	 * wakeup.  usb_hc_died() should ensure that both hosts are marked as
561	 * dying, so we only need to check the primary roothub.
562	 */
563	if (HCD_DEAD(hcd))
564		device_set_wakeup_enable(dev, 0);
565	dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev));
566
567	/* Possibly enable remote wakeup,
568	 * choose the appropriate low-power state, and go to that state.
569	 */
570	retval = pci_prepare_to_sleep(pci_dev);
571	if (retval == -EIO) {		/* Low-power not supported */
572		dev_dbg(dev, "--> PCI D0 legacy\n");
573		retval = 0;
574	} else if (retval == 0) {
575		dev_dbg(dev, "--> PCI %s\n",
576				pci_power_name(pci_dev->current_state));
577	} else {
578		suspend_report_result(pci_prepare_to_sleep, retval);
579		return retval;
580	}
581
582	powermac_set_asic(pci_dev, 0);
583	return retval;
584}
585
586static int hcd_pci_resume_noirq(struct device *dev)
587{
588	struct pci_dev		*pci_dev = to_pci_dev(dev);
589
590	powermac_set_asic(pci_dev, 1);
591
592	/* Go back to D0 and disable remote wakeup */
593	pci_back_from_sleep(pci_dev);
594	return 0;
595}
596
597static int hcd_pci_resume(struct device *dev)
598{
599	return resume_common(dev, PM_EVENT_RESUME);
600}
601
602static int hcd_pci_restore(struct device *dev)
603{
604	return resume_common(dev, PM_EVENT_RESTORE);
605}
606
607#else
608
609#define hcd_pci_suspend		NULL
610#define hcd_pci_suspend_noirq	NULL
611#define hcd_pci_resume_noirq	NULL
612#define hcd_pci_resume		NULL
613#define hcd_pci_restore		NULL
614
615#endif	/* CONFIG_PM_SLEEP */
616
617static int hcd_pci_runtime_suspend(struct device *dev)
618{
619	int	retval;
620
621	retval = suspend_common(dev, true);
622	if (retval == 0)
623		powermac_set_asic(to_pci_dev(dev), 0);
624	dev_dbg(dev, "hcd_pci_runtime_suspend: %d\n", retval);
625	return retval;
626}
627
628static int hcd_pci_runtime_resume(struct device *dev)
629{
630	int	retval;
631
632	powermac_set_asic(to_pci_dev(dev), 1);
633	retval = resume_common(dev, PM_EVENT_AUTO_RESUME);
634	dev_dbg(dev, "hcd_pci_runtime_resume: %d\n", retval);
635	return retval;
636}
637
638const struct dev_pm_ops usb_hcd_pci_pm_ops = {
639	.suspend	= hcd_pci_suspend,
640	.suspend_noirq	= hcd_pci_suspend_noirq,
641	.resume_noirq	= hcd_pci_resume_noirq,
642	.resume		= hcd_pci_resume,
643	.freeze		= check_root_hub_suspended,
644	.freeze_noirq	= check_root_hub_suspended,
645	.thaw_noirq	= NULL,
646	.thaw		= NULL,
647	.poweroff	= hcd_pci_suspend,
648	.poweroff_noirq	= hcd_pci_suspend_noirq,
649	.restore_noirq	= hcd_pci_resume_noirq,
650	.restore	= hcd_pci_restore,
651	.runtime_suspend = hcd_pci_runtime_suspend,
652	.runtime_resume	= hcd_pci_runtime_resume,
653};
654EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops);
655
656#endif	/* CONFIG_PM */
657