2 * (C) Copyright David Brownell 2000-2002
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.
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
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.
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/pci.h>
22 #include <linux/usb.h>
27 #ifdef CONFIG_PPC_PMAC
28 #include <asm/machdep.h>
29 #include <asm/pmac_feature.h>
30 #include <asm/pci-bridge.h>
38 /* PCI-based HCs are common, but plenty of non-PCI HCs are used too */
41 /*-------------------------------------------------------------------------*/
43 /* configure so an HC device and id are always provided */
44 /* always called with process context; sleeping is OK */
47 * usb_hcd_pci_probe - initialize PCI-based HCDs
48 * @dev: USB Host Controller being probed
49 * @id: pci hotplug id connecting controller to HCD framework
50 * Context: !in_interrupt()
52 * Allocates basic PCI resources for this USB host controller, and
53 * then invokes the start() method for the HCD associated with it
54 * through the hotplug entry's driver_data.
56 * Store this function in the HCD's struct pci_driver as probe().
58 int usb_hcd_pci_probe(struct pci_dev
*dev
, const struct pci_device_id
*id
)
60 struct hc_driver
*driver
;
69 driver
= (struct hc_driver
*)id
->driver_data
;
73 if (pci_enable_device(dev
) < 0)
75 dev
->current_state
= PCI_D0
;
79 "Found HC with no IRQ. Check BIOS/PCI %s setup!\n",
85 hcd
= usb_create_hcd(driver
, &dev
->dev
, pci_name(dev
));
91 if (driver
->flags
& HCD_MEMORY
) {
93 hcd
->rsrc_start
= pci_resource_start(dev
, 0);
94 hcd
->rsrc_len
= pci_resource_len(dev
, 0);
95 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
,
96 driver
->description
)) {
97 dev_dbg(&dev
->dev
, "controller already in use\n");
101 hcd
->regs
= ioremap_nocache(hcd
->rsrc_start
, hcd
->rsrc_len
);
102 if (hcd
->regs
== NULL
) {
103 dev_dbg(&dev
->dev
, "error mapping memory\n");
112 for (region
= 0; region
< PCI_ROM_RESOURCE
; region
++) {
113 if (!(pci_resource_flags(dev
, region
) &
117 hcd
->rsrc_start
= pci_resource_start(dev
, region
);
118 hcd
->rsrc_len
= pci_resource_len(dev
, region
);
119 if (request_region(hcd
->rsrc_start
, hcd
->rsrc_len
,
120 driver
->description
))
123 if (region
== PCI_ROM_RESOURCE
) {
124 dev_dbg(&dev
->dev
, "no i/o regions available\n");
132 retval
= usb_add_hcd(hcd
, dev
->irq
, IRQF_DISABLED
| IRQF_SHARED
);
138 if (driver
->flags
& HCD_MEMORY
) {
141 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
143 release_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
147 pci_disable_device(dev
);
148 dev_err(&dev
->dev
, "init %s fail, %d\n", pci_name(dev
), retval
);
151 EXPORT_SYMBOL_GPL(usb_hcd_pci_probe
);
154 /* may be called without controller electrically present */
155 /* may be called with controller, bus, and devices active */
158 * usb_hcd_pci_remove - shutdown processing for PCI-based HCDs
159 * @dev: USB Host Controller being removed
160 * Context: !in_interrupt()
162 * Reverses the effect of usb_hcd_pci_probe(), first invoking
163 * the HCD's stop() method. It is always called from a thread
164 * context, normally "rmmod", "apmd", or something similar.
166 * Store this function in the HCD's struct pci_driver as remove().
168 void usb_hcd_pci_remove(struct pci_dev
*dev
)
172 hcd
= pci_get_drvdata(dev
);
177 if (hcd
->driver
->flags
& HCD_MEMORY
) {
179 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
181 release_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
184 pci_disable_device(dev
);
186 EXPORT_SYMBOL_GPL(usb_hcd_pci_remove
);
192 * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD
193 * @dev: USB Host Controller being suspended
194 * @message: semantics in flux
196 * Store this function in the HCD's struct pci_driver as suspend().
198 int usb_hcd_pci_suspend(struct pci_dev
*dev
, pm_message_t message
)
204 hcd
= pci_get_drvdata(dev
);
206 /* Root hub suspend should have stopped all downstream traffic,
207 * and all bus master traffic. And done so for both the interface
208 * and the stub usb_device (which we check here). But maybe it
209 * didn't; writing sysfs power/state files ignores such rules...
211 * We must ignore the FREEZE vs SUSPEND distinction here, because
212 * otherwise the swsusp will save (and restore) garbage state.
214 if (!(hcd
->state
== HC_STATE_SUSPENDED
||
215 hcd
->state
== HC_STATE_HALT
))
218 if (hcd
->driver
->pci_suspend
) {
219 retval
= hcd
->driver
->pci_suspend(hcd
, message
);
220 suspend_report_result(hcd
->driver
->pci_suspend
, retval
);
224 synchronize_irq(dev
->irq
);
226 /* FIXME until the generic PM interfaces change a lot more, this
227 * can't use PCI D1 and D2 states. For example, the confusion
228 * between messages and states will need to vanish, and messages
229 * will need to provide a target system state again.
231 * It'll be important to learn characteristics of the target state,
232 * especially on embedded hardware where the HCD will often be in
233 * charge of an external VBUS power supply and one or more clocks.
234 * Some target system states will leave them active; others won't.
235 * (With PCI, that's often handled by platform BIOS code.)
238 /* even when the PCI layer rejects some of the PCI calls
239 * below, HCs can try global suspend and reduce DMA traffic.
240 * PM-sensitive HCDs may already have done this.
242 has_pci_pm
= pci_find_capability(dev
, PCI_CAP_ID_PM
);
244 /* Downstream ports from this root hub should already be quiesced, so
245 * there will be no DMA activity. Now we can shut down the upstream
246 * link (except maybe for PME# resume signaling) and enter some PCI
247 * low power state, if the hardware allows.
249 if (hcd
->state
== HC_STATE_SUSPENDED
) {
251 /* no DMA or IRQs except when HC is active */
252 if (dev
->current_state
== PCI_D0
) {
254 pci_disable_device(dev
);
257 if (message
.event
== PM_EVENT_FREEZE
||
258 message
.event
== PM_EVENT_PRETHAW
) {
259 dev_dbg(hcd
->self
.controller
, "--> no state change\n");
264 dev_dbg(hcd
->self
.controller
, "--> PCI D0/legacy\n");
268 /* NOTE: dev->current_state becomes nonzero only here, and
269 * only for devices that support PCI PM. Also, exiting
270 * PCI_D3 (but not PCI_D1 or PCI_D2) is allowed to reset
271 * some device state (e.g. as part of clock reinit).
273 retval
= pci_set_power_state(dev
, PCI_D3hot
);
274 suspend_report_result(pci_set_power_state
, retval
);
276 int wake
= device_can_wakeup(&hcd
->self
.root_hub
->dev
);
278 wake
= wake
&& device_may_wakeup(hcd
->self
.controller
);
280 dev_dbg(hcd
->self
.controller
, "--> PCI D3%s\n",
281 wake
? "/wakeup" : "");
283 /* Ignore these return values. We rely on pci code to
284 * reject requests the hardware can't implement, rather
285 * than coding the same thing.
287 (void) pci_enable_wake(dev
, PCI_D3hot
, wake
);
288 (void) pci_enable_wake(dev
, PCI_D3cold
, wake
);
290 dev_dbg(&dev
->dev
, "PCI D3 suspend fail, %d\n",
292 (void) usb_hcd_pci_resume(dev
);
295 } else if (hcd
->state
!= HC_STATE_HALT
) {
296 dev_dbg(hcd
->self
.controller
, "hcd state %d; not suspended\n",
304 #ifdef CONFIG_PPC_PMAC
305 /* Disable ASIC clocks for USB */
306 if (machine_is(powermac
)) {
307 struct device_node
*of_node
;
309 of_node
= pci_device_to_OF_node(dev
);
311 pmac_call_feature(PMAC_FTR_USB_ENABLE
,
319 EXPORT_SYMBOL_GPL(usb_hcd_pci_suspend
);
322 * usb_hcd_pci_resume - power management resume of a PCI-based HCD
323 * @dev: USB Host Controller being resumed
325 * Store this function in the HCD's struct pci_driver as resume().
327 int usb_hcd_pci_resume(struct pci_dev
*dev
)
332 hcd
= pci_get_drvdata(dev
);
333 if (hcd
->state
!= HC_STATE_SUSPENDED
) {
334 dev_dbg(hcd
->self
.controller
,
335 "can't resume, not suspended!\n");
339 #ifdef CONFIG_PPC_PMAC
340 /* Reenable ASIC clocks for USB */
341 if (machine_is(powermac
)) {
342 struct device_node
*of_node
;
344 of_node
= pci_device_to_OF_node(dev
);
346 pmac_call_feature(PMAC_FTR_USB_ENABLE
,
351 /* NOTE: chip docs cover clean "real suspend" cases (what Linux
352 * calls "standby", "suspend to RAM", and so on). There are also
353 * dirty cases when swsusp fakes a suspend in "shutdown" mode.
355 if (dev
->current_state
!= PCI_D0
) {
360 pci_pm
= pci_find_capability(dev
, PCI_CAP_ID_PM
);
361 pci_read_config_word(dev
, pci_pm
+ PCI_PM_CTRL
, &pmcr
);
362 pmcr
&= PCI_PM_CTRL_STATE_MASK
;
364 /* Clean case: power to USB and to HC registers was
365 * maintained; remote wakeup is easy.
367 dev_dbg(hcd
->self
.controller
, "resume from PCI D%d\n",
370 /* Clean: HC lost Vcc power, D0 uninitialized
371 * + Vaux may have preserved port and transceiver
372 * state ... for remote wakeup from D3cold
373 * + or not; HCD must reinit + re-enumerate
375 * Dirty: D0 semi-initialized cases with swsusp
377 * + after Linux init (HCD statically linked)
379 dev_dbg(hcd
->self
.controller
,
380 "PCI D0, from previous PCI D%d\n",
384 /* yes, ignore these results too... */
385 (void) pci_enable_wake(dev
, dev
->current_state
, 0);
386 (void) pci_enable_wake(dev
, PCI_D3cold
, 0);
388 /* Same basic cases: clean (powered/not), dirty */
389 dev_dbg(hcd
->self
.controller
, "PCI legacy resume\n");
392 /* NOTE: the PCI API itself is asymmetric here. We don't need to
393 * pci_set_power_state(PCI_D0) since that's part of re-enabling;
394 * but that won't re-enable bus mastering. Yet pci_disable_device()
395 * explicitly disables bus mastering...
397 retval
= pci_enable_device(dev
);
399 dev_err(hcd
->self
.controller
,
400 "can't re-enable after resume, %d!\n", retval
);
404 pci_restore_state(dev
);
406 clear_bit(HCD_FLAG_SAW_IRQ
, &hcd
->flags
);
408 if (hcd
->driver
->pci_resume
) {
409 retval
= hcd
->driver
->pci_resume(hcd
);
411 dev_err(hcd
->self
.controller
,
412 "PCI post-resume error %d!\n", retval
);
419 EXPORT_SYMBOL_GPL(usb_hcd_pci_resume
);
421 #endif /* CONFIG_PM */
424 * usb_hcd_pci_shutdown - shutdown host controller
425 * @dev: USB Host Controller being shutdown
427 void usb_hcd_pci_shutdown(struct pci_dev
*dev
)
431 hcd
= pci_get_drvdata(dev
);
435 if (hcd
->driver
->shutdown
)
436 hcd
->driver
->shutdown(hcd
);
438 EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown
);