mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 11:41:38 -04:00
Merge master.kernel.org:/home/rmk/linux-2.6-drvmodel
This commit is contained in:
Linus Torvalds
commit
5643f000c1
95 changed files with 1501 additions and 1416 deletions
|
|
@ -896,7 +896,7 @@ dummy_gadget_release (struct device *dev)
|
|||
#endif
|
||||
}
|
||||
|
||||
static int dummy_udc_probe (struct device *dev)
|
||||
static int dummy_udc_probe (struct platform_device *dev)
|
||||
{
|
||||
struct dummy *dum = the_controller;
|
||||
int rc;
|
||||
|
|
@ -909,7 +909,7 @@ static int dummy_udc_probe (struct device *dev)
|
|||
dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
|
||||
|
||||
strcpy (dum->gadget.dev.bus_id, "gadget");
|
||||
dum->gadget.dev.parent = dev;
|
||||
dum->gadget.dev.parent = &dev->dev;
|
||||
dum->gadget.dev.release = dummy_gadget_release;
|
||||
rc = device_register (&dum->gadget.dev);
|
||||
if (rc < 0)
|
||||
|
|
@ -919,26 +919,26 @@ static int dummy_udc_probe (struct device *dev)
|
|||
usb_bus_get (&dummy_to_hcd (dum)->self);
|
||||
#endif
|
||||
|
||||
dev_set_drvdata (dev, dum);
|
||||
platform_set_drvdata (dev, dum);
|
||||
device_create_file (&dum->gadget.dev, &dev_attr_function);
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int dummy_udc_remove (struct device *dev)
|
||||
static int dummy_udc_remove (struct platform_device *dev)
|
||||
{
|
||||
struct dummy *dum = dev_get_drvdata (dev);
|
||||
struct dummy *dum = platform_get_drvdata (dev);
|
||||
|
||||
dev_set_drvdata (dev, NULL);
|
||||
platform_set_drvdata (dev, NULL);
|
||||
device_remove_file (&dum->gadget.dev, &dev_attr_function);
|
||||
device_unregister (&dum->gadget.dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dummy_udc_suspend (struct device *dev, pm_message_t state)
|
||||
static int dummy_udc_suspend (struct platform_device *dev, pm_message_t state)
|
||||
{
|
||||
struct dummy *dum = dev_get_drvdata(dev);
|
||||
struct dummy *dum = platform_get_drvdata(dev);
|
||||
|
||||
dev_dbg (dev, "%s\n", __FUNCTION__);
|
||||
dev_dbg (&dev->dev, "%s\n", __FUNCTION__);
|
||||
spin_lock_irq (&dum->lock);
|
||||
dum->udc_suspended = 1;
|
||||
set_link_state (dum);
|
||||
|
|
@ -949,29 +949,30 @@ static int dummy_udc_suspend (struct device *dev, pm_message_t state)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int dummy_udc_resume (struct device *dev)
|
||||
static int dummy_udc_resume (struct platform_device *dev)
|
||||
{
|
||||
struct dummy *dum = dev_get_drvdata(dev);
|
||||
struct dummy *dum = platform_get_drvdata(dev);
|
||||
|
||||
dev_dbg (dev, "%s\n", __FUNCTION__);
|
||||
dev_dbg (&dev->dev, "%s\n", __FUNCTION__);
|
||||
spin_lock_irq (&dum->lock);
|
||||
dum->udc_suspended = 0;
|
||||
set_link_state (dum);
|
||||
spin_unlock_irq (&dum->lock);
|
||||
|
||||
dev->power.power_state = PMSG_ON;
|
||||
dev->dev.power.power_state = PMSG_ON;
|
||||
usb_hcd_poll_rh_status (dummy_to_hcd (dum));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct device_driver dummy_udc_driver = {
|
||||
.name = (char *) gadget_name,
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver dummy_udc_driver = {
|
||||
.probe = dummy_udc_probe,
|
||||
.remove = dummy_udc_remove,
|
||||
.suspend = dummy_udc_suspend,
|
||||
.resume = dummy_udc_resume,
|
||||
.driver = {
|
||||
.name = (char *) gadget_name,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
|
@ -1898,14 +1899,14 @@ static const struct hc_driver dummy_hcd = {
|
|||
.bus_resume = dummy_bus_resume,
|
||||
};
|
||||
|
||||
static int dummy_hcd_probe (struct device *dev)
|
||||
static int dummy_hcd_probe (struct platform_device *dev)
|
||||
{
|
||||
struct usb_hcd *hcd;
|
||||
int retval;
|
||||
|
||||
dev_info (dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
|
||||
|
||||
hcd = usb_create_hcd (&dummy_hcd, dev, dev->bus_id);
|
||||
hcd = usb_create_hcd (&dummy_hcd, &dev->dev, dev->dev.bus_id);
|
||||
if (!hcd)
|
||||
return -ENOMEM;
|
||||
the_controller = hcd_to_dummy (hcd);
|
||||
|
|
@ -1918,48 +1919,49 @@ static int dummy_hcd_probe (struct device *dev)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int dummy_hcd_remove (struct device *dev)
|
||||
static int dummy_hcd_remove (struct platform_device *dev)
|
||||
{
|
||||
struct usb_hcd *hcd;
|
||||
|
||||
hcd = dev_get_drvdata (dev);
|
||||
hcd = platform_get_drvdata (dev);
|
||||
usb_remove_hcd (hcd);
|
||||
usb_put_hcd (hcd);
|
||||
the_controller = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dummy_hcd_suspend (struct device *dev, pm_message_t state)
|
||||
static int dummy_hcd_suspend (struct platform_device *dev, pm_message_t state)
|
||||
{
|
||||
struct usb_hcd *hcd;
|
||||
|
||||
dev_dbg (dev, "%s\n", __FUNCTION__);
|
||||
hcd = dev_get_drvdata (dev);
|
||||
dev_dbg (&dev->dev, "%s\n", __FUNCTION__);
|
||||
hcd = platform_get_drvdata (dev);
|
||||
|
||||
hcd->state = HC_STATE_SUSPENDED;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dummy_hcd_resume (struct device *dev)
|
||||
static int dummy_hcd_resume (struct platform_device *dev)
|
||||
{
|
||||
struct usb_hcd *hcd;
|
||||
|
||||
dev_dbg (dev, "%s\n", __FUNCTION__);
|
||||
hcd = dev_get_drvdata (dev);
|
||||
dev_dbg (&dev->dev, "%s\n", __FUNCTION__);
|
||||
hcd = platform_get_drvdata (dev);
|
||||
hcd->state = HC_STATE_RUNNING;
|
||||
|
||||
usb_hcd_poll_rh_status (hcd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct device_driver dummy_hcd_driver = {
|
||||
.name = (char *) driver_name,
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver dummy_hcd_driver = {
|
||||
.probe = dummy_hcd_probe,
|
||||
.remove = dummy_hcd_remove,
|
||||
.suspend = dummy_hcd_suspend,
|
||||
.resume = dummy_hcd_resume,
|
||||
.driver = {
|
||||
.name = (char *) driver_name,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
|
@ -1995,11 +1997,11 @@ static int __init init (void)
|
|||
if (usb_disabled ())
|
||||
return -ENODEV;
|
||||
|
||||
retval = driver_register (&dummy_hcd_driver);
|
||||
retval = platform_driver_register (&dummy_hcd_driver);
|
||||
if (retval < 0)
|
||||
return retval;
|
||||
|
||||
retval = driver_register (&dummy_udc_driver);
|
||||
retval = platform_driver_register (&dummy_udc_driver);
|
||||
if (retval < 0)
|
||||
goto err_register_udc_driver;
|
||||
|
||||
|
|
@ -2015,9 +2017,9 @@ static int __init init (void)
|
|||
err_register_udc:
|
||||
platform_device_unregister (&the_hcd_pdev);
|
||||
err_register_hcd:
|
||||
driver_unregister (&dummy_udc_driver);
|
||||
platform_driver_unregister (&dummy_udc_driver);
|
||||
err_register_udc_driver:
|
||||
driver_unregister (&dummy_hcd_driver);
|
||||
platform_driver_unregister (&dummy_hcd_driver);
|
||||
return retval;
|
||||
}
|
||||
module_init (init);
|
||||
|
|
@ -2026,7 +2028,7 @@ static void __exit cleanup (void)
|
|||
{
|
||||
platform_device_unregister (&the_udc_pdev);
|
||||
platform_device_unregister (&the_hcd_pdev);
|
||||
driver_unregister (&dummy_udc_driver);
|
||||
driver_unregister (&dummy_hcd_driver);
|
||||
platform_driver_unregister (&dummy_udc_driver);
|
||||
platform_driver_unregister (&dummy_hcd_driver);
|
||||
}
|
||||
module_exit (cleanup);
|
||||
|
|
|
|||
|
|
@ -2085,21 +2085,21 @@ static struct lh7a40x_udc memory = {
|
|||
/*
|
||||
* probe - binds to the platform device
|
||||
*/
|
||||
static int lh7a40x_udc_probe(struct device *_dev)
|
||||
static int lh7a40x_udc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct lh7a40x_udc *dev = &memory;
|
||||
int retval;
|
||||
|
||||
DEBUG("%s: %p\n", __FUNCTION__, _dev);
|
||||
DEBUG("%s: %p\n", __FUNCTION__, pdev);
|
||||
|
||||
spin_lock_init(&dev->lock);
|
||||
dev->dev = _dev;
|
||||
dev->dev = &pdev->dev;
|
||||
|
||||
device_initialize(&dev->gadget.dev);
|
||||
dev->gadget.dev.parent = _dev;
|
||||
dev->gadget.dev.parent = &pdev->dev;
|
||||
|
||||
the_controller = dev;
|
||||
dev_set_drvdata(_dev, dev);
|
||||
platform_set_drvdata(pdev, dev);
|
||||
|
||||
udc_disable(dev);
|
||||
udc_reinit(dev);
|
||||
|
|
@ -2119,11 +2119,11 @@ static int lh7a40x_udc_probe(struct device *_dev)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static int lh7a40x_udc_remove(struct device *_dev)
|
||||
static int lh7a40x_udc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct lh7a40x_udc *dev = _dev->driver_data;
|
||||
struct lh7a40x_udc *dev = platform_get_drvdata(pdev);
|
||||
|
||||
DEBUG("%s: %p\n", __FUNCTION__, dev);
|
||||
DEBUG("%s: %p\n", __FUNCTION__, pdev);
|
||||
|
||||
udc_disable(dev);
|
||||
remove_proc_files();
|
||||
|
|
@ -2131,7 +2131,7 @@ static int lh7a40x_udc_remove(struct device *_dev)
|
|||
|
||||
free_irq(IRQ_USBINTR, dev);
|
||||
|
||||
dev_set_drvdata(_dev, 0);
|
||||
platform_set_drvdata(pdev, 0);
|
||||
|
||||
the_controller = 0;
|
||||
|
||||
|
|
@ -2140,26 +2140,27 @@ static int lh7a40x_udc_remove(struct device *_dev)
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static struct device_driver udc_driver = {
|
||||
.name = (char *)driver_name,
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver udc_driver = {
|
||||
.probe = lh7a40x_udc_probe,
|
||||
.remove = lh7a40x_udc_remove
|
||||
/* FIXME power management support */
|
||||
/* .suspend = ... disable UDC */
|
||||
/* .resume = ... re-enable UDC */
|
||||
.driver = {
|
||||
.name = (char *)driver_name,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init udc_init(void)
|
||||
{
|
||||
DEBUG("%s: %s version %s\n", __FUNCTION__, driver_name, DRIVER_VERSION);
|
||||
return driver_register(&udc_driver);
|
||||
return platform_driver_register(&udc_driver);
|
||||
}
|
||||
|
||||
static void __exit udc_exit(void)
|
||||
{
|
||||
driver_unregister(&udc_driver);
|
||||
platform_driver_unregister(&udc_driver);
|
||||
}
|
||||
|
||||
module_init(udc_init);
|
||||
|
|
|
|||
|
|
@ -2707,18 +2707,17 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int __init omap_udc_probe(struct device *dev)
|
||||
static int __init omap_udc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *odev = to_platform_device(dev);
|
||||
int status = -ENODEV;
|
||||
int hmc;
|
||||
struct otg_transceiver *xceiv = NULL;
|
||||
const char *type = NULL;
|
||||
struct omap_usb_config *config = dev->platform_data;
|
||||
struct omap_usb_config *config = pdev->dev.platform_data;
|
||||
|
||||
/* NOTE: "knows" the order of the resources! */
|
||||
if (!request_mem_region(odev->resource[0].start,
|
||||
odev->resource[0].end - odev->resource[0].start + 1,
|
||||
if (!request_mem_region(pdev->resource[0].start,
|
||||
pdev->resource[0].end - pdev->resource[0].start + 1,
|
||||
driver_name)) {
|
||||
DBG("request_mem_region failed\n");
|
||||
return -EBUSY;
|
||||
|
|
@ -2803,7 +2802,7 @@ bad_on_1710:
|
|||
INFO("hmc mode %d, %s transceiver\n", hmc, type);
|
||||
|
||||
/* a "gadget" abstracts/virtualizes the controller */
|
||||
status = omap_udc_setup(odev, xceiv);
|
||||
status = omap_udc_setup(pdev, xceiv);
|
||||
if (status) {
|
||||
goto cleanup0;
|
||||
}
|
||||
|
|
@ -2821,28 +2820,28 @@ bad_on_1710:
|
|||
udc->clr_halt = UDC_RESET_EP;
|
||||
|
||||
/* USB general purpose IRQ: ep0, state changes, dma, etc */
|
||||
status = request_irq(odev->resource[1].start, omap_udc_irq,
|
||||
status = request_irq(pdev->resource[1].start, omap_udc_irq,
|
||||
SA_SAMPLE_RANDOM, driver_name, udc);
|
||||
if (status != 0) {
|
||||
ERR( "can't get irq %ld, err %d\n",
|
||||
odev->resource[1].start, status);
|
||||
pdev->resource[1].start, status);
|
||||
goto cleanup1;
|
||||
}
|
||||
|
||||
/* USB "non-iso" IRQ (PIO for all but ep0) */
|
||||
status = request_irq(odev->resource[2].start, omap_udc_pio_irq,
|
||||
status = request_irq(pdev->resource[2].start, omap_udc_pio_irq,
|
||||
SA_SAMPLE_RANDOM, "omap_udc pio", udc);
|
||||
if (status != 0) {
|
||||
ERR( "can't get irq %ld, err %d\n",
|
||||
odev->resource[2].start, status);
|
||||
pdev->resource[2].start, status);
|
||||
goto cleanup2;
|
||||
}
|
||||
#ifdef USE_ISO
|
||||
status = request_irq(odev->resource[3].start, omap_udc_iso_irq,
|
||||
status = request_irq(pdev->resource[3].start, omap_udc_iso_irq,
|
||||
SA_INTERRUPT, "omap_udc iso", udc);
|
||||
if (status != 0) {
|
||||
ERR("can't get irq %ld, err %d\n",
|
||||
odev->resource[3].start, status);
|
||||
pdev->resource[3].start, status);
|
||||
goto cleanup3;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -2853,11 +2852,11 @@ bad_on_1710:
|
|||
|
||||
#ifdef USE_ISO
|
||||
cleanup3:
|
||||
free_irq(odev->resource[2].start, udc);
|
||||
free_irq(pdev->resource[2].start, udc);
|
||||
#endif
|
||||
|
||||
cleanup2:
|
||||
free_irq(odev->resource[1].start, udc);
|
||||
free_irq(pdev->resource[1].start, udc);
|
||||
|
||||
cleanup1:
|
||||
kfree (udc);
|
||||
|
|
@ -2866,14 +2865,13 @@ cleanup1:
|
|||
cleanup0:
|
||||
if (xceiv)
|
||||
put_device(xceiv->dev);
|
||||
release_mem_region(odev->resource[0].start,
|
||||
odev->resource[0].end - odev->resource[0].start + 1);
|
||||
release_mem_region(pdev->resource[0].start,
|
||||
pdev->resource[0].end - pdev->resource[0].start + 1);
|
||||
return status;
|
||||
}
|
||||
|
||||
static int __exit omap_udc_remove(struct device *dev)
|
||||
static int __exit omap_udc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *odev = to_platform_device(dev);
|
||||
DECLARE_COMPLETION(done);
|
||||
|
||||
if (!udc)
|
||||
|
|
@ -2891,13 +2889,13 @@ static int __exit omap_udc_remove(struct device *dev)
|
|||
remove_proc_file();
|
||||
|
||||
#ifdef USE_ISO
|
||||
free_irq(odev->resource[3].start, udc);
|
||||
free_irq(pdev->resource[3].start, udc);
|
||||
#endif
|
||||
free_irq(odev->resource[2].start, udc);
|
||||
free_irq(odev->resource[1].start, udc);
|
||||
free_irq(pdev->resource[2].start, udc);
|
||||
free_irq(pdev->resource[1].start, udc);
|
||||
|
||||
release_mem_region(odev->resource[0].start,
|
||||
odev->resource[0].end - odev->resource[0].start + 1);
|
||||
release_mem_region(pdev->resource[0].start,
|
||||
pdev->resource[0].end - pdev->resource[0].start + 1);
|
||||
|
||||
device_unregister(&udc->gadget.dev);
|
||||
wait_for_completion(&done);
|
||||
|
|
@ -2915,7 +2913,7 @@ static int __exit omap_udc_remove(struct device *dev)
|
|||
* may involve talking to an external transceiver (e.g. isp1301).
|
||||
*/
|
||||
|
||||
static int omap_udc_suspend(struct device *dev, pm_message_t message)
|
||||
static int omap_udc_suspend(struct platform_device *dev, pm_message_t message)
|
||||
{
|
||||
u32 devstat;
|
||||
|
||||
|
|
@ -2935,7 +2933,7 @@ static int omap_udc_suspend(struct device *dev, pm_message_t message)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int omap_udc_resume(struct device *dev)
|
||||
static int omap_udc_resume(struct platform_device *dev)
|
||||
{
|
||||
DBG("resume + wakeup/SRP\n");
|
||||
omap_pullup(&udc->gadget, 1);
|
||||
|
|
@ -2947,14 +2945,15 @@ static int omap_udc_resume(struct device *dev)
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static struct device_driver udc_driver = {
|
||||
.name = (char *) driver_name,
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver udc_driver = {
|
||||
.probe = omap_udc_probe,
|
||||
.remove = __exit_p(omap_udc_remove),
|
||||
.suspend = omap_udc_suspend,
|
||||
.resume = omap_udc_resume,
|
||||
.driver = {
|
||||
.owner = THIS_MODULE,
|
||||
.name = (char *) driver_name,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init udc_init(void)
|
||||
|
|
@ -2965,13 +2964,13 @@ static int __init udc_init(void)
|
|||
#endif
|
||||
"%s\n", driver_desc,
|
||||
use_dma ? " (dma)" : "");
|
||||
return driver_register(&udc_driver);
|
||||
return platform_driver_register(&udc_driver);
|
||||
}
|
||||
module_init(udc_init);
|
||||
|
||||
static void __exit udc_exit(void)
|
||||
{
|
||||
driver_unregister(&udc_driver);
|
||||
platform_driver_unregister(&udc_driver);
|
||||
}
|
||||
module_exit(udc_exit);
|
||||
|
||||
|
|
|
|||
|
|
@ -2432,7 +2432,7 @@ static struct pxa2xx_udc memory = {
|
|||
/*
|
||||
* probe - binds to the platform device
|
||||
*/
|
||||
static int __init pxa2xx_udc_probe(struct device *_dev)
|
||||
static int __init pxa2xx_udc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct pxa2xx_udc *dev = &memory;
|
||||
int retval, out_dma = 1;
|
||||
|
|
@ -2495,19 +2495,19 @@ static int __init pxa2xx_udc_probe(struct device *_dev)
|
|||
#endif
|
||||
|
||||
/* other non-static parts of init */
|
||||
dev->dev = _dev;
|
||||
dev->mach = _dev->platform_data;
|
||||
dev->dev = &pdev->dev;
|
||||
dev->mach = pdev->dev.platform_data;
|
||||
|
||||
init_timer(&dev->timer);
|
||||
dev->timer.function = udc_watchdog;
|
||||
dev->timer.data = (unsigned long) dev;
|
||||
|
||||
device_initialize(&dev->gadget.dev);
|
||||
dev->gadget.dev.parent = _dev;
|
||||
dev->gadget.dev.dma_mask = _dev->dma_mask;
|
||||
dev->gadget.dev.parent = &pdev->dev;
|
||||
dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
|
||||
|
||||
the_controller = dev;
|
||||
dev_set_drvdata(_dev, dev);
|
||||
platform_set_drvdata(pdev, dev);
|
||||
|
||||
udc_disable(dev);
|
||||
udc_reinit(dev);
|
||||
|
|
@ -2559,14 +2559,14 @@ lubbock_fail0:
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void pxa2xx_udc_shutdown(struct device *_dev)
|
||||
static void pxa2xx_udc_shutdown(struct platform_device *_dev)
|
||||
{
|
||||
pullup_off();
|
||||
}
|
||||
|
||||
static int __exit pxa2xx_udc_remove(struct device *_dev)
|
||||
static int __exit pxa2xx_udc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct pxa2xx_udc *dev = dev_get_drvdata(_dev);
|
||||
struct pxa2xx_udc *dev = platform_get_drvdata(pdev);
|
||||
|
||||
udc_disable(dev);
|
||||
remove_proc_files();
|
||||
|
|
@ -2580,7 +2580,7 @@ static int __exit pxa2xx_udc_remove(struct device *_dev)
|
|||
free_irq(LUBBOCK_USB_DISC_IRQ, dev);
|
||||
free_irq(LUBBOCK_USB_IRQ, dev);
|
||||
}
|
||||
dev_set_drvdata(_dev, NULL);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
the_controller = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -2601,9 +2601,9 @@ static int __exit pxa2xx_udc_remove(struct device *_dev)
|
|||
* VBUS IRQs should probably be ignored so that the PXA device just acts
|
||||
* "dead" to USB hosts until system resume.
|
||||
*/
|
||||
static int pxa2xx_udc_suspend(struct device *dev, pm_message_t state)
|
||||
static int pxa2xx_udc_suspend(struct platform_device *dev, pm_message_t state)
|
||||
{
|
||||
struct pxa2xx_udc *udc = dev_get_drvdata(dev);
|
||||
struct pxa2xx_udc *udc = platform_get_drvdata(dev);
|
||||
|
||||
if (!udc->mach->udc_command)
|
||||
WARN("USB host won't detect disconnect!\n");
|
||||
|
|
@ -2612,9 +2612,9 @@ static int pxa2xx_udc_suspend(struct device *dev, pm_message_t state)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int pxa2xx_udc_resume(struct device *dev)
|
||||
static int pxa2xx_udc_resume(struct platform_device *dev)
|
||||
{
|
||||
struct pxa2xx_udc *udc = dev_get_drvdata(dev);
|
||||
struct pxa2xx_udc *udc = platform_get_drvdata(dev);
|
||||
|
||||
pullup(udc, 1);
|
||||
|
||||
|
|
@ -2628,27 +2628,28 @@ static int pxa2xx_udc_resume(struct device *dev)
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static struct device_driver udc_driver = {
|
||||
.name = "pxa2xx-udc",
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver udc_driver = {
|
||||
.probe = pxa2xx_udc_probe,
|
||||
.shutdown = pxa2xx_udc_shutdown,
|
||||
.remove = __exit_p(pxa2xx_udc_remove),
|
||||
.suspend = pxa2xx_udc_suspend,
|
||||
.resume = pxa2xx_udc_resume,
|
||||
.driver = {
|
||||
.owner = THIS_MODULE,
|
||||
.name = "pxa2xx-udc",
|
||||
},
|
||||
};
|
||||
|
||||
static int __init udc_init(void)
|
||||
{
|
||||
printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION);
|
||||
return driver_register(&udc_driver);
|
||||
return platform_driver_register(&udc_driver);
|
||||
}
|
||||
module_init(udc_init);
|
||||
|
||||
static void __exit udc_exit(void)
|
||||
{
|
||||
driver_unregister(&udc_driver);
|
||||
platform_driver_unregister(&udc_driver);
|
||||
}
|
||||
module_exit(udc_exit);
|
||||
|
||||
|
|
|
|||
|
|
@ -1633,17 +1633,15 @@ static struct hc_driver isp116x_hc_driver = {
|
|||
|
||||
/*----------------------------------------------------------------*/
|
||||
|
||||
static int __init_or_module isp116x_remove(struct device *dev)
|
||||
static int __init_or_module isp116x_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(pdev);
|
||||
struct isp116x *isp116x;
|
||||
struct platform_device *pdev;
|
||||
struct resource *res;
|
||||
|
||||
if (!hcd)
|
||||
return 0;
|
||||
isp116x = hcd_to_isp116x(hcd);
|
||||
pdev = container_of(dev, struct platform_device, dev);
|
||||
remove_debug_file(isp116x);
|
||||
usb_remove_hcd(hcd);
|
||||
|
||||
|
|
@ -1660,18 +1658,16 @@ static int __init_or_module isp116x_remove(struct device *dev)
|
|||
|
||||
#define resource_len(r) (((r)->end - (r)->start) + 1)
|
||||
|
||||
static int __init isp116x_probe(struct device *dev)
|
||||
static int __init isp116x_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct usb_hcd *hcd;
|
||||
struct isp116x *isp116x;
|
||||
struct platform_device *pdev;
|
||||
struct resource *addr, *data;
|
||||
void __iomem *addr_reg;
|
||||
void __iomem *data_reg;
|
||||
int irq;
|
||||
int ret = 0;
|
||||
|
||||
pdev = container_of(dev, struct platform_device, dev);
|
||||
if (pdev->num_resources < 3) {
|
||||
ret = -ENODEV;
|
||||
goto err1;
|
||||
|
|
@ -1685,7 +1681,7 @@ static int __init isp116x_probe(struct device *dev)
|
|||
goto err1;
|
||||
}
|
||||
|
||||
if (dev->dma_mask) {
|
||||
if (pdev->dev.dma_mask) {
|
||||
DBG("DMA not supported\n");
|
||||
ret = -EINVAL;
|
||||
goto err1;
|
||||
|
|
@ -1711,7 +1707,7 @@ static int __init isp116x_probe(struct device *dev)
|
|||
}
|
||||
|
||||
/* allocate and initialize hcd */
|
||||
hcd = usb_create_hcd(&isp116x_hc_driver, dev, dev->bus_id);
|
||||
hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
|
||||
if (!hcd) {
|
||||
ret = -ENOMEM;
|
||||
goto err5;
|
||||
|
|
@ -1723,7 +1719,7 @@ static int __init isp116x_probe(struct device *dev)
|
|||
isp116x->addr_reg = addr_reg;
|
||||
spin_lock_init(&isp116x->lock);
|
||||
INIT_LIST_HEAD(&isp116x->async);
|
||||
isp116x->board = dev->platform_data;
|
||||
isp116x->board = pdev->dev.platform_data;
|
||||
|
||||
if (!isp116x->board) {
|
||||
ERR("Platform data structure not initialized\n");
|
||||
|
|
@ -1764,13 +1760,13 @@ static int __init isp116x_probe(struct device *dev)
|
|||
/*
|
||||
Suspend of platform device
|
||||
*/
|
||||
static int isp116x_suspend(struct device *dev, pm_message_t state)
|
||||
static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
VDBG("%s: state %x\n", __func__, state);
|
||||
|
||||
dev->power.power_state = state;
|
||||
dev->dev.power.power_state = state;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1778,13 +1774,13 @@ static int isp116x_suspend(struct device *dev, pm_message_t state)
|
|||
/*
|
||||
Resume platform device
|
||||
*/
|
||||
static int isp116x_resume(struct device *dev)
|
||||
static int isp116x_resume(struct platform_device *dev)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
VDBG("%s: state %x\n", __func__, dev->power.power_state);
|
||||
VDBG("%s: state %x\n", __func__, dev->dev.power.power_state);
|
||||
|
||||
dev->power.power_state = PMSG_ON;
|
||||
dev->dev.power.power_state = PMSG_ON;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1796,13 +1792,14 @@ static int isp116x_resume(struct device *dev)
|
|||
|
||||
#endif
|
||||
|
||||
static struct device_driver isp116x_driver = {
|
||||
.name = (char *)hcd_name,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver isp116x_driver = {
|
||||
.probe = isp116x_probe,
|
||||
.remove = isp116x_remove,
|
||||
.suspend = isp116x_suspend,
|
||||
.resume = isp116x_resume,
|
||||
.driver = {
|
||||
.name = (char *)hcd_name,
|
||||
},
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------*/
|
||||
|
|
@ -1813,14 +1810,14 @@ static int __init isp116x_init(void)
|
|||
return -ENODEV;
|
||||
|
||||
INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
|
||||
return driver_register(&isp116x_driver);
|
||||
return platform_driver_register(&isp116x_driver);
|
||||
}
|
||||
|
||||
module_init(isp116x_init);
|
||||
|
||||
static void __exit isp116x_cleanup(void)
|
||||
{
|
||||
driver_unregister(&isp116x_driver);
|
||||
platform_driver_unregister(&isp116x_driver);
|
||||
}
|
||||
|
||||
module_exit(isp116x_cleanup);
|
||||
|
|
|
|||
|
|
@ -225,9 +225,8 @@ static const struct hc_driver ohci_au1xxx_hc_driver = {
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int ohci_hcd_au1xxx_drv_probe(struct device *dev)
|
||||
static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
int ret;
|
||||
|
||||
pr_debug ("In ohci_hcd_au1xxx_drv_probe");
|
||||
|
|
@ -239,39 +238,37 @@ static int ohci_hcd_au1xxx_drv_probe(struct device *dev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int ohci_hcd_au1xxx_drv_remove(struct device *dev)
|
||||
static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(pdev);
|
||||
|
||||
usb_hcd_au1xxx_remove(hcd, pdev);
|
||||
return 0;
|
||||
}
|
||||
/*TBD*/
|
||||
/*static int ohci_hcd_au1xxx_drv_suspend(struct device *dev)
|
||||
/*static int ohci_hcd_au1xxx_drv_suspend(struct platform_device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
static int ohci_hcd_au1xxx_drv_resume(struct device *dev)
|
||||
static int ohci_hcd_au1xxx_drv_resume(struct platform_device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
static struct device_driver ohci_hcd_au1xxx_driver = {
|
||||
.name = "au1xxx-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver ohci_hcd_au1xxx_driver = {
|
||||
.probe = ohci_hcd_au1xxx_drv_probe,
|
||||
.remove = ohci_hcd_au1xxx_drv_remove,
|
||||
/*.suspend = ohci_hcd_au1xxx_drv_suspend, */
|
||||
/*.resume = ohci_hcd_au1xxx_drv_resume, */
|
||||
.driver = {
|
||||
.name = "au1xxx-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init ohci_hcd_au1xxx_init (void)
|
||||
|
|
@ -280,12 +277,12 @@ static int __init ohci_hcd_au1xxx_init (void)
|
|||
pr_debug ("block sizes: ed %d td %d\n",
|
||||
sizeof (struct ed), sizeof (struct td));
|
||||
|
||||
return driver_register(&ohci_hcd_au1xxx_driver);
|
||||
return platform_driver_register(&ohci_hcd_au1xxx_driver);
|
||||
}
|
||||
|
||||
static void __exit ohci_hcd_au1xxx_cleanup (void)
|
||||
{
|
||||
driver_unregister(&ohci_hcd_au1xxx_driver);
|
||||
platform_driver_unregister(&ohci_hcd_au1xxx_driver);
|
||||
}
|
||||
|
||||
module_init (ohci_hcd_au1xxx_init);
|
||||
|
|
|
|||
|
|
@ -204,9 +204,8 @@ static const struct hc_driver ohci_lh7a404_hc_driver = {
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int ohci_hcd_lh7a404_drv_probe(struct device *dev)
|
||||
static int ohci_hcd_lh7a404_drv_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
int ret;
|
||||
|
||||
pr_debug ("In ohci_hcd_lh7a404_drv_probe");
|
||||
|
|
@ -218,40 +217,38 @@ static int ohci_hcd_lh7a404_drv_probe(struct device *dev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int ohci_hcd_lh7a404_drv_remove(struct device *dev)
|
||||
static int ohci_hcd_lh7a404_drv_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
|
||||
usb_hcd_lh7a404_remove(hcd, pdev);
|
||||
return 0;
|
||||
}
|
||||
/*TBD*/
|
||||
/*static int ohci_hcd_lh7a404_drv_suspend(struct device *dev)
|
||||
/*static int ohci_hcd_lh7a404_drv_suspend(struct platform_device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
static int ohci_hcd_lh7a404_drv_resume(struct device *dev)
|
||||
static int ohci_hcd_lh7a404_drv_resume(struct platform_device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
static struct device_driver ohci_hcd_lh7a404_driver = {
|
||||
.name = "lh7a404-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver ohci_hcd_lh7a404_driver = {
|
||||
.probe = ohci_hcd_lh7a404_drv_probe,
|
||||
.remove = ohci_hcd_lh7a404_drv_remove,
|
||||
/*.suspend = ohci_hcd_lh7a404_drv_suspend, */
|
||||
/*.resume = ohci_hcd_lh7a404_drv_resume, */
|
||||
.driver = {
|
||||
.name = "lh7a404-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init ohci_hcd_lh7a404_init (void)
|
||||
|
|
@ -260,12 +257,12 @@ static int __init ohci_hcd_lh7a404_init (void)
|
|||
pr_debug ("block sizes: ed %d td %d\n",
|
||||
sizeof (struct ed), sizeof (struct td));
|
||||
|
||||
return driver_register(&ohci_hcd_lh7a404_driver);
|
||||
return platform_driver_register(&ohci_hcd_lh7a404_driver);
|
||||
}
|
||||
|
||||
static void __exit ohci_hcd_lh7a404_cleanup (void)
|
||||
{
|
||||
driver_unregister(&ohci_hcd_lh7a404_driver);
|
||||
platform_driver_unregister(&ohci_hcd_lh7a404_driver);
|
||||
}
|
||||
|
||||
module_init (ohci_hcd_lh7a404_init);
|
||||
|
|
|
|||
|
|
@ -433,24 +433,22 @@ static const struct hc_driver ohci_omap_hc_driver = {
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int ohci_hcd_omap_drv_probe(struct device *dev)
|
||||
static int ohci_hcd_omap_drv_probe(struct platform_device *dev)
|
||||
{
|
||||
return usb_hcd_omap_probe(&ohci_omap_hc_driver,
|
||||
to_platform_device(dev));
|
||||
return usb_hcd_omap_probe(&ohci_omap_hc_driver, dev);
|
||||
}
|
||||
|
||||
static int ohci_hcd_omap_drv_remove(struct device *dev)
|
||||
static int ohci_hcd_omap_drv_remove(struct platform_device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
|
||||
|
||||
usb_hcd_omap_remove(hcd, pdev);
|
||||
usb_hcd_omap_remove(hcd, dev);
|
||||
if (ohci->transceiver) {
|
||||
(void) otg_set_host(ohci->transceiver, 0);
|
||||
put_device(ohci->transceiver->dev);
|
||||
}
|
||||
dev_set_drvdata(dev, NULL);
|
||||
platform_set_drvdata(dev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -459,9 +457,9 @@ static int ohci_hcd_omap_drv_remove(struct device *dev)
|
|||
|
||||
#ifdef CONFIG_PM
|
||||
|
||||
static int ohci_omap_suspend(struct device *dev, pm_message_t message)
|
||||
static int ohci_omap_suspend(struct platform_device *dev, pm_message_t message)
|
||||
{
|
||||
struct ohci_hcd *ohci = hcd_to_ohci(dev_get_drvdata(dev));
|
||||
struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(dev));
|
||||
|
||||
if (time_before(jiffies, ohci->next_statechange))
|
||||
msleep(5);
|
||||
|
|
@ -473,9 +471,9 @@ static int ohci_omap_suspend(struct device *dev, pm_message_t message)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int ohci_omap_resume(struct device *dev)
|
||||
static int ohci_omap_resume(struct platform_device *dev)
|
||||
{
|
||||
struct ohci_hcd *ohci = hcd_to_ohci(dev_get_drvdata(dev));
|
||||
struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(dev));
|
||||
|
||||
if (time_before(jiffies, ohci->next_statechange))
|
||||
msleep(5);
|
||||
|
|
@ -494,16 +492,17 @@ static int ohci_omap_resume(struct device *dev)
|
|||
/*
|
||||
* Driver definition to register with the OMAP bus
|
||||
*/
|
||||
static struct device_driver ohci_hcd_omap_driver = {
|
||||
.name = "ohci",
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver ohci_hcd_omap_driver = {
|
||||
.probe = ohci_hcd_omap_drv_probe,
|
||||
.remove = ohci_hcd_omap_drv_remove,
|
||||
#ifdef CONFIG_PM
|
||||
.suspend = ohci_omap_suspend,
|
||||
.resume = ohci_omap_resume,
|
||||
#endif
|
||||
.driver = {
|
||||
.owner = THIS_MODULE,
|
||||
.name = "ohci",
|
||||
},
|
||||
};
|
||||
|
||||
static int __init ohci_hcd_omap_init (void)
|
||||
|
|
@ -515,12 +514,12 @@ static int __init ohci_hcd_omap_init (void)
|
|||
pr_debug("%s: block sizes: ed %Zd td %Zd\n", hcd_name,
|
||||
sizeof (struct ed), sizeof (struct td));
|
||||
|
||||
return driver_register(&ohci_hcd_omap_driver);
|
||||
return platform_driver_register(&ohci_hcd_omap_driver);
|
||||
}
|
||||
|
||||
static void __exit ohci_hcd_omap_cleanup (void)
|
||||
{
|
||||
driver_unregister(&ohci_hcd_omap_driver);
|
||||
platform_driver_unregister(&ohci_hcd_omap_driver);
|
||||
}
|
||||
|
||||
module_init (ohci_hcd_omap_init);
|
||||
|
|
|
|||
|
|
@ -172,9 +172,8 @@ static const struct hc_driver ohci_ppc_soc_hc_driver = {
|
|||
.start_port_reset = ohci_start_port_reset,
|
||||
};
|
||||
|
||||
static int ohci_hcd_ppc_soc_drv_probe(struct device *dev)
|
||||
static int ohci_hcd_ppc_soc_drv_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
int ret;
|
||||
|
||||
if (usb_disabled())
|
||||
|
|
@ -184,25 +183,25 @@ static int ohci_hcd_ppc_soc_drv_probe(struct device *dev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int ohci_hcd_ppc_soc_drv_remove(struct device *dev)
|
||||
static int ohci_hcd_ppc_soc_drv_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
|
||||
usb_hcd_ppc_soc_remove(hcd, pdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct device_driver ohci_hcd_ppc_soc_driver = {
|
||||
.name = "ppc-soc-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver ohci_hcd_ppc_soc_driver = {
|
||||
.probe = ohci_hcd_ppc_soc_drv_probe,
|
||||
.remove = ohci_hcd_ppc_soc_drv_remove,
|
||||
#ifdef CONFIG_PM
|
||||
/*.suspend = ohci_hcd_ppc_soc_drv_suspend,*/
|
||||
/*.resume = ohci_hcd_ppc_soc_drv_resume,*/
|
||||
#endif
|
||||
.driver = {
|
||||
.name = "ppc-soc-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init ohci_hcd_ppc_soc_init(void)
|
||||
|
|
@ -211,12 +210,12 @@ static int __init ohci_hcd_ppc_soc_init(void)
|
|||
pr_debug("block sizes: ed %d td %d\n", sizeof(struct ed),
|
||||
sizeof(struct td));
|
||||
|
||||
return driver_register(&ohci_hcd_ppc_soc_driver);
|
||||
return platform_driver_register(&ohci_hcd_ppc_soc_driver);
|
||||
}
|
||||
|
||||
static void __exit ohci_hcd_ppc_soc_cleanup(void)
|
||||
{
|
||||
driver_unregister(&ohci_hcd_ppc_soc_driver);
|
||||
platform_driver_unregister(&ohci_hcd_ppc_soc_driver);
|
||||
}
|
||||
|
||||
module_init(ohci_hcd_ppc_soc_init);
|
||||
|
|
|
|||
|
|
@ -290,9 +290,8 @@ static const struct hc_driver ohci_pxa27x_hc_driver = {
|
|||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int ohci_hcd_pxa27x_drv_probe(struct device *dev)
|
||||
static int ohci_hcd_pxa27x_drv_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
int ret;
|
||||
|
||||
pr_debug ("In ohci_hcd_pxa27x_drv_probe");
|
||||
|
|
@ -304,41 +303,39 @@ static int ohci_hcd_pxa27x_drv_probe(struct device *dev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int ohci_hcd_pxa27x_drv_remove(struct device *dev)
|
||||
static int ohci_hcd_pxa27x_drv_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(pdev);
|
||||
|
||||
usb_hcd_pxa27x_remove(hcd, pdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ohci_hcd_pxa27x_drv_suspend(struct device *dev, pm_message_t state)
|
||||
static int ohci_hcd_pxa27x_drv_suspend(struct platform_device *dev, pm_message_t state)
|
||||
{
|
||||
// struct platform_device *pdev = to_platform_device(dev);
|
||||
// struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
// struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
printk("%s: not implemented yet\n", __FUNCTION__);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ohci_hcd_pxa27x_drv_resume(struct device *dev)
|
||||
static int ohci_hcd_pxa27x_drv_resume(struct platform_device *dev)
|
||||
{
|
||||
// struct platform_device *pdev = to_platform_device(dev);
|
||||
// struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
// struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
printk("%s: not implemented yet\n", __FUNCTION__);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static struct device_driver ohci_hcd_pxa27x_driver = {
|
||||
.name = "pxa27x-ohci",
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver ohci_hcd_pxa27x_driver = {
|
||||
.probe = ohci_hcd_pxa27x_drv_probe,
|
||||
.remove = ohci_hcd_pxa27x_drv_remove,
|
||||
.suspend = ohci_hcd_pxa27x_drv_suspend,
|
||||
.resume = ohci_hcd_pxa27x_drv_resume,
|
||||
.resume = ohci_hcd_pxa27x_drv_resume,
|
||||
.driver = {
|
||||
.name = "pxa27x-ohci",
|
||||
},
|
||||
};
|
||||
|
||||
static int __init ohci_hcd_pxa27x_init (void)
|
||||
|
|
@ -347,12 +344,12 @@ static int __init ohci_hcd_pxa27x_init (void)
|
|||
pr_debug ("block sizes: ed %d td %d\n",
|
||||
sizeof (struct ed), sizeof (struct td));
|
||||
|
||||
return driver_register(&ohci_hcd_pxa27x_driver);
|
||||
return platform_driver_register(&ohci_hcd_pxa27x_driver);
|
||||
}
|
||||
|
||||
static void __exit ohci_hcd_pxa27x_cleanup (void)
|
||||
{
|
||||
driver_unregister(&ohci_hcd_pxa27x_driver);
|
||||
platform_driver_unregister(&ohci_hcd_pxa27x_driver);
|
||||
}
|
||||
|
||||
module_init (ohci_hcd_pxa27x_init);
|
||||
|
|
|
|||
|
|
@ -459,39 +459,38 @@ static const struct hc_driver ohci_s3c2410_hc_driver = {
|
|||
|
||||
/* device driver */
|
||||
|
||||
static int ohci_hcd_s3c2410_drv_probe(struct device *dev)
|
||||
static int ohci_hcd_s3c2410_drv_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
return usb_hcd_s3c2410_probe(&ohci_s3c2410_hc_driver, pdev);
|
||||
}
|
||||
|
||||
static int ohci_hcd_s3c2410_drv_remove(struct device *dev)
|
||||
static int ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(pdev);
|
||||
|
||||
usb_hcd_s3c2410_remove(hcd, pdev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct device_driver ohci_hcd_s3c2410_driver = {
|
||||
.name = "s3c2410-ohci",
|
||||
.owner = THIS_MODULE,
|
||||
.bus = &platform_bus_type,
|
||||
static struct platform_driver ohci_hcd_s3c2410_driver = {
|
||||
.probe = ohci_hcd_s3c2410_drv_probe,
|
||||
.remove = ohci_hcd_s3c2410_drv_remove,
|
||||
/*.suspend = ohci_hcd_s3c2410_drv_suspend, */
|
||||
/*.resume = ohci_hcd_s3c2410_drv_resume, */
|
||||
.driver = {
|
||||
.owner = THIS_MODULE,
|
||||
.name = "s3c2410-ohci",
|
||||
},
|
||||
};
|
||||
|
||||
static int __init ohci_hcd_s3c2410_init (void)
|
||||
{
|
||||
return driver_register(&ohci_hcd_s3c2410_driver);
|
||||
return platform_driver_register(&ohci_hcd_s3c2410_driver);
|
||||
}
|
||||
|
||||
static void __exit ohci_hcd_s3c2410_cleanup (void)
|
||||
{
|
||||
driver_unregister(&ohci_hcd_s3c2410_driver);
|
||||
platform_driver_unregister(&ohci_hcd_s3c2410_driver);
|
||||
}
|
||||
|
||||
module_init (ohci_hcd_s3c2410_init);
|
||||
|
|
|
|||
|
|
@ -1631,24 +1631,21 @@ static struct hc_driver sl811h_hc_driver = {
|
|||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int __devexit
|
||||
sl811h_remove(struct device *dev)
|
||||
sl811h_remove(struct platform_device *dev)
|
||||
{
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
struct sl811 *sl811 = hcd_to_sl811(hcd);
|
||||
struct platform_device *pdev;
|
||||
struct resource *res;
|
||||
|
||||
pdev = container_of(dev, struct platform_device, dev);
|
||||
|
||||
remove_debug_file(sl811);
|
||||
usb_remove_hcd(hcd);
|
||||
|
||||
/* some platforms may use IORESOURCE_IO */
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
||||
res = platform_get_resource(dev, IORESOURCE_MEM, 1);
|
||||
if (res)
|
||||
iounmap(sl811->data_reg);
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
res = platform_get_resource(dev, IORESOURCE_MEM, 0);
|
||||
if (res)
|
||||
iounmap(sl811->addr_reg);
|
||||
|
||||
|
|
@ -1657,11 +1654,10 @@ sl811h_remove(struct device *dev)
|
|||
}
|
||||
|
||||
static int __devinit
|
||||
sl811h_probe(struct device *dev)
|
||||
sl811h_probe(struct platform_device *dev)
|
||||
{
|
||||
struct usb_hcd *hcd;
|
||||
struct sl811 *sl811;
|
||||
struct platform_device *pdev;
|
||||
struct resource *addr, *data;
|
||||
int irq;
|
||||
void __iomem *addr_reg;
|
||||
|
|
@ -1674,24 +1670,23 @@ sl811h_probe(struct device *dev)
|
|||
* specific platform_data. we don't probe for IRQs, and do only
|
||||
* minimal sanity checking.
|
||||
*/
|
||||
pdev = container_of(dev, struct platform_device, dev);
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
if (pdev->num_resources < 3 || irq < 0)
|
||||
irq = platform_get_irq(dev, 0);
|
||||
if (dev->num_resources < 3 || irq < 0)
|
||||
return -ENODEV;
|
||||
|
||||
/* refuse to confuse usbcore */
|
||||
if (dev->dma_mask) {
|
||||
if (dev->dev.dma_mask) {
|
||||
DBG("no we won't dma\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* the chip may be wired for either kind of addressing */
|
||||
addr = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
data = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
||||
addr = platform_get_resource(dev, IORESOURCE_MEM, 0);
|
||||
data = platform_get_resource(dev, IORESOURCE_MEM, 1);
|
||||
retval = -EBUSY;
|
||||
if (!addr || !data) {
|
||||
addr = platform_get_resource(pdev, IORESOURCE_IO, 0);
|
||||
data = platform_get_resource(pdev, IORESOURCE_IO, 1);
|
||||
addr = platform_get_resource(dev, IORESOURCE_IO, 0);
|
||||
data = platform_get_resource(dev, IORESOURCE_IO, 1);
|
||||
if (!addr || !data)
|
||||
return -ENODEV;
|
||||
ioaddr = 1;
|
||||
|
|
@ -1713,7 +1708,7 @@ sl811h_probe(struct device *dev)
|
|||
}
|
||||
|
||||
/* allocate and initialize hcd */
|
||||
hcd = usb_create_hcd(&sl811h_hc_driver, dev, dev->bus_id);
|
||||
hcd = usb_create_hcd(&sl811h_hc_driver, &dev->dev, dev->dev.bus_id);
|
||||
if (!hcd) {
|
||||
retval = -ENOMEM;
|
||||
goto err5;
|
||||
|
|
@ -1723,7 +1718,7 @@ sl811h_probe(struct device *dev)
|
|||
|
||||
spin_lock_init(&sl811->lock);
|
||||
INIT_LIST_HEAD(&sl811->async);
|
||||
sl811->board = dev->platform_data;
|
||||
sl811->board = dev->dev.platform_data;
|
||||
init_timer(&sl811->timer);
|
||||
sl811->timer.function = sl811h_timer;
|
||||
sl811->timer.data = (unsigned long) sl811;
|
||||
|
|
@ -1785,9 +1780,9 @@ sl811h_probe(struct device *dev)
|
|||
*/
|
||||
|
||||
static int
|
||||
sl811h_suspend(struct device *dev, pm_message_t state)
|
||||
sl811h_suspend(struct platform_device *dev, pm_message_t state)
|
||||
{
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
struct sl811 *sl811 = hcd_to_sl811(hcd);
|
||||
int retval = 0;
|
||||
|
||||
|
|
@ -1796,27 +1791,27 @@ sl811h_suspend(struct device *dev, pm_message_t state)
|
|||
else if (state.event == PM_EVENT_SUSPEND)
|
||||
port_power(sl811, 0);
|
||||
if (retval == 0)
|
||||
dev->power.power_state = state;
|
||||
dev->dev.power.power_state = state;
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int
|
||||
sl811h_resume(struct device *dev)
|
||||
sl811h_resume(struct platform_device *dev)
|
||||
{
|
||||
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
||||
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
||||
struct sl811 *sl811 = hcd_to_sl811(hcd);
|
||||
|
||||
/* with no "check to see if VBUS is still powered" board hook,
|
||||
* let's assume it'd only be powered to enable remote wakeup.
|
||||
*/
|
||||
if (dev->power.power_state.event == PM_EVENT_SUSPEND
|
||||
if (dev->dev.power.power_state.event == PM_EVENT_SUSPEND
|
||||
|| !hcd->can_wakeup) {
|
||||
sl811->port1 = 0;
|
||||
port_power(sl811, 1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
dev->power.power_state = PMSG_ON;
|
||||
dev->dev.power.power_state = PMSG_ON;
|
||||
return sl811h_bus_resume(hcd);
|
||||
}
|
||||
|
||||
|
|
@ -1829,16 +1824,16 @@ sl811h_resume(struct device *dev)
|
|||
|
||||
|
||||
/* this driver is exported so sl811_cs can depend on it */
|
||||
struct device_driver sl811h_driver = {
|
||||
.name = (char *) hcd_name,
|
||||
.bus = &platform_bus_type,
|
||||
.owner = THIS_MODULE,
|
||||
|
||||
struct platform_driver sl811h_driver = {
|
||||
.probe = sl811h_probe,
|
||||
.remove = __devexit_p(sl811h_remove),
|
||||
|
||||
.suspend = sl811h_suspend,
|
||||
.resume = sl811h_resume,
|
||||
.driver = {
|
||||
.name = (char *) hcd_name,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
EXPORT_SYMBOL(sl811h_driver);
|
||||
|
||||
|
|
@ -1850,12 +1845,12 @@ static int __init sl811h_init(void)
|
|||
return -ENODEV;
|
||||
|
||||
INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION);
|
||||
return driver_register(&sl811h_driver);
|
||||
return platform_driver_register(&sl811h_driver);
|
||||
}
|
||||
module_init(sl811h_init);
|
||||
|
||||
static void __exit sl811h_cleanup(void)
|
||||
{
|
||||
driver_unregister(&sl811h_driver);
|
||||
platform_driver_unregister(&sl811h_driver);
|
||||
}
|
||||
module_exit(sl811h_cleanup);
|
||||
|
|
|
|||
Loading…
Reference in a new issue