USB: fix codingstyle issues in drivers/usb/core/hcd-pci.c

Fixes a number of coding style issues in the hcd-pci.c file.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

+67 -62
+67 -62
drivers/usb/core/hcd-pci.c
··· 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 ··· 55 * 56 * Store this function in the HCD's struct pci_driver as probe(). 57 */ 58 - int usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id) 59 { 60 struct hc_driver *driver; 61 struct usb_hcd *hcd; ··· 64 if (usb_disabled()) 65 return -ENODEV; 66 67 - if (!id || !(driver = (struct hc_driver *) id->driver_data)) 68 return -EINVAL; 69 70 - if (pci_enable_device (dev) < 0) 71 return -ENODEV; 72 dev->current_state = PCI_D0; 73 dev->dev.power.power_state = PMSG_ON; 74 - 75 - if (!dev->irq) { 76 - dev_err (&dev->dev, 77 "Found HC with no IRQ. Check BIOS/PCI %s setup!\n", 78 pci_name(dev)); 79 - retval = -ENODEV; 80 goto err1; 81 - } 82 83 - hcd = usb_create_hcd (driver, &dev->dev, pci_name(dev)); 84 if (!hcd) { 85 retval = -ENOMEM; 86 goto err1; 87 } 88 89 - if (driver->flags & HCD_MEMORY) { // EHCI, OHCI 90 - hcd->rsrc_start = pci_resource_start (dev, 0); 91 - hcd->rsrc_len = pci_resource_len (dev, 0); 92 - if (!request_mem_region (hcd->rsrc_start, hcd->rsrc_len, 93 driver->description)) { 94 - dev_dbg (&dev->dev, "controller already in use\n"); 95 retval = -EBUSY; 96 goto err2; 97 } 98 - hcd->regs = ioremap_nocache (hcd->rsrc_start, hcd->rsrc_len); 99 if (hcd->regs == NULL) { 100 - dev_dbg (&dev->dev, "error mapping memory\n"); 101 retval = -EFAULT; 102 goto err3; 103 } 104 105 - } else { // UHCI 106 int region; 107 108 for (region = 0; region < PCI_ROM_RESOURCE; region++) { 109 - if (!(pci_resource_flags (dev, region) & 110 IORESOURCE_IO)) 111 continue; 112 113 - hcd->rsrc_start = pci_resource_start (dev, region); 114 - hcd->rsrc_len = pci_resource_len (dev, region); 115 - if (request_region (hcd->rsrc_start, hcd->rsrc_len, 116 driver->description)) 117 break; 118 } 119 if (region == PCI_ROM_RESOURCE) { 120 - dev_dbg (&dev->dev, "no i/o regions available\n"); 121 retval = -EBUSY; 122 goto err1; 123 } 124 } 125 126 - pci_set_master (dev); 127 128 retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED); 129 if (retval != 0) ··· 137 138 err4: 139 if (driver->flags & HCD_MEMORY) { 140 - iounmap (hcd->regs); 141 err3: 142 - release_mem_region (hcd->rsrc_start, hcd->rsrc_len); 143 } else 144 - release_region (hcd->rsrc_start, hcd->rsrc_len); 145 err2: 146 - usb_put_hcd (hcd); 147 err1: 148 - pci_disable_device (dev); 149 - dev_err (&dev->dev, "init %s fail, %d\n", pci_name(dev), retval); 150 return retval; 151 - } 152 EXPORT_SYMBOL_GPL(usb_hcd_pci_probe); 153 154 ··· 166 * 167 * Store this function in the HCD's struct pci_driver as remove(). 168 */ 169 - void usb_hcd_pci_remove (struct pci_dev *dev) 170 { 171 struct usb_hcd *hcd; 172 ··· 174 if (!hcd) 175 return; 176 177 - usb_remove_hcd (hcd); 178 if (hcd->driver->flags & HCD_MEMORY) { 179 - iounmap (hcd->regs); 180 - release_mem_region (hcd->rsrc_start, hcd->rsrc_len); 181 } else { 182 - release_region (hcd->rsrc_start, hcd->rsrc_len); 183 } 184 - usb_put_hcd (hcd); 185 pci_disable_device(dev); 186 } 187 EXPORT_SYMBOL_GPL(usb_hcd_pci_remove); ··· 196 * 197 * Store this function in the HCD's struct pci_driver as suspend(). 198 */ 199 - int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message) 200 { 201 struct usb_hcd *hcd; 202 int retval = 0; ··· 251 252 /* no DMA or IRQs except when HC is active */ 253 if (dev->current_state == PCI_D0) { 254 - pci_save_state (dev); 255 - pci_disable_device (dev); 256 } 257 258 if (message.event == PM_EVENT_FREEZE || ··· 262 } 263 264 if (!has_pci_pm) { 265 - dev_dbg (hcd->self.controller, "--> PCI D0/legacy\n"); 266 goto done; 267 } 268 ··· 271 * PCI_D3 (but not PCI_D1 or PCI_D2) is allowed to reset 272 * some device state (e.g. as part of clock reinit). 273 */ 274 - retval = pci_set_power_state (dev, PCI_D3hot); 275 suspend_report_result(pci_set_power_state, retval); 276 if (retval == 0) { 277 int wake = device_can_wakeup(&hcd->self.root_hub->dev); 278 279 wake = wake && device_may_wakeup(hcd->self.controller); 280 281 - dev_dbg (hcd->self.controller, "--> PCI D3%s\n", 282 wake ? "/wakeup" : ""); 283 284 /* Ignore these return values. We rely on pci code to 285 * reject requests the hardware can't implement, rather 286 * than coding the same thing. 287 */ 288 - (void) pci_enable_wake (dev, PCI_D3hot, wake); 289 - (void) pci_enable_wake (dev, PCI_D3cold, wake); 290 } else { 291 - dev_dbg (&dev->dev, "PCI D3 suspend fail, %d\n", 292 retval); 293 - (void) usb_hcd_pci_resume (dev); 294 } 295 296 } else if (hcd->state != HC_STATE_HALT) { 297 - dev_dbg (hcd->self.controller, "hcd state %d; not suspended\n", 298 hcd->state); 299 WARN_ON(1); 300 retval = -EINVAL; ··· 309 if (machine_is(powermac)) { 310 struct device_node *of_node; 311 312 - of_node = pci_device_to_OF_node (dev); 313 if (of_node) 314 pmac_call_feature(PMAC_FTR_USB_ENABLE, 315 of_node, 0, 0); ··· 327 * 328 * Store this function in the HCD's struct pci_driver as resume(). 329 */ 330 - int usb_hcd_pci_resume (struct pci_dev *dev) 331 { 332 struct usb_hcd *hcd; 333 int retval; 334 335 hcd = pci_get_drvdata(dev); 336 if (hcd->state != HC_STATE_SUSPENDED) { 337 - dev_dbg (hcd->self.controller, 338 "can't resume, not suspended!\n"); 339 return 0; 340 } ··· 344 if (machine_is(powermac)) { 345 struct device_node *of_node; 346 347 - of_node = pci_device_to_OF_node (dev); 348 if (of_node) 349 - pmac_call_feature (PMAC_FTR_USB_ENABLE, 350 of_node, 0, 1); 351 } 352 #endif ··· 385 } 386 #endif 387 /* yes, ignore these results too... */ 388 - (void) pci_enable_wake (dev, dev->current_state, 0); 389 - (void) pci_enable_wake (dev, PCI_D3cold, 0); 390 } else { 391 /* Same basic cases: clean (powered/not), dirty */ 392 dev_dbg(hcd->self.controller, "PCI legacy resume\n"); ··· 397 * but that won't re-enable bus mastering. Yet pci_disable_device() 398 * explicitly disables bus mastering... 399 */ 400 - retval = pci_enable_device (dev); 401 if (retval < 0) { 402 - dev_err (hcd->self.controller, 403 "can't re-enable after resume, %d!\n", retval); 404 return retval; 405 } 406 - pci_set_master (dev); 407 - pci_restore_state (dev); 408 409 dev->dev.power.power_state = PMSG_ON; 410 ··· 413 if (hcd->driver->resume) { 414 retval = hcd->driver->resume(hcd); 415 if (retval) { 416 - dev_err (hcd->self.controller, 417 "PCI post-resume error %d!\n", retval); 418 - usb_hc_died (hcd); 419 } 420 } 421 ··· 429 * usb_hcd_pci_shutdown - shutdown host controller 430 * @dev: USB Host Controller being shutdown 431 */ 432 - void usb_hcd_pci_shutdown (struct pci_dev *dev) 433 { 434 struct usb_hcd *hcd; 435
··· 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 ··· 55 * 56 * Store this function in the HCD's struct pci_driver as probe(). 57 */ 58 + int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) 59 { 60 struct hc_driver *driver; 61 struct usb_hcd *hcd; ··· 64 if (usb_disabled()) 65 return -ENODEV; 66 67 + if (!id) 68 + return -EINVAL; 69 + driver = (struct hc_driver *)id->driver_data; 70 + if (!driver) 71 return -EINVAL; 72 73 + if (pci_enable_device(dev) < 0) 74 return -ENODEV; 75 dev->current_state = PCI_D0; 76 dev->dev.power.power_state = PMSG_ON; 77 + 78 + if (!dev->irq) { 79 + dev_err(&dev->dev, 80 "Found HC with no IRQ. Check BIOS/PCI %s setup!\n", 81 pci_name(dev)); 82 + retval = -ENODEV; 83 goto err1; 84 + } 85 86 + hcd = usb_create_hcd(driver, &dev->dev, pci_name(dev)); 87 if (!hcd) { 88 retval = -ENOMEM; 89 goto err1; 90 } 91 92 + if (driver->flags & HCD_MEMORY) { 93 + /* EHCI, OHCI */ 94 + hcd->rsrc_start = pci_resource_start(dev, 0); 95 + hcd->rsrc_len = pci_resource_len(dev, 0); 96 + if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, 97 driver->description)) { 98 + dev_dbg(&dev->dev, "controller already in use\n"); 99 retval = -EBUSY; 100 goto err2; 101 } 102 + hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len); 103 if (hcd->regs == NULL) { 104 + dev_dbg(&dev->dev, "error mapping memory\n"); 105 retval = -EFAULT; 106 goto err3; 107 } 108 109 + } else { 110 + /* UHCI */ 111 int region; 112 113 for (region = 0; region < PCI_ROM_RESOURCE; region++) { 114 + if (!(pci_resource_flags(dev, region) & 115 IORESOURCE_IO)) 116 continue; 117 118 + hcd->rsrc_start = pci_resource_start(dev, region); 119 + hcd->rsrc_len = pci_resource_len(dev, region); 120 + if (request_region(hcd->rsrc_start, hcd->rsrc_len, 121 driver->description)) 122 break; 123 } 124 if (region == PCI_ROM_RESOURCE) { 125 + dev_dbg(&dev->dev, "no i/o regions available\n"); 126 retval = -EBUSY; 127 goto err1; 128 } 129 } 130 131 + pci_set_master(dev); 132 133 retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED); 134 if (retval != 0) ··· 132 133 err4: 134 if (driver->flags & HCD_MEMORY) { 135 + iounmap(hcd->regs); 136 err3: 137 + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 138 } else 139 + release_region(hcd->rsrc_start, hcd->rsrc_len); 140 err2: 141 + usb_put_hcd(hcd); 142 err1: 143 + pci_disable_device(dev); 144 + dev_err(&dev->dev, "init %s fail, %d\n", pci_name(dev), retval); 145 return retval; 146 + } 147 EXPORT_SYMBOL_GPL(usb_hcd_pci_probe); 148 149 ··· 161 * 162 * Store this function in the HCD's struct pci_driver as remove(). 163 */ 164 + void usb_hcd_pci_remove(struct pci_dev *dev) 165 { 166 struct usb_hcd *hcd; 167 ··· 169 if (!hcd) 170 return; 171 172 + usb_remove_hcd(hcd); 173 if (hcd->driver->flags & HCD_MEMORY) { 174 + iounmap(hcd->regs); 175 + release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 176 } else { 177 + release_region(hcd->rsrc_start, hcd->rsrc_len); 178 } 179 + usb_put_hcd(hcd); 180 pci_disable_device(dev); 181 } 182 EXPORT_SYMBOL_GPL(usb_hcd_pci_remove); ··· 191 * 192 * Store this function in the HCD's struct pci_driver as suspend(). 193 */ 194 + int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t message) 195 { 196 struct usb_hcd *hcd; 197 int retval = 0; ··· 246 247 /* no DMA or IRQs except when HC is active */ 248 if (dev->current_state == PCI_D0) { 249 + pci_save_state(dev); 250 + pci_disable_device(dev); 251 } 252 253 if (message.event == PM_EVENT_FREEZE || ··· 257 } 258 259 if (!has_pci_pm) { 260 + dev_dbg(hcd->self.controller, "--> PCI D0/legacy\n"); 261 goto done; 262 } 263 ··· 266 * PCI_D3 (but not PCI_D1 or PCI_D2) is allowed to reset 267 * some device state (e.g. as part of clock reinit). 268 */ 269 + retval = pci_set_power_state(dev, PCI_D3hot); 270 suspend_report_result(pci_set_power_state, retval); 271 if (retval == 0) { 272 int wake = device_can_wakeup(&hcd->self.root_hub->dev); 273 274 wake = wake && device_may_wakeup(hcd->self.controller); 275 276 + dev_dbg(hcd->self.controller, "--> PCI D3%s\n", 277 wake ? "/wakeup" : ""); 278 279 /* Ignore these return values. We rely on pci code to 280 * reject requests the hardware can't implement, rather 281 * than coding the same thing. 282 */ 283 + (void) pci_enable_wake(dev, PCI_D3hot, wake); 284 + (void) pci_enable_wake(dev, PCI_D3cold, wake); 285 } else { 286 + dev_dbg(&dev->dev, "PCI D3 suspend fail, %d\n", 287 retval); 288 + (void) usb_hcd_pci_resume(dev); 289 } 290 291 } else if (hcd->state != HC_STATE_HALT) { 292 + dev_dbg(hcd->self.controller, "hcd state %d; not suspended\n", 293 hcd->state); 294 WARN_ON(1); 295 retval = -EINVAL; ··· 304 if (machine_is(powermac)) { 305 struct device_node *of_node; 306 307 + of_node = pci_device_to_OF_node(dev); 308 if (of_node) 309 pmac_call_feature(PMAC_FTR_USB_ENABLE, 310 of_node, 0, 0); ··· 322 * 323 * Store this function in the HCD's struct pci_driver as resume(). 324 */ 325 + int usb_hcd_pci_resume(struct pci_dev *dev) 326 { 327 struct usb_hcd *hcd; 328 int retval; 329 330 hcd = pci_get_drvdata(dev); 331 if (hcd->state != HC_STATE_SUSPENDED) { 332 + dev_dbg(hcd->self.controller, 333 "can't resume, not suspended!\n"); 334 return 0; 335 } ··· 339 if (machine_is(powermac)) { 340 struct device_node *of_node; 341 342 + of_node = pci_device_to_OF_node(dev); 343 if (of_node) 344 + pmac_call_feature(PMAC_FTR_USB_ENABLE, 345 of_node, 0, 1); 346 } 347 #endif ··· 380 } 381 #endif 382 /* yes, ignore these results too... */ 383 + (void) pci_enable_wake(dev, dev->current_state, 0); 384 + (void) pci_enable_wake(dev, PCI_D3cold, 0); 385 } else { 386 /* Same basic cases: clean (powered/not), dirty */ 387 dev_dbg(hcd->self.controller, "PCI legacy resume\n"); ··· 392 * but that won't re-enable bus mastering. Yet pci_disable_device() 393 * explicitly disables bus mastering... 394 */ 395 + retval = pci_enable_device(dev); 396 if (retval < 0) { 397 + dev_err(hcd->self.controller, 398 "can't re-enable after resume, %d!\n", retval); 399 return retval; 400 } 401 + pci_set_master(dev); 402 + pci_restore_state(dev); 403 404 dev->dev.power.power_state = PMSG_ON; 405 ··· 408 if (hcd->driver->resume) { 409 retval = hcd->driver->resume(hcd); 410 if (retval) { 411 + dev_err(hcd->self.controller, 412 "PCI post-resume error %d!\n", retval); 413 + usb_hc_died(hcd); 414 } 415 } 416 ··· 424 * usb_hcd_pci_shutdown - shutdown host controller 425 * @dev: USB Host Controller being shutdown 426 */ 427 + void usb_hcd_pci_shutdown(struct pci_dev *dev) 428 { 429 struct usb_hcd *hcd; 430