This source file includes following definitions.
- is_ohci_or_uhci
- for_each_companion
- ehci_pre_add
- ehci_post_add
- non_ehci_add
- ehci_remove
- ehci_wait_for_companions
- usb_hcd_pci_probe
- usb_hcd_pci_remove
- usb_hcd_pci_shutdown
- powermac_set_asic
- powermac_set_asic
- check_root_hub_suspended
- suspend_common
- resume_common
- hcd_pci_suspend
- hcd_pci_suspend_noirq
- hcd_pci_resume_noirq
- hcd_pci_resume
- hcd_pci_restore
- hcd_pci_runtime_suspend
- hcd_pci_runtime_resume
1
2
3
4
5
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/pci.h>
9 #include <linux/usb.h>
10 #include <linux/usb/hcd.h>
11
12 #include <asm/io.h>
13 #include <asm/irq.h>
14
15 #ifdef CONFIG_PPC_PMAC
16 #include <asm/machdep.h>
17 #include <asm/pmac_feature.h>
18 #include <asm/prom.h>
19 #endif
20
21 #include "usb.h"
22
23
24
25
26
27
28
29
30
31 static DECLARE_RWSEM(companions_rwsem);
32
33 #define CL_UHCI PCI_CLASS_SERIAL_USB_UHCI
34 #define CL_OHCI PCI_CLASS_SERIAL_USB_OHCI
35 #define CL_EHCI PCI_CLASS_SERIAL_USB_EHCI
36
37 static inline int is_ohci_or_uhci(struct pci_dev *pdev)
38 {
39 return pdev->class == CL_OHCI || pdev->class == CL_UHCI;
40 }
41
42 typedef void (*companion_fn)(struct pci_dev *pdev, struct usb_hcd *hcd,
43 struct pci_dev *companion, struct usb_hcd *companion_hcd);
44
45
46 static void for_each_companion(struct pci_dev *pdev, struct usb_hcd *hcd,
47 companion_fn fn)
48 {
49 struct pci_dev *companion;
50 struct usb_hcd *companion_hcd;
51 unsigned int slot = PCI_SLOT(pdev->devfn);
52
53
54
55
56
57
58 companion = NULL;
59 for_each_pci_dev(companion) {
60 if (companion->bus != pdev->bus ||
61 PCI_SLOT(companion->devfn) != slot)
62 continue;
63
64
65
66
67
68 if (companion->class != CL_UHCI && companion->class != CL_OHCI &&
69 companion->class != CL_EHCI)
70 continue;
71
72 companion_hcd = pci_get_drvdata(companion);
73 if (!companion_hcd || !companion_hcd->self.root_hub)
74 continue;
75 fn(pdev, hcd, companion, companion_hcd);
76 }
77 }
78
79
80
81
82
83
84
85 static void ehci_pre_add(struct pci_dev *pdev, struct usb_hcd *hcd,
86 struct pci_dev *companion, struct usb_hcd *companion_hcd)
87 {
88 struct usb_device *udev;
89
90 if (is_ohci_or_uhci(companion)) {
91 udev = companion_hcd->self.root_hub;
92 usb_lock_device(udev);
93 usb_set_configuration(udev, 0);
94 }
95 }
96
97
98
99
100
101
102 static void ehci_post_add(struct pci_dev *pdev, struct usb_hcd *hcd,
103 struct pci_dev *companion, struct usb_hcd *companion_hcd)
104 {
105 struct usb_device *udev;
106
107 if (is_ohci_or_uhci(companion)) {
108 if (dev_get_drvdata(&pdev->dev)) {
109 dev_dbg(&pdev->dev, "HS companion for %s\n",
110 dev_name(&companion->dev));
111 companion_hcd->self.hs_companion = &hcd->self;
112 }
113 udev = companion_hcd->self.root_hub;
114 usb_set_configuration(udev, 1);
115 usb_unlock_device(udev);
116 }
117 }
118
119
120
121
122
123 static void non_ehci_add(struct pci_dev *pdev, struct usb_hcd *hcd,
124 struct pci_dev *companion, struct usb_hcd *companion_hcd)
125 {
126 if (is_ohci_or_uhci(pdev) && companion->class == CL_EHCI) {
127 dev_dbg(&pdev->dev, "FS/LS companion for %s\n",
128 dev_name(&companion->dev));
129 hcd->self.hs_companion = &companion_hcd->self;
130 }
131 }
132
133
134 static void ehci_remove(struct pci_dev *pdev, struct usb_hcd *hcd,
135 struct pci_dev *companion, struct usb_hcd *companion_hcd)
136 {
137 if (is_ohci_or_uhci(companion))
138 companion_hcd->self.hs_companion = NULL;
139 }
140
141 #ifdef CONFIG_PM
142
143
144 static void ehci_wait_for_companions(struct pci_dev *pdev, struct usb_hcd *hcd,
145 struct pci_dev *companion, struct usb_hcd *companion_hcd)
146 {
147 if (is_ohci_or_uhci(companion))
148 device_pm_wait_for_dev(&pdev->dev, &companion->dev);
149 }
150
151 #endif
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172 int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
173 {
174 struct hc_driver *driver;
175 struct usb_hcd *hcd;
176 int retval;
177 int hcd_irq = 0;
178
179 if (usb_disabled())
180 return -ENODEV;
181
182 if (!id)
183 return -EINVAL;
184 driver = (struct hc_driver *)id->driver_data;
185 if (!driver)
186 return -EINVAL;
187
188 if (pci_enable_device(dev) < 0)
189 return -ENODEV;
190
191
192
193
194
195 if ((driver->flags & HCD_MASK) < HCD_USB3) {
196 if (!dev->irq) {
197 dev_err(&dev->dev,
198 "Found HC with no IRQ. Check BIOS/PCI %s setup!\n",
199 pci_name(dev));
200 retval = -ENODEV;
201 goto disable_pci;
202 }
203 hcd_irq = dev->irq;
204 }
205
206 hcd = usb_create_hcd(driver, &dev->dev, pci_name(dev));
207 if (!hcd) {
208 retval = -ENOMEM;
209 goto disable_pci;
210 }
211
212 hcd->amd_resume_bug = (usb_hcd_amd_remote_wakeup_quirk(dev) &&
213 driver->flags & (HCD_USB11 | HCD_USB3)) ? 1 : 0;
214
215 if (driver->flags & HCD_MEMORY) {
216
217 hcd->rsrc_start = pci_resource_start(dev, 0);
218 hcd->rsrc_len = pci_resource_len(dev, 0);
219 if (!devm_request_mem_region(&dev->dev, hcd->rsrc_start,
220 hcd->rsrc_len, driver->description)) {
221 dev_dbg(&dev->dev, "controller already in use\n");
222 retval = -EBUSY;
223 goto put_hcd;
224 }
225 hcd->regs = devm_ioremap_nocache(&dev->dev, hcd->rsrc_start,
226 hcd->rsrc_len);
227 if (hcd->regs == NULL) {
228 dev_dbg(&dev->dev, "error mapping memory\n");
229 retval = -EFAULT;
230 goto put_hcd;
231 }
232
233 } else {
234
235 int region;
236
237 for (region = 0; region < PCI_ROM_RESOURCE; region++) {
238 if (!(pci_resource_flags(dev, region) &
239 IORESOURCE_IO))
240 continue;
241
242 hcd->rsrc_start = pci_resource_start(dev, region);
243 hcd->rsrc_len = pci_resource_len(dev, region);
244 if (devm_request_region(&dev->dev, hcd->rsrc_start,
245 hcd->rsrc_len, driver->description))
246 break;
247 }
248 if (region == PCI_ROM_RESOURCE) {
249 dev_dbg(&dev->dev, "no i/o regions available\n");
250 retval = -EBUSY;
251 goto put_hcd;
252 }
253 }
254
255 pci_set_master(dev);
256
257
258 if (dev->class == CL_EHCI) {
259 down_write(&companions_rwsem);
260 dev_set_drvdata(&dev->dev, hcd);
261 for_each_companion(dev, hcd, ehci_pre_add);
262 retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
263 if (retval != 0)
264 dev_set_drvdata(&dev->dev, NULL);
265 for_each_companion(dev, hcd, ehci_post_add);
266 up_write(&companions_rwsem);
267 } else {
268 down_read(&companions_rwsem);
269 dev_set_drvdata(&dev->dev, hcd);
270 retval = usb_add_hcd(hcd, hcd_irq, IRQF_SHARED);
271 if (retval != 0)
272 dev_set_drvdata(&dev->dev, NULL);
273 else
274 for_each_companion(dev, hcd, non_ehci_add);
275 up_read(&companions_rwsem);
276 }
277
278 if (retval != 0)
279 goto put_hcd;
280 device_wakeup_enable(hcd->self.controller);
281
282 if (pci_dev_run_wake(dev))
283 pm_runtime_put_noidle(&dev->dev);
284 return retval;
285
286 put_hcd:
287 usb_put_hcd(hcd);
288 disable_pci:
289 pci_disable_device(dev);
290 dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval);
291 return retval;
292 }
293 EXPORT_SYMBOL_GPL(usb_hcd_pci_probe);
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310 void usb_hcd_pci_remove(struct pci_dev *dev)
311 {
312 struct usb_hcd *hcd;
313
314 hcd = pci_get_drvdata(dev);
315 if (!hcd)
316 return;
317
318 if (pci_dev_run_wake(dev))
319 pm_runtime_get_noresume(&dev->dev);
320
321
322
323
324
325 local_irq_disable();
326 usb_hcd_irq(0, hcd);
327 local_irq_enable();
328
329
330 if (dev->class == CL_EHCI) {
331 down_write(&companions_rwsem);
332 for_each_companion(dev, hcd, ehci_remove);
333 usb_remove_hcd(hcd);
334 dev_set_drvdata(&dev->dev, NULL);
335 up_write(&companions_rwsem);
336 } else {
337
338 down_read(&companions_rwsem);
339 hcd->self.hs_companion = NULL;
340 usb_remove_hcd(hcd);
341 dev_set_drvdata(&dev->dev, NULL);
342 up_read(&companions_rwsem);
343 }
344 usb_put_hcd(hcd);
345 pci_disable_device(dev);
346 }
347 EXPORT_SYMBOL_GPL(usb_hcd_pci_remove);
348
349
350
351
352
353 void usb_hcd_pci_shutdown(struct pci_dev *dev)
354 {
355 struct usb_hcd *hcd;
356
357 hcd = pci_get_drvdata(dev);
358 if (!hcd)
359 return;
360
361 if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) &&
362 hcd->driver->shutdown) {
363 hcd->driver->shutdown(hcd);
364 if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
365 free_irq(hcd->irq, hcd);
366 pci_disable_device(dev);
367 }
368 }
369 EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown);
370
371 #ifdef CONFIG_PM
372
373 #ifdef CONFIG_PPC_PMAC
374 static void powermac_set_asic(struct pci_dev *pci_dev, int enable)
375 {
376
377 if (machine_is(powermac)) {
378 struct device_node *of_node;
379
380 of_node = pci_device_to_OF_node(pci_dev);
381 if (of_node)
382 pmac_call_feature(PMAC_FTR_USB_ENABLE,
383 of_node, 0, enable);
384 }
385 }
386
387 #else
388
389 static inline void powermac_set_asic(struct pci_dev *pci_dev, int enable)
390 {}
391
392 #endif
393
394 static int check_root_hub_suspended(struct device *dev)
395 {
396 struct usb_hcd *hcd = dev_get_drvdata(dev);
397
398 if (HCD_RH_RUNNING(hcd)) {
399 dev_warn(dev, "Root hub is not suspended\n");
400 return -EBUSY;
401 }
402 if (hcd->shared_hcd) {
403 hcd = hcd->shared_hcd;
404 if (HCD_RH_RUNNING(hcd)) {
405 dev_warn(dev, "Secondary root hub is not suspended\n");
406 return -EBUSY;
407 }
408 }
409 return 0;
410 }
411
412 static int suspend_common(struct device *dev, bool do_wakeup)
413 {
414 struct pci_dev *pci_dev = to_pci_dev(dev);
415 struct usb_hcd *hcd = pci_get_drvdata(pci_dev);
416 int retval;
417
418
419
420
421
422
423 retval = check_root_hub_suspended(dev);
424 if (retval)
425 return retval;
426
427 if (hcd->driver->pci_suspend && !HCD_DEAD(hcd)) {
428
429
430
431 if (do_wakeup && HCD_WAKEUP_PENDING(hcd))
432 return -EBUSY;
433 if (do_wakeup && hcd->shared_hcd &&
434 HCD_WAKEUP_PENDING(hcd->shared_hcd))
435 return -EBUSY;
436 retval = hcd->driver->pci_suspend(hcd, do_wakeup);
437 suspend_report_result(hcd->driver->pci_suspend, retval);
438
439
440 if ((retval == 0 && do_wakeup && HCD_WAKEUP_PENDING(hcd)) ||
441 (retval == 0 && do_wakeup && hcd->shared_hcd &&
442 HCD_WAKEUP_PENDING(hcd->shared_hcd))) {
443 if (hcd->driver->pci_resume)
444 hcd->driver->pci_resume(hcd, false);
445 retval = -EBUSY;
446 }
447 if (retval)
448 return retval;
449 }
450
451
452
453
454
455 if (!hcd->msix_enabled)
456 synchronize_irq(pci_dev->irq);
457
458
459
460
461
462
463 pci_disable_device(pci_dev);
464 return retval;
465 }
466
467 static int resume_common(struct device *dev, int event)
468 {
469 struct pci_dev *pci_dev = to_pci_dev(dev);
470 struct usb_hcd *hcd = pci_get_drvdata(pci_dev);
471 int retval;
472
473 if (HCD_RH_RUNNING(hcd) ||
474 (hcd->shared_hcd &&
475 HCD_RH_RUNNING(hcd->shared_hcd))) {
476 dev_dbg(dev, "can't resume, not suspended!\n");
477 return 0;
478 }
479
480 retval = pci_enable_device(pci_dev);
481 if (retval < 0) {
482 dev_err(dev, "can't re-enable after resume, %d!\n", retval);
483 return retval;
484 }
485
486 pci_set_master(pci_dev);
487
488 if (hcd->driver->pci_resume && !HCD_DEAD(hcd)) {
489
490
491
492
493
494
495 if (pci_dev->class == CL_EHCI && event != PM_EVENT_AUTO_RESUME)
496 for_each_companion(pci_dev, hcd,
497 ehci_wait_for_companions);
498
499 retval = hcd->driver->pci_resume(hcd,
500 event == PM_EVENT_RESTORE);
501 if (retval) {
502 dev_err(dev, "PCI post-resume error %d!\n", retval);
503 usb_hc_died(hcd);
504 }
505 }
506 return retval;
507 }
508
509 #ifdef CONFIG_PM_SLEEP
510
511 static int hcd_pci_suspend(struct device *dev)
512 {
513 return suspend_common(dev, device_may_wakeup(dev));
514 }
515
516 static int hcd_pci_suspend_noirq(struct device *dev)
517 {
518 struct pci_dev *pci_dev = to_pci_dev(dev);
519 struct usb_hcd *hcd = pci_get_drvdata(pci_dev);
520 int retval;
521
522 retval = check_root_hub_suspended(dev);
523 if (retval)
524 return retval;
525
526 pci_save_state(pci_dev);
527
528
529
530
531
532 if (HCD_DEAD(hcd))
533 device_set_wakeup_enable(dev, 0);
534 dev_dbg(dev, "wakeup: %d\n", device_may_wakeup(dev));
535
536
537
538
539 retval = pci_prepare_to_sleep(pci_dev);
540 if (retval == -EIO) {
541 dev_dbg(dev, "--> PCI D0 legacy\n");
542 retval = 0;
543 } else if (retval == 0) {
544 dev_dbg(dev, "--> PCI %s\n",
545 pci_power_name(pci_dev->current_state));
546 } else {
547 suspend_report_result(pci_prepare_to_sleep, retval);
548 return retval;
549 }
550
551 powermac_set_asic(pci_dev, 0);
552 return retval;
553 }
554
555 static int hcd_pci_resume_noirq(struct device *dev)
556 {
557 powermac_set_asic(to_pci_dev(dev), 1);
558 return 0;
559 }
560
561 static int hcd_pci_resume(struct device *dev)
562 {
563 return resume_common(dev, PM_EVENT_RESUME);
564 }
565
566 static int hcd_pci_restore(struct device *dev)
567 {
568 return resume_common(dev, PM_EVENT_RESTORE);
569 }
570
571 #else
572
573 #define hcd_pci_suspend NULL
574 #define hcd_pci_suspend_noirq NULL
575 #define hcd_pci_resume_noirq NULL
576 #define hcd_pci_resume NULL
577 #define hcd_pci_restore NULL
578
579 #endif
580
581 static int hcd_pci_runtime_suspend(struct device *dev)
582 {
583 int retval;
584
585 retval = suspend_common(dev, true);
586 if (retval == 0)
587 powermac_set_asic(to_pci_dev(dev), 0);
588 dev_dbg(dev, "hcd_pci_runtime_suspend: %d\n", retval);
589 return retval;
590 }
591
592 static int hcd_pci_runtime_resume(struct device *dev)
593 {
594 int retval;
595
596 powermac_set_asic(to_pci_dev(dev), 1);
597 retval = resume_common(dev, PM_EVENT_AUTO_RESUME);
598 dev_dbg(dev, "hcd_pci_runtime_resume: %d\n", retval);
599 return retval;
600 }
601
602 const struct dev_pm_ops usb_hcd_pci_pm_ops = {
603 .suspend = hcd_pci_suspend,
604 .suspend_noirq = hcd_pci_suspend_noirq,
605 .resume_noirq = hcd_pci_resume_noirq,
606 .resume = hcd_pci_resume,
607 .freeze = check_root_hub_suspended,
608 .freeze_noirq = check_root_hub_suspended,
609 .thaw_noirq = NULL,
610 .thaw = NULL,
611 .poweroff = hcd_pci_suspend,
612 .poweroff_noirq = hcd_pci_suspend_noirq,
613 .restore_noirq = hcd_pci_resume_noirq,
614 .restore = hcd_pci_restore,
615 .runtime_suspend = hcd_pci_runtime_suspend,
616 .runtime_resume = hcd_pci_runtime_resume,
617 };
618 EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops);
619
620 #endif