Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 05768918b9a122ce21bd55950df5054ff6c57f28

Authored by Alan Stern
Committed by Greg Kroah-Hartman
1 parent 4e9c8e5c58
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

USB: improve port transitions when EHCI starts up 

It seems to be getting more common recently for EHCI host controllers
to be probed after their companion UHCI or OHCI controllers.  This may
be caused partly by splitting the ehci-pci driver out from ehci-hcd,
or it may be caused by changes in the way the kernel does driver
probing.

Regardless, it has a tendency to cause problems.  When an EHCI
controller is initialized, it takes ownership of all the ports away
from the companions.  In effect, it forcefully disconnects all the USB
devices that may already be using a companion controller.

This patch (as1672b) tries to make the transition more orderly by
deconfiguring the root hubs for all the companion controllers before
initializing the EHCI controller, and reconfiguring them afterward.
The result is a soft disconnect rather than a hard one.

Internally, the patch refactors the code involved in associating EHCI
controllers with their companions.  The old approach, in which a
single function is called with an argument telling it what to do (the
companion_action enum), has been replaced with a scheme using multiple
callback functions, each performing a single task.

This patch won't solve all the problems people encounter when their
EHCI controllers start up, but it will at least reduce the number of
error messages generated by the unexpected disconnections.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Tested-by: Jenya Y <jy.gerstmaier@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 129 additions and 85 deletions Inline Diff

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