8 files changed, 156 insertions, 157 deletions

diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 98820603e75f..3742753241ee 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2381,9 +2381,9 @@ void serial8250_resume_port(int line)
  * list is terminated with a zero flags entry, which means we expect
  * all entries to have at least UPF_BOOT_AUTOCONF set.
  */
-static int __devinit serial8250_probe(struct device *dev)
+static int __devinit serial8250_probe(struct platform_device *dev)
 {
-        struct plat_serial8250_port *p = dev->platform_data;
+        struct plat_serial8250_port *p = dev->dev.platform_data;
         struct uart_port port;
         int ret, i;
 
@@ -2399,12 +2399,12 @@ static int __devinit serial8250_probe(struct device *dev)
                 port.flags      = p->flags;
                 port.mapbase    = p->mapbase;
                 port.hub6       = p->hub6;
-                port.dev        = dev;
+                port.dev        = &dev->dev;
                 if (share_irqs)
                         port.flags |= UPF_SHARE_IRQ;
                 ret = serial8250_register_port(&port);
                 if (ret < 0) {
-                        dev_err(dev, "unable to register port at index %d "
+                        dev_err(&dev->dev, "unable to register port at index %d "
                                 "(IO%lx MEM%lx IRQ%d): %d\n", i,
                                 p->iobase, p->mapbase, p->irq, ret);
                 }
@@ -2415,54 +2415,55 @@ static int __devinit serial8250_probe(struct device *dev)
 /*
  * Remove serial ports registered against a platform device.
  */
-static int __devexit serial8250_remove(struct device *dev)
+static int __devexit serial8250_remove(struct platform_device *dev)
 {
         int i;
 
         for (i = 0; i < UART_NR; i++) {
                 struct uart_8250_port *up = &serial8250_ports[i];
 
-                if (up->port.dev == dev)
+                if (up->port.dev == &dev->dev)
                         serial8250_unregister_port(i);
         }
         return 0;
 }
 
-static int serial8250_suspend(struct device *dev, pm_message_t state)
+static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
 {
         int i;
 
         for (i = 0; i < UART_NR; i++) {
                 struct uart_8250_port *up = &serial8250_ports[i];
 
-                if (up->port.type != PORT_UNKNOWN && up->port.dev == dev)
+                if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
                         uart_suspend_port(&serial8250_reg, &up->port);
         }
 
         return 0;
 }
 
-static int serial8250_resume(struct device *dev)
+static int serial8250_resume(struct platform_device *dev)
 {
         int i;
 
         for (i = 0; i < UART_NR; i++) {
                 struct uart_8250_port *up = &serial8250_ports[i];
 
-                if (up->port.type != PORT_UNKNOWN && up->port.dev == dev)
+                if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
                         uart_resume_port(&serial8250_reg, &up->port);
         }
 
         return 0;
 }
 
-static struct device_driver serial8250_isa_driver = {
-        .name           = "serial8250",
-        .bus            = &platform_bus_type,
+static struct platform_driver serial8250_isa_driver = {
         .probe          = serial8250_probe,
         .remove         = __devexit_p(serial8250_remove),
         .suspend        = serial8250_suspend,
         .resume         = serial8250_resume,
+        .driver         = {
+                .name   = "serial8250",
+        },
 };
 
 /*
@@ -2608,7 +2609,7 @@ static int __init serial8250_init(void)
 
         serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
 
-        ret = driver_register(&serial8250_isa_driver);
+        ret = platform_driver_register(&serial8250_isa_driver);
         if (ret == 0)
                 goto out;
 
@@ -2630,7 +2631,7 @@ static void __exit serial8250_exit(void)
          */
         serial8250_isa_devs = NULL;
 
-        driver_unregister(&serial8250_isa_driver);
+        platform_driver_unregister(&serial8250_isa_driver);
         platform_device_unregister(isa_dev);
 
         uart_unregister_driver(&serial8250_reg);
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 4a54ff584700..355cd93a8a87 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -921,9 +921,9 @@ static struct uart_driver imx_reg = {
         .cons           = IMX_CONSOLE,
 };
 
-static int serial_imx_suspend(struct device *_dev, pm_message_t state)
+static int serial_imx_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct imx_port *sport = dev_get_drvdata(_dev);
+        struct imx_port *sport = platform_get_drvdata(dev);
 
         if (sport)
                 uart_suspend_port(&imx_reg, &sport->port);
@@ -931,9 +931,9 @@ static int serial_imx_suspend(struct device *_dev, pm_message_t state)
         return 0;
 }
 
-static int serial_imx_resume(struct device *_dev)
+static int serial_imx_resume(struct platform_device *dev)
 {
-        struct imx_port *sport = dev_get_drvdata(_dev);
+        struct imx_port *sport = platform_get_drvdata(dev);
 
         if (sport)
                 uart_resume_port(&imx_reg, &sport->port);
@@ -941,21 +941,19 @@ static int serial_imx_resume(struct device *_dev)
         return 0;
 }
 
-static int serial_imx_probe(struct device *_dev)
+static int serial_imx_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(_dev);
-
-        imx_ports[dev->id].port.dev = _dev;
+        imx_ports[dev->id].port.dev = &dev->dev;
         uart_add_one_port(&imx_reg, &imx_ports[dev->id].port);
-        dev_set_drvdata(_dev, &imx_ports[dev->id]);
+        platform_set_drvdata(dev, &imx_ports[dev->id]);
         return 0;
 }
 
-static int serial_imx_remove(struct device *_dev)
+static int serial_imx_remove(struct platform_device *dev)
 {
-        struct imx_port *sport = dev_get_drvdata(_dev);
+        struct imx_port *sport = platform_get_drvdata(dev);
 
-        dev_set_drvdata(_dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
         if (sport)
                 uart_remove_one_port(&imx_reg, &sport->port);
@@ -963,14 +961,15 @@ static int serial_imx_remove(struct device *_dev)
         return 0;
 }
 
-static struct device_driver serial_imx_driver = {
-        .name           = "imx-uart",
-        .bus            = &platform_bus_type,
+static struct platform_driver serial_imx_driver = {
         .probe          = serial_imx_probe,
         .remove         = serial_imx_remove,
 
         .suspend        = serial_imx_suspend,
         .resume         = serial_imx_resume,
+        .driver         = {
+                .name   = "imx-uart",
+        },
 };
 
 static int __init imx_serial_init(void)
@@ -985,7 +984,7 @@ static int __init imx_serial_init(void)
         if (ret)
                 return ret;
 
-        ret = driver_register(&serial_imx_driver);
+        ret = platform_driver_register(&serial_imx_driver);
         if (ret != 0)
                 uart_unregister_driver(&imx_reg);
 
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index 0dd08a09e7e6..5d3cb8486447 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -717,10 +717,9 @@ static struct uart_driver mpc52xx_uart_driver = {
 /* ======================================================================== */
 
 static int __devinit
-mpc52xx_uart_probe(struct device *dev)
+mpc52xx_uart_probe(struct platform_device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct resource *res = pdev->resource;
+        struct resource *res = dev->resource;
 
         struct uart_port *port = NULL;
         int i, idx, ret;
@@ -761,17 +760,17 @@ mpc52xx_uart_probe(struct device *dev)
         /* Add the port to the uart sub-system */
         ret = uart_add_one_port(&mpc52xx_uart_driver, port);
         if (!ret)
-                dev_set_drvdata(dev, (void*)port);
+                platform_set_drvdata(dev, (void*)port);
 
         return ret;
 }
 
 static int
-mpc52xx_uart_remove(struct device *dev)
+mpc52xx_uart_remove(struct platform_device *dev)
 {
-        struct uart_port *port = (struct uart_port *) dev_get_drvdata(dev);
+        struct uart_port *port = (struct uart_port *) platform_get_drvdata(dev);
 
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
         if (port)
                 uart_remove_one_port(&mpc52xx_uart_driver, port);
@@ -781,9 +780,9 @@ mpc52xx_uart_remove(struct device *dev)
 
 #ifdef CONFIG_PM
 static int
-mpc52xx_uart_suspend(struct device *dev, pm_message_t state)
+mpc52xx_uart_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct uart_port *port = (struct uart_port *) dev_get_drvdata(dev);
+        struct uart_port *port = (struct uart_port *) platform_get_drvdata(dev);
 
         if (sport)
                 uart_suspend_port(&mpc52xx_uart_driver, port);
@@ -792,9 +791,9 @@ mpc52xx_uart_suspend(struct device *dev, pm_message_t state)
 }
 
 static int
-mpc52xx_uart_resume(struct device *dev)
+mpc52xx_uart_resume(struct platform_device *dev)
 {
-        struct uart_port *port = (struct uart_port *) dev_get_drvdata(dev);
+        struct uart_port *port = (struct uart_port *) platform_get_drvdata(dev);
 
         if (port)
                 uart_resume_port(&mpc52xx_uart_driver, port);
@@ -803,15 +802,16 @@ mpc52xx_uart_resume(struct device *dev)
 }
 #endif
 
-static struct device_driver mpc52xx_uart_platform_driver = {
-        .name           = "mpc52xx-psc",
-        .bus            = &platform_bus_type,
+static struct platform_driver mpc52xx_uart_platform_driver = {
         .probe          = mpc52xx_uart_probe,
         .remove         = mpc52xx_uart_remove,
 #ifdef CONFIG_PM
         .suspend        = mpc52xx_uart_suspend,
         .resume         = mpc52xx_uart_resume,
 #endif
+        .driver         = {
+                .name   = "mpc52xx-psc",
+        },
 };
 
 
@@ -828,7 +828,7 @@ mpc52xx_uart_init(void)
 
         ret = uart_register_driver(&mpc52xx_uart_driver);
         if (ret == 0) {
-                ret = driver_register(&mpc52xx_uart_platform_driver);
+                ret = platform_driver_register(&mpc52xx_uart_platform_driver);
                 if (ret)
                         uart_unregister_driver(&mpc52xx_uart_driver);
         }
@@ -839,7 +839,7 @@ mpc52xx_uart_init(void)
 static void __exit
 mpc52xx_uart_exit(void)
 {
-        driver_unregister(&mpc52xx_uart_platform_driver);
+        platform_driver_unregister(&mpc52xx_uart_platform_driver);
         uart_unregister_driver(&mpc52xx_uart_driver);
 }
 
diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
index ba8838b234da..8f83e4007ecd 100644
--- a/drivers/serial/mpsc.c
+++ b/drivers/serial/mpsc.c
@@ -1551,15 +1551,14 @@ mpsc_shared_unmap_regs(void)
 }
 
 static int
-mpsc_shared_drv_probe(struct device *dev)
+mpsc_shared_drv_probe(struct platform_device *dev)
 {
-        struct platform_device          *pd = to_platform_device(dev);
         struct mpsc_shared_pdata        *pdata;
         int                              rc = -ENODEV;
 
-        if (pd->id == 0) {
-                if (!(rc = mpsc_shared_map_regs(pd)))  {
-                        pdata = (struct mpsc_shared_pdata *)dev->platform_data;
+        if (dev->id == 0) {
+                if (!(rc = mpsc_shared_map_regs(dev)))  {
+                        pdata = (struct mpsc_shared_pdata *)dev->dev.platform_data;
 
                         mpsc_shared_regs.MPSC_MRR_m = pdata->mrr_val;
                         mpsc_shared_regs.MPSC_RCRR_m= pdata->rcrr_val;
@@ -1577,12 +1576,11 @@ mpsc_shared_drv_probe(struct device *dev)
 }
 
 static int
-mpsc_shared_drv_remove(struct device *dev)
+mpsc_shared_drv_remove(struct platform_device *dev)
 {
-        struct platform_device  *pd = to_platform_device(dev);
         int     rc = -ENODEV;
 
-        if (pd->id == 0) {
+        if (dev->id == 0) {
                 mpsc_shared_unmap_regs();
                 mpsc_shared_regs.MPSC_MRR_m = 0;
                 mpsc_shared_regs.MPSC_RCRR_m = 0;
@@ -1595,11 +1593,12 @@ mpsc_shared_drv_remove(struct device *dev)
         return rc;
 }
 
-static struct device_driver mpsc_shared_driver = {
-        .name   = MPSC_SHARED_NAME,
-        .bus    = &platform_bus_type,
+static struct platform_driver mpsc_shared_driver = {
         .probe  = mpsc_shared_drv_probe,
         .remove = mpsc_shared_drv_remove,
+        .driver = {
+                .name = MPSC_SHARED_NAME,
+        },
 };
 
 /*
@@ -1732,19 +1731,18 @@ mpsc_drv_get_platform_data(struct mpsc_port_info *pi,
 }
 
 static int
-mpsc_drv_probe(struct device *dev)
+mpsc_drv_probe(struct platform_device *dev)
 {
-        struct platform_device  *pd = to_platform_device(dev);
         struct mpsc_port_info   *pi;
         int                     rc = -ENODEV;
 
-        pr_debug("mpsc_drv_probe: Adding MPSC %d\n", pd->id);
+        pr_debug("mpsc_drv_probe: Adding MPSC %d\n", dev->id);
 
-        if (pd->id < MPSC_NUM_CTLRS) {
-                pi = &mpsc_ports[pd->id];
+        if (dev->id < MPSC_NUM_CTLRS) {
+                pi = &mpsc_ports[dev->id];
 
-                if (!(rc = mpsc_drv_map_regs(pi, pd))) {
-                        mpsc_drv_get_platform_data(pi, pd, pd->id);
+                if (!(rc = mpsc_drv_map_regs(pi, dev))) {
+                        mpsc_drv_get_platform_data(pi, dev, dev->id);
 
                         if (!(rc = mpsc_make_ready(pi)))
                                 if (!(rc = uart_add_one_port(&mpsc_reg,
@@ -1764,27 +1762,26 @@ mpsc_drv_probe(struct device *dev)
 }
 
 static int
-mpsc_drv_remove(struct device *dev)
+mpsc_drv_remove(struct platform_device *dev)
 {
-        struct platform_device  *pd = to_platform_device(dev);
+        pr_debug("mpsc_drv_exit: Removing MPSC %d\n", dev->id);
 
-        pr_debug("mpsc_drv_exit: Removing MPSC %d\n", pd->id);
-
-        if (pd->id < MPSC_NUM_CTLRS) {
-                uart_remove_one_port(&mpsc_reg, &mpsc_ports[pd->id].port);
-                mpsc_release_port((struct uart_port *)&mpsc_ports[pd->id].port);
-                mpsc_drv_unmap_regs(&mpsc_ports[pd->id]);
+        if (dev->id < MPSC_NUM_CTLRS) {
+                uart_remove_one_port(&mpsc_reg, &mpsc_ports[dev->id].port);
+                mpsc_release_port((struct uart_port *)&mpsc_ports[dev->id].port);
+                mpsc_drv_unmap_regs(&mpsc_ports[dev->id]);
                 return 0;
         }
         else
                 return -ENODEV;
 }
 
-static struct device_driver mpsc_driver = {
-        .name   = MPSC_CTLR_NAME,
-        .bus    = &platform_bus_type,
+static struct platform_driver mpsc_driver = {
         .probe  = mpsc_drv_probe,
         .remove = mpsc_drv_remove,
+        .driver = {
+                .name = MPSC_CTLR_NAME,
+        },
 };
 
 static int __init
@@ -1798,9 +1795,9 @@ mpsc_drv_init(void)
         memset(&mpsc_shared_regs, 0, sizeof(mpsc_shared_regs));
 
         if (!(rc = uart_register_driver(&mpsc_reg))) {
-                if (!(rc = driver_register(&mpsc_shared_driver))) {
-                        if ((rc = driver_register(&mpsc_driver))) {
-                                driver_unregister(&mpsc_shared_driver);
+                if (!(rc = platform_driver_register(&mpsc_shared_driver))) {
+                        if ((rc = platform_driver_register(&mpsc_driver))) {
+                                platform_driver_unregister(&mpsc_shared_driver);
                                 uart_unregister_driver(&mpsc_reg);
                         }
                 }
@@ -1815,8 +1812,8 @@ mpsc_drv_init(void)
 static void __exit
 mpsc_drv_exit(void)
 {
-        driver_unregister(&mpsc_driver);
-        driver_unregister(&mpsc_shared_driver);
+        platform_driver_unregister(&mpsc_driver);
+        platform_driver_unregister(&mpsc_shared_driver);
         uart_unregister_driver(&mpsc_reg);
         memset(mpsc_ports, 0, sizeof(mpsc_ports));
         memset(&mpsc_shared_regs, 0, sizeof(mpsc_shared_regs));
diff --git a/drivers/serial/pxa.c b/drivers/serial/pxa.c
index 16b2f9417af9..ff5e6309d682 100644
--- a/drivers/serial/pxa.c
+++ b/drivers/serial/pxa.c
@@ -805,9 +805,9 @@ static struct uart_driver serial_pxa_reg = {
         .cons           = PXA_CONSOLE,
 };
 
-static int serial_pxa_suspend(struct device *_dev, pm_message_t state)
+static int serial_pxa_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct uart_pxa_port *sport = dev_get_drvdata(_dev);
+        struct uart_pxa_port *sport = platform_get_drvdata(dev);
 
         if (sport)
                 uart_suspend_port(&serial_pxa_reg, &sport->port);
@@ -815,9 +815,9 @@ static int serial_pxa_suspend(struct device *_dev, pm_message_t state)
         return 0;
 }
 
-static int serial_pxa_resume(struct device *_dev)
+static int serial_pxa_resume(struct platform_device *dev)
 {
-        struct uart_pxa_port *sport = dev_get_drvdata(_dev);
+        struct uart_pxa_port *sport = platform_get_drvdata(dev);
 
         if (sport)
                 uart_resume_port(&serial_pxa_reg, &sport->port);
@@ -825,21 +825,19 @@ static int serial_pxa_resume(struct device *_dev)
         return 0;
 }
 
-static int serial_pxa_probe(struct device *_dev)
+static int serial_pxa_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(_dev);
-
-        serial_pxa_ports[dev->id].port.dev = _dev;
+        serial_pxa_ports[dev->id].port.dev = &dev->dev;
         uart_add_one_port(&serial_pxa_reg, &serial_pxa_ports[dev->id].port);
-        dev_set_drvdata(_dev, &serial_pxa_ports[dev->id]);
+        platform_set_drvdata(dev, &serial_pxa_ports[dev->id]);
         return 0;
 }
 
-static int serial_pxa_remove(struct device *_dev)
+static int serial_pxa_remove(struct platform_device *dev)
 {
-        struct uart_pxa_port *sport = dev_get_drvdata(_dev);
+        struct uart_pxa_port *sport = platform_get_drvdata(dev);
 
-        dev_set_drvdata(_dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
         if (sport)
                 uart_remove_one_port(&serial_pxa_reg, &sport->port);
@@ -847,14 +845,15 @@ static int serial_pxa_remove(struct device *_dev)
         return 0;
 }
 
-static struct device_driver serial_pxa_driver = {
-        .name           = "pxa2xx-uart",
-        .bus            = &platform_bus_type,
+static struct platform_driver serial_pxa_driver = {
         .probe          = serial_pxa_probe,
         .remove         = serial_pxa_remove,
 
         .suspend        = serial_pxa_suspend,
         .resume         = serial_pxa_resume,
+        .driver         = {
+                .name   = "pxa2xx-uart",
+        },
 };
 
 int __init serial_pxa_init(void)
@@ -865,7 +864,7 @@ int __init serial_pxa_init(void)
         if (ret != 0)
                 return ret;
 
-        ret = driver_register(&serial_pxa_driver);
+        ret = platform_driver_register(&serial_pxa_driver);
         if (ret != 0)
                 uart_unregister_driver(&serial_pxa_reg);
 
@@ -874,7 +873,7 @@ int __init serial_pxa_init(void)
 
 void __exit serial_pxa_exit(void)
 {
-        driver_unregister(&serial_pxa_driver);
+        platform_driver_unregister(&serial_pxa_driver);
         uart_unregister_driver(&serial_pxa_reg);
 }
 
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index 036792328d49..47681c4654e4 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -1092,14 +1092,13 @@ static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
 
 static int probe_index = 0;
 
-static int s3c24xx_serial_probe(struct device *_dev,
+static int s3c24xx_serial_probe(struct platform_device *dev,
                                 struct s3c24xx_uart_info *info)
 {
         struct s3c24xx_uart_port *ourport;
-        struct platform_device *dev = to_platform_device(_dev);
         int ret;
 
-        dbg("s3c24xx_serial_probe(%p, %p) %d\n", _dev, info, probe_index);
+        dbg("s3c24xx_serial_probe(%p, %p) %d\n", dev, info, probe_index);
 
         ourport = &s3c24xx_serial_ports[probe_index];
         probe_index++;
@@ -1112,7 +1111,7 @@ static int s3c24xx_serial_probe(struct device *_dev,
 
         dbg("%s: adding port\n", __FUNCTION__);
         uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);
-        dev_set_drvdata(_dev, &ourport->port);
+        platform_set_drvdata(dev, &ourport->port);
 
         return 0;
 
@@ -1120,9 +1119,9 @@ static int s3c24xx_serial_probe(struct device *_dev,
         return ret;
 }
 
-static int s3c24xx_serial_remove(struct device *_dev)
+static int s3c24xx_serial_remove(struct platform_device *dev)
 {
-        struct uart_port *port = s3c24xx_dev_to_port(_dev);
+        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
 
         if (port)
                 uart_remove_one_port(&s3c24xx_uart_drv, port);
@@ -1134,9 +1133,9 @@ static int s3c24xx_serial_remove(struct device *_dev)
 
 #ifdef CONFIG_PM
 
-static int s3c24xx_serial_suspend(struct device *dev, pm_message_t state)
+static int s3c24xx_serial_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct uart_port *port = s3c24xx_dev_to_port(dev);
+        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
 
         if (port)
                 uart_suspend_port(&s3c24xx_uart_drv, port);
@@ -1144,9 +1143,9 @@ static int s3c24xx_serial_suspend(struct device *dev, pm_message_t state)
         return 0;
 }
 
-static int s3c24xx_serial_resume(struct device *dev)
+static int s3c24xx_serial_resume(struct platform_device *dev)
 {
-        struct uart_port *port = s3c24xx_dev_to_port(dev);
+        struct uart_port *port = s3c24xx_dev_to_port(&dev->dev);
         struct s3c24xx_uart_port *ourport = to_ourport(port);
 
         if (port) {
@@ -1165,11 +1164,11 @@ static int s3c24xx_serial_resume(struct device *dev)
 #define s3c24xx_serial_resume  NULL
 #endif
 
-static int s3c24xx_serial_init(struct device_driver *drv,
+static int s3c24xx_serial_init(struct platform_driver *drv,
                                struct s3c24xx_uart_info *info)
 {
         dbg("s3c24xx_serial_init(%p,%p)\n", drv, info);
-        return driver_register(drv);
+        return platform_driver_register(drv);
 }
 
 
@@ -1228,19 +1227,20 @@ static struct s3c24xx_uart_info s3c2400_uart_inf = {
         .reset_port     = s3c2400_serial_resetport,
 };
 
-static int s3c2400_serial_probe(struct device *dev)
+static int s3c2400_serial_probe(struct platform_device *dev)
 {
         return s3c24xx_serial_probe(dev, &s3c2400_uart_inf);
 }
 
-static struct device_driver s3c2400_serial_drv = {
-        .name           = "s3c2400-uart",
-        .owner          = THIS_MODULE,
-        .bus            = &platform_bus_type,
+static struct platform_driver s3c2400_serial_drv = {
         .probe          = s3c2400_serial_probe,
         .remove         = s3c24xx_serial_remove,
         .suspend        = s3c24xx_serial_suspend,
         .resume         = s3c24xx_serial_resume,
+        .driver         = {
+                .name   = "s3c2400-uart",
+                .owner  = THIS_MODULE,
+        },
 };
 
 static inline int s3c2400_serial_init(void)
@@ -1250,7 +1250,7 @@ static inline int s3c2400_serial_init(void)
 
 static inline void s3c2400_serial_exit(void)
 {
-        driver_unregister(&s3c2400_serial_drv);
+        platform_driver_unregister(&s3c2400_serial_drv);
 }
 
 #define s3c2400_uart_inf_at &s3c2400_uart_inf
@@ -1332,19 +1332,20 @@ static struct s3c24xx_uart_info s3c2410_uart_inf = {
 
 /* device management */
 
-static int s3c2410_serial_probe(struct device *dev)
+static int s3c2410_serial_probe(struct platform_device *dev)
 {
         return s3c24xx_serial_probe(dev, &s3c2410_uart_inf);
 }
 
-static struct device_driver s3c2410_serial_drv = {
-        .name           = "s3c2410-uart",
-        .owner          = THIS_MODULE,
-        .bus            = &platform_bus_type,
+static struct platform_driver s3c2410_serial_drv = {
         .probe          = s3c2410_serial_probe,
         .remove         = s3c24xx_serial_remove,
         .suspend        = s3c24xx_serial_suspend,
         .resume         = s3c24xx_serial_resume,
+        .driver         = {
+                .name   = "s3c2410-uart",
+                .owner  = THIS_MODULE,
+        },
 };
 
 static inline int s3c2410_serial_init(void)
@@ -1354,7 +1355,7 @@ static inline int s3c2410_serial_init(void)
 
 static inline void s3c2410_serial_exit(void)
 {
-        driver_unregister(&s3c2410_serial_drv);
+        platform_driver_unregister(&s3c2410_serial_drv);
 }
 
 #define s3c2410_uart_inf_at &s3c2410_uart_inf
@@ -1493,20 +1494,21 @@ static struct s3c24xx_uart_info s3c2440_uart_inf = {
 
 /* device management */
 
-static int s3c2440_serial_probe(struct device *dev)
+static int s3c2440_serial_probe(struct platform_device *dev)
 {
         dbg("s3c2440_serial_probe: dev=%p\n", dev);
         return s3c24xx_serial_probe(dev, &s3c2440_uart_inf);
 }
 
-static struct device_driver s3c2440_serial_drv = {
-        .name           = "s3c2440-uart",
-        .owner          = THIS_MODULE,
-        .bus            = &platform_bus_type,
+static struct platform_driver s3c2440_serial_drv = {
         .probe          = s3c2440_serial_probe,
         .remove         = s3c24xx_serial_remove,
         .suspend        = s3c24xx_serial_suspend,
         .resume         = s3c24xx_serial_resume,
+        .driver         = {
+                .name   = "s3c2440-uart",
+                .owner  = THIS_MODULE,
+        },
 };
 
 
@@ -1517,7 +1519,7 @@ static inline int s3c2440_serial_init(void)
 
 static inline void s3c2440_serial_exit(void)
 {
-        driver_unregister(&s3c2440_serial_drv);
+        platform_driver_unregister(&s3c2440_serial_drv);
 }
 
 #define s3c2440_uart_inf_at &s3c2440_uart_inf
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c
index ed618cc7ae96..fd9deee20e05 100644
--- a/drivers/serial/sa1100.c
+++ b/drivers/serial/sa1100.c
@@ -834,9 +834,9 @@ static struct uart_driver sa1100_reg = {
         .cons                   = SA1100_CONSOLE,
 };
 
-static int sa1100_serial_suspend(struct device *_dev, pm_message_t state)
+static int sa1100_serial_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct sa1100_port *sport = dev_get_drvdata(_dev);
+        struct sa1100_port *sport = platform_get_drvdata(dev);
 
         if (sport)
                 uart_suspend_port(&sa1100_reg, &sport->port);
@@ -844,9 +844,9 @@ static int sa1100_serial_suspend(struct device *_dev, pm_message_t state)
         return 0;
 }
 
-static int sa1100_serial_resume(struct device *_dev)
+static int sa1100_serial_resume(struct platform_device *dev)
 {
-        struct sa1100_port *sport = dev_get_drvdata(_dev);
+        struct sa1100_port *sport = platform_get_drvdata(dev);
 
         if (sport)
                 uart_resume_port(&sa1100_reg, &sport->port);
@@ -854,9 +854,8 @@ static int sa1100_serial_resume(struct device *_dev)
         return 0;
 }
 
-static int sa1100_serial_probe(struct device *_dev)
+static int sa1100_serial_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(_dev);
         struct resource *res = dev->resource;
         int i;
 
@@ -869,9 +868,9 @@ static int sa1100_serial_probe(struct device *_dev)
                         if (sa1100_ports[i].port.mapbase != res->start)
                                 continue;
 
-                        sa1100_ports[i].port.dev = _dev;
+                        sa1100_ports[i].port.dev = &dev->dev;
                         uart_add_one_port(&sa1100_reg, &sa1100_ports[i].port);
-                        dev_set_drvdata(_dev, &sa1100_ports[i]);
+                        platform_set_drvdata(dev, &sa1100_ports[i]);
                         break;
                 }
         }
@@ -879,11 +878,11 @@ static int sa1100_serial_probe(struct device *_dev)
         return 0;
 }
 
-static int sa1100_serial_remove(struct device *_dev)
+static int sa1100_serial_remove(struct platform_device *pdev)
 {
-        struct sa1100_port *sport = dev_get_drvdata(_dev);
+        struct sa1100_port *sport = platform_get_drvdata(pdev);
 
-        dev_set_drvdata(_dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         if (sport)
                 uart_remove_one_port(&sa1100_reg, &sport->port);
@@ -891,13 +890,14 @@ static int sa1100_serial_remove(struct device *_dev)
         return 0;
 }
 
-static struct device_driver sa11x0_serial_driver = {
-        .name           = "sa11x0-uart",
-        .bus            = &platform_bus_type,
+static struct platform_driver sa11x0_serial_driver = {
         .probe          = sa1100_serial_probe,
         .remove         = sa1100_serial_remove,
         .suspend        = sa1100_serial_suspend,
         .resume         = sa1100_serial_resume,
+        .driver         = {
+                .name   = "sa11x0-uart",
+        },
 };
 
 static int __init sa1100_serial_init(void)
@@ -910,7 +910,7 @@ static int __init sa1100_serial_init(void)
 
         ret = uart_register_driver(&sa1100_reg);
         if (ret == 0) {
-                ret = driver_register(&sa11x0_serial_driver);
+                ret = platform_driver_register(&sa11x0_serial_driver);
                 if (ret)
                         uart_unregister_driver(&sa1100_reg);
         }
@@ -919,7 +919,7 @@ static int __init sa1100_serial_init(void)
 
 static void __exit sa1100_serial_exit(void)
 {
-        driver_unregister(&sa11x0_serial_driver);
+        platform_driver_unregister(&sa11x0_serial_driver);
         uart_unregister_driver(&sa1100_reg);
 }
 
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index 01696b3e3f61..865d4dea65df 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -924,7 +924,7 @@ static struct uart_driver siu_uart_driver = {
         .cons           = SERIAL_VR41XX_CONSOLE,
 };
 
-static int siu_probe(struct device *dev)
+static int siu_probe(struct platform_device *dev)
 {
         struct uart_port *port;
         int num, i, retval;
@@ -941,7 +941,7 @@ static int siu_probe(struct device *dev)
         for (i = 0; i < num; i++) {
                 port = &siu_uart_ports[i];
                 port->ops = &siu_uart_ops;
-                port->dev = dev;
+                port->dev = &dev->dev;
 
                 retval = uart_add_one_port(&siu_uart_driver, port);
                 if (retval < 0) {
@@ -958,14 +958,14 @@ static int siu_probe(struct device *dev)
         return 0;
 }
 
-static int siu_remove(struct device *dev)
+static int siu_remove(struct platform_device *dev)
 {
         struct uart_port *port;
         int i;
 
         for (i = 0; i < siu_uart_driver.nr; i++) {
                 port = &siu_uart_ports[i];
-                if (port->dev == dev) {
+                if (port->dev == &dev->dev) {
                         uart_remove_one_port(&siu_uart_driver, port);
                         port->dev = NULL;
                 }
@@ -976,7 +976,7 @@ static int siu_remove(struct device *dev)
         return 0;
 }
 
-static int siu_suspend(struct device *dev, pm_message_t state)
+static int siu_suspend(struct platform_device *dev, pm_message_t state)
 {
         struct uart_port *port;
         int i;
@@ -984,7 +984,7 @@ static int siu_suspend(struct device *dev, pm_message_t state)
         for (i = 0; i < siu_uart_driver.nr; i++) {
                 port = &siu_uart_ports[i];
                 if ((port->type == PORT_VR41XX_SIU ||
-                     port->type == PORT_VR41XX_DSIU) && port->dev == dev)
+                     port->type == PORT_VR41XX_DSIU) && port->dev == &dev->dev)
                         uart_suspend_port(&siu_uart_driver, port);
 
         }
@@ -992,7 +992,7 @@ static int siu_suspend(struct device *dev, pm_message_t state)
         return 0;
 }
 
-static int siu_resume(struct device *dev)
+static int siu_resume(struct platform_device *dev)
 {
         struct uart_port *port;
         int i;
@@ -1000,7 +1000,7 @@ static int siu_resume(struct device *dev)
         for (i = 0; i < siu_uart_driver.nr; i++) {
                 port = &siu_uart_ports[i];
                 if ((port->type == PORT_VR41XX_SIU ||
-                     port->type == PORT_VR41XX_DSIU) && port->dev == dev)
+                     port->type == PORT_VR41XX_DSIU) && port->dev == &dev->dev)
                         uart_resume_port(&siu_uart_driver, port);
         }
 
@@ -1009,13 +1009,14 @@ static int siu_resume(struct device *dev)
 
 static struct platform_device *siu_platform_device;
 
-static struct device_driver siu_device_driver = {
-        .name           = "SIU",
-        .bus            = &platform_bus_type,
+static struct platform_driver siu_device_driver = {
         .probe          = siu_probe,
         .remove         = siu_remove,
         .suspend        = siu_suspend,
         .resume         = siu_resume,
+        .driver         = {
+                .name   = "SIU",
+        },
 };
 
 static int __devinit vr41xx_siu_init(void)
@@ -1026,7 +1027,7 @@ static int __devinit vr41xx_siu_init(void)
         if (IS_ERR(siu_platform_device))
                 return PTR_ERR(siu_platform_device);
 
-        retval = driver_register(&siu_device_driver);
+        retval = platform_driver_register(&siu_device_driver);
         if (retval < 0)
                 platform_device_unregister(siu_platform_device);
 
@@ -1035,7 +1036,7 @@ static int __devinit vr41xx_siu_init(void)
 
 static void __devexit vr41xx_siu_exit(void)
 {
-        driver_unregister(&siu_device_driver);
+        platform_driver_unregister(&siu_device_driver);
 
         platform_device_unregister(siu_platform_device);
 }