Merge master.kernel.org:/home/rmk/linux-2.6-drvmodel

16 files changed, 228 insertions, 228 deletions

diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c
index 193b482570c7..750cebb18306 100644
--- a/drivers/video/acornfb.c
+++ b/drivers/video/acornfb.c
@@ -1279,7 +1279,7 @@ free_unused_pages(unsigned int virtual_start, unsigned int virtual_end)
         printk("acornfb: freed %dK memory\n", mb_freed);
 }
 
-static int __init acornfb_probe(struct device *dev)
+static int __init acornfb_probe(struct platform_device *dev)
 {
         unsigned long size;
         u_int h_sync, v_sync;
@@ -1292,7 +1292,7 @@ static int __init acornfb_probe(struct device *dev)
 
         acornfb_init_fbinfo();
 
-        current_par.dev = dev;
+        current_par.dev = &dev->dev;
 
         if (current_par.montype == -1)
                 current_par.montype = acornfb_detect_monitortype();
@@ -1453,15 +1453,16 @@ static int __init acornfb_probe(struct device *dev)
         return 0;
 }
 
-static struct device_driver acornfb_driver = {
-        .name   = "acornfb",
-        .bus    = &platform_bus_type,
+static struct platform_driver acornfb_driver = {
         .probe  = acornfb_probe,
+        .driver = {
+                .name   = "acornfb",
+        },
 };
 
 static int __init acornfb_init(void)
 {
-        return driver_register(&acornfb_driver);
+        return platform_driver_register(&acornfb_driver);
 }
 
 module_init(acornfb_init);
diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index a1fc8bbb1090..080db812ca48 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -514,9 +514,8 @@ static struct fb_ops arcfb_ops = {
         .fb_ioctl       = arcfb_ioctl,
 };
 
-static int __init arcfb_probe(struct device *device)
+static int __init arcfb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct fb_info *info;
         int retval = -ENOMEM;
         int videomemorysize;
@@ -559,7 +558,7 @@ static int __init arcfb_probe(struct device *device)
         retval = register_framebuffer(info);
         if (retval < 0)
                 goto err1;
-        dev_set_drvdata(&dev->dev, info);
+        platform_set_drvdata(dev, info);
         if (irq) {
                 par->irq = irq;
                 if (request_irq(par->irq, &arcfb_interrupt, SA_SHIRQ,
@@ -600,9 +599,9 @@ err:
         return retval;
 }
 
-static int arcfb_remove(struct device *device)
+static int arcfb_remove(struct platform_device *dev)
 {
-        struct fb_info *info = dev_get_drvdata(device);
+        struct fb_info *info = platform_get_drvdata(dev);
 
         if (info) {
                 unregister_framebuffer(info);
@@ -612,11 +611,12 @@ static int arcfb_remove(struct device *device)
         return 0;
 }
 
-static struct device_driver arcfb_driver = {
-        .name   = "arcfb",
-        .bus    = &platform_bus_type,
+static struct platform_driver arcfb_driver = {
         .probe  = arcfb_probe,
         .remove = arcfb_remove,
+        .driver = {
+                .name   = "arcfb",
+        },
 };
 
 static struct platform_device *arcfb_device;
@@ -628,7 +628,7 @@ static int __init arcfb_init(void)
         if (!arcfb_enable)
                 return -ENXIO;
 
-        ret = driver_register(&arcfb_driver);
+        ret = platform_driver_register(&arcfb_driver);
         if (!ret) {
                 arcfb_device = platform_device_alloc("arcfb", 0);
                 if (arcfb_device) {
@@ -638,7 +638,7 @@ static int __init arcfb_init(void)
                 }
                 if (ret) {
                         platform_device_put(arcfb_device);
-                        driver_unregister(&arcfb_driver);
+                        platform_driver_unregister(&arcfb_driver);
                 }
         }
         return ret;
@@ -648,7 +648,7 @@ static int __init arcfb_init(void)
 static void __exit arcfb_exit(void)
 {
         platform_device_unregister(arcfb_device);
-        driver_unregister(&arcfb_driver);
+        platform_driver_unregister(&arcfb_driver);
 }
 
 module_param(num_cols, ulong, 0);
diff --git a/drivers/video/backlight/corgi_bl.c b/drivers/video/backlight/corgi_bl.c
index bd9a6996aee7..6a219b2c77e3 100644
--- a/drivers/video/backlight/corgi_bl.c
+++ b/drivers/video/backlight/corgi_bl.c
@@ -79,13 +79,13 @@ static void corgibl_blank(int blank)
 }
 
 #ifdef CONFIG_PM
-static int corgibl_suspend(struct device *dev, pm_message_t state)
+static int corgibl_suspend(struct platform_device *dev, pm_message_t state)
 {
         corgibl_blank(FB_BLANK_POWERDOWN);
         return 0;
 }
 
-static int corgibl_resume(struct device *dev)
+static int corgibl_resume(struct platform_device *dev)
 {
         corgibl_blank(FB_BLANK_UNBLANK);
         return 0;
@@ -143,9 +143,9 @@ static struct backlight_properties corgibl_data = {
 
 static struct backlight_device *corgi_backlight_device;
 
-static int __init corgibl_probe(struct device *dev)
+static int __init corgibl_probe(struct platform_device *pdev)
 {
-        struct corgibl_machinfo *machinfo = dev->platform_data;
+        struct corgibl_machinfo *machinfo = pdev->dev.platform_data;
 
         corgibl_data.max_brightness = machinfo->max_intensity;
         corgibl_mach_set_intensity = machinfo->set_bl_intensity;
@@ -162,7 +162,7 @@ static int __init corgibl_probe(struct device *dev)
         return 0;
 }
 
-static int corgibl_remove(struct device *dev)
+static int corgibl_remove(struct platform_device *dev)
 {
         backlight_device_unregister(corgi_backlight_device);
 
@@ -172,23 +172,24 @@ static int corgibl_remove(struct device *dev)
         return 0;
 }
 
-static struct device_driver corgibl_driver = {
-        .name           = "corgi-bl",
-        .bus            = &platform_bus_type,
+static struct platform_driver corgibl_driver = {
         .probe          = corgibl_probe,
         .remove         = corgibl_remove,
         .suspend        = corgibl_suspend,
         .resume         = corgibl_resume,
+        .driver         = {
+                .name   = "corgi-bl",
+        },
 };
 
 static int __init corgibl_init(void)
 {
-        return driver_register(&corgibl_driver);
+        return platform_driver_register(&corgibl_driver);
 }
 
 static void __exit corgibl_exit(void)
 {
-        driver_unregister(&corgibl_driver);
+        platform_driver_unregister(&corgibl_driver);
 }
 
 module_init(corgibl_init);
diff --git a/drivers/video/dnfb.c b/drivers/video/dnfb.c
index 957a3ada2b75..5abd3cb00671 100644
--- a/drivers/video/dnfb.c
+++ b/drivers/video/dnfb.c
@@ -227,9 +227,8 @@ void dnfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
  * Initialization
  */
 
-static int __devinit dnfb_probe(struct device *device)
+static int __devinit dnfb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct fb_info *info;
         int err = 0;
 
@@ -257,7 +256,7 @@ static int __devinit dnfb_probe(struct device *device)
                 framebuffer_release(info);
                 return err;
         }
-        dev_set_drvdata(&dev->dev, info);
+        platform_set_drvdata(dev, info);
 
         /* now we have registered we can safely setup the hardware */
         out_8(AP_CONTROL_3A, RESET_CREG);
@@ -271,10 +270,11 @@ static int __devinit dnfb_probe(struct device *device)
         return err;
 }
 
-static struct device_driver dnfb_driver = {
-        .name   = "dnfb",
-        .bus    = &platform_bus_type,
+static struct platform_driver dnfb_driver = {
         .probe  = dnfb_probe,
+        .driver = {
+                .name   = "dnfb",
+        },
 };
 
 static struct platform_device dnfb_device = {
@@ -288,12 +288,12 @@ int __init dnfb_init(void)
         if (fb_get_options("dnfb", NULL))
                 return -ENODEV;
 
-        ret = driver_register(&dnfb_driver);
+        ret = platform_driver_register(&dnfb_driver);
 
         if (!ret) {
                 ret = platform_device_register(&dnfb_device);
                 if (ret)
-                        driver_unregister(&dnfb_driver);
+                        platform_driver_unregister(&dnfb_driver);
         }
         return ret;
 }
diff --git a/drivers/video/epson1355fb.c b/drivers/video/epson1355fb.c
index 6a81a1dd8f3d..3b0e71383448 100644
--- a/drivers/video/epson1355fb.c
+++ b/drivers/video/epson1355fb.c
@@ -609,9 +609,9 @@ static void epson1355fb_platform_release(struct device *device)
 {
 }
 
-static int epson1355fb_remove(struct device *device)
+static int epson1355fb_remove(struct platform_device *dev)
 {
-        struct fb_info *info = dev_get_drvdata(device);
+        struct fb_info *info = platform_get_drvdata(dev);
         struct epson1355_par *par = info->par;
 
         backlight_enable(0);
@@ -632,9 +632,8 @@ static int epson1355fb_remove(struct device *device)
         return 0;
 }
 
-int __init epson1355fb_probe(struct device *device)
+int __init epson1355fb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct epson1355_par *default_par;
         struct fb_info *info;
         u8 revision;
@@ -713,7 +712,7 @@ int __init epson1355fb_probe(struct device *device)
         /*
          * Our driver data.
          */
-        dev_set_drvdata(&dev->dev, info);
+        platform_set_drvdata(dev, info);
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n",
                info->node, info->fix.id);
@@ -721,15 +720,16 @@ int __init epson1355fb_probe(struct device *device)
         return 0;
 
       bail:
-        epson1355fb_remove(device);
+        epson1355fb_remove(dev);
         return rc;
 }
 
-static struct device_driver epson1355fb_driver = {
-        .name   = "epson1355fb",
-        .bus    = &platform_bus_type,
+static struct platform_driver epson1355fb_driver = {
         .probe  = epson1355fb_probe,
         .remove = epson1355fb_remove,
+        .driver = {
+                .name   = "epson1355fb",
+        },
 };
 
 static struct platform_device epson1355fb_device = {
@@ -747,11 +747,11 @@ int __init epson1355fb_init(void)
         if (fb_get_options("epson1355fb", NULL))
                 return -ENODEV;
 
-        ret = driver_register(&epson1355fb_driver);
+        ret = platform_driver_register(&epson1355fb_driver);
         if (!ret) {
                 ret = platform_device_register(&epson1355fb_device);
                 if (ret)
-                        driver_unregister(&epson1355fb_driver);
+                        platform_driver_unregister(&epson1355fb_driver);
         }
         return ret;
 }
@@ -762,7 +762,7 @@ module_init(epson1355fb_init);
 static void __exit epson1355fb_exit(void)
 {
         platform_device_unregister(&epson1355fb_device);
-        driver_unregister(&epson1355fb_driver);
+        platform_driver_unregister(&epson1355fb_driver);
 }
 
 /* ------------------------------------------------------------------------- */
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index 9d5e4f342110..d744c51807b7 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -1105,12 +1105,11 @@ int __init gbefb_setup(char *options)
         return 0;
 }
 
-static int __init gbefb_probe(struct device *dev)
+static int __init gbefb_probe(struct platform_device *p_dev)
 {
         int i, ret = 0;
         struct fb_info *info;
         struct gbefb_par *par;
-        struct platform_device *p_dev = to_platform_device(dev);
 #ifndef MODULE
         char *options = NULL;
 #endif
@@ -1204,8 +1203,8 @@ static int __init gbefb_probe(struct device *dev)
                 goto out_gbe_unmap;
         }
 
-        dev_set_drvdata(&p_dev->dev, info);
-        gbefb_create_sysfs(dev);
+        platform_set_drvdata(p_dev, info);
+        gbefb_create_sysfs(&p_dev->dev);
 
         printk(KERN_INFO "fb%d: %s rev %d @ 0x%08x using %dkB memory\n",
                info->node, info->fix.id, gbe_revision, (unsigned) GBE_BASE,
@@ -1231,10 +1230,9 @@ out_release_framebuffer:
         return ret;
 }
 
-static int __devexit gbefb_remove(struct device* dev)
+static int __devexit gbefb_remove(struct platform_device* p_dev)
 {
-        struct platform_device *p_dev = to_platform_device(dev);
-        struct fb_info *info = dev_get_drvdata(&p_dev->dev);
+        struct fb_info *info = platform_get_drvdata(p_dev);
 
         unregister_framebuffer(info);
         gbe_turn_off();
@@ -1252,18 +1250,19 @@ static int __devexit gbefb_remove(struct device* dev)
         return 0;
 }
 
-static struct device_driver gbefb_driver = {
-        .name = "gbefb",
-        .bus = &platform_bus_type,
+static struct platform_driver gbefb_driver = {
         .probe = gbefb_probe,
         .remove = __devexit_p(gbefb_remove),
+        .driver = {
+                .name = "gbefb",
+        },
 };
 
 static struct platform_device *gbefb_device;
 
 int __init gbefb_init(void)
 {
-        int ret = driver_register(&gbefb_driver);
+        int ret = platform_driver_register(&gbefb_driver);
         if (!ret) {
                 gbefb_device = platform_device_alloc("gbefb", 0);
                 if (gbefb_device) {
@@ -1273,7 +1272,7 @@ int __init gbefb_init(void)
                 }
                 if (ret) {
                         platform_device_put(gbefb_device);
-                        driver_unregister(&gbefb_driver);
+                        platform_driver_unregister(&gbefb_driver);
                 }
         }
         return ret;
@@ -1282,7 +1281,7 @@ int __init gbefb_init(void)
 void __exit gbefb_exit(void)
 {
         platform_device_unregister(gbefb_device);
-        driver_unregister(&gbefb_driver);
+        platform_driver_unregister(&gbefb_driver);
 }
 
 module_init(gbefb_init);
diff --git a/drivers/video/imxfb.c b/drivers/video/imxfb.c
index e20b9f3a255f..5924cc225c95 100644
--- a/drivers/video/imxfb.c
+++ b/drivers/video/imxfb.c
@@ -423,18 +423,18 @@ static void imxfb_setup_gpio(struct imxfb_info *fbi)
  * Power management hooks.  Note that we won't be called from IRQ context,
  * unlike the blank functions above, so we may sleep.
  */
-static int imxfb_suspend(struct device *dev, pm_message_t state)
+static int imxfb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct imxfb_info *fbi = dev_get_drvdata(dev);
+        struct imxfb_info *fbi = platform_get_drvdata(dev);
         pr_debug("%s\n",__FUNCTION__);
 
         imxfb_disable_controller(fbi);
         return 0;
 }
 
-static int imxfb_resume(struct device *dev)
+static int imxfb_resume(struct platform_device *dev)
 {
-        struct imxfb_info *fbi = dev_get_drvdata(dev);
+        struct imxfb_info *fbi = platform_get_drvdata(dev);
         pr_debug("%s\n",__FUNCTION__);
 
         imxfb_enable_controller(fbi);
@@ -538,9 +538,8 @@ static int __init imxfb_map_video_memory(struct fb_info *info)
         return fbi->map_cpu ? 0 : -ENOMEM;
 }
 
-static int __init imxfb_probe(struct device *dev)
+static int __init imxfb_probe(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         struct imxfb_info *fbi;
         struct fb_info *info;
         struct imxfb_mach_info *inf;
@@ -553,21 +552,21 @@ static int __init imxfb_probe(struct device *dev)
         if(!res)
                 return -ENODEV;
 
-        inf = dev->platform_data;
+        inf = pdev->dev.platform_data;
         if(!inf) {
                 dev_err(dev,"No platform_data available\n");
                 return -ENOMEM;
         }
 
-        info = framebuffer_alloc(sizeof(struct imxfb_info), dev);
+        info = framebuffer_alloc(sizeof(struct imxfb_info), &pdev->dev);
         if(!info)
                 return -ENOMEM;
 
         fbi = info->par;
 
-        dev_set_drvdata(dev, info);
+        platform_set_drvdata(pdev, info);
 
-        ret = imxfb_init_fbinfo(dev);
+        ret = imxfb_init_fbinfo(&pdev->dev);
         if( ret < 0 )
                 goto failed_init;
 
@@ -621,22 +620,21 @@ failed_register:
         fb_dealloc_cmap(&info->cmap);
 failed_cmap:
         if (!inf->fixed_screen_cpu)
-                dma_free_writecombine(dev,fbi->map_size,fbi->map_cpu,
+                dma_free_writecombine(&pdev->dev,fbi->map_size,fbi->map_cpu,
                            fbi->map_dma);
 failed_map:
         kfree(info->pseudo_palette);
 failed_regs:
         release_mem_region(res->start, res->end - res->start);
 failed_init:
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
         framebuffer_release(info);
         return ret;
 }
 
-static int imxfb_remove(struct device *dev)
+static int imxfb_remove(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(pdev);
         struct imxfb_info *fbi = info->par;
         struct resource *res;
 
@@ -651,36 +649,37 @@ static int imxfb_remove(struct device *dev)
         framebuffer_release(info);
 
         release_mem_region(res->start, res->end - res->start + 1);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         return 0;
 }
 
-void  imxfb_shutdown(struct device * dev)
+void  imxfb_shutdown(struct platform_device * dev)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
         struct imxfb_info *fbi = info->par;
         imxfb_disable_controller(fbi);
 }
 
-static struct device_driver imxfb_driver = {
-        .name           = "imx-fb",
-        .bus            = &platform_bus_type,
+static struct platform_driver imxfb_driver = {
         .probe          = imxfb_probe,
         .suspend        = imxfb_suspend,
         .resume         = imxfb_resume,
         .remove         = imxfb_remove,
         .shutdown       = imxfb_shutdown,
+        .driver         = {
+                .name   = "imx-fb",
+        },
 };
 
 int __init imxfb_init(void)
 {
-        return driver_register(&imxfb_driver);
+        return platform_driver_register(&imxfb_driver);
 }
 
 static void __exit imxfb_cleanup(void)
 {
-        driver_unregister(&imxfb_driver);
+        platform_driver_unregister(&imxfb_driver);
 }
 
 module_init(imxfb_init);
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index f305a5b77b23..7b4cd250bec8 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -980,17 +980,17 @@ pxafb_freq_policy(struct notifier_block *nb, unsigned long val, void *data)
  * Power management hooks.  Note that we won't be called from IRQ context,
  * unlike the blank functions above, so we may sleep.
  */
-static int pxafb_suspend(struct device *dev, pm_message_t state)
+static int pxafb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct pxafb_info *fbi = dev_get_drvdata(dev);
+        struct pxafb_info *fbi = platform_get_drvdata(dev);
 
         set_ctrlr_state(fbi, C_DISABLE_PM);
         return 0;
 }
 
-static int pxafb_resume(struct device *dev)
+static int pxafb_resume(struct platform_device *dev)
 {
-        struct pxafb_info *fbi = dev_get_drvdata(dev);
+        struct pxafb_info *fbi = platform_get_drvdata(dev);
 
         set_ctrlr_state(fbi, C_ENABLE_PM);
         return 0;
@@ -1268,7 +1268,7 @@ static int __init pxafb_parse_options(struct device *dev, char *options)
 }
 #endif
 
-int __init pxafb_probe(struct device *dev)
+int __init pxafb_probe(struct platform_device *dev)
 {
         struct pxafb_info *fbi;
         struct pxafb_mach_info *inf;
@@ -1276,14 +1276,14 @@ int __init pxafb_probe(struct device *dev)
 
         dev_dbg(dev, "pxafb_probe\n");
 
-        inf = dev->platform_data;
+        inf = dev->dev.platform_data;
         ret = -ENOMEM;
         fbi = NULL;
         if (!inf)
                 goto failed;
 
 #ifdef CONFIG_FB_PXA_PARAMETERS
-        ret = pxafb_parse_options(dev, g_options);
+        ret = pxafb_parse_options(&dev->dev, g_options);
         if (ret < 0)
                 goto failed;
 #endif
@@ -1293,36 +1293,36 @@ int __init pxafb_probe(struct device *dev)
          * a warning is given. */
 
         if (inf->lccr0 & LCCR0_INVALID_CONFIG_MASK)
-                dev_warn(dev, "machine LCCR0 setting contains illegal bits: %08x\n",
+                dev_warn(&dev->dev, "machine LCCR0 setting contains illegal bits: %08x\n",
                         inf->lccr0 & LCCR0_INVALID_CONFIG_MASK);
         if (inf->lccr3 & LCCR3_INVALID_CONFIG_MASK)
-                dev_warn(dev, "machine LCCR3 setting contains illegal bits: %08x\n",
+                dev_warn(&dev->dev, "machine LCCR3 setting contains illegal bits: %08x\n",
                         inf->lccr3 & LCCR3_INVALID_CONFIG_MASK);
         if (inf->lccr0 & LCCR0_DPD &&
             ((inf->lccr0 & LCCR0_PAS) != LCCR0_Pas ||
              (inf->lccr0 & LCCR0_SDS) != LCCR0_Sngl ||
              (inf->lccr0 & LCCR0_CMS) != LCCR0_Mono))
-                dev_warn(dev, "Double Pixel Data (DPD) mode is only valid in passive mono"
+                dev_warn(&dev->dev, "Double Pixel Data (DPD) mode is only valid in passive mono"
                          " single panel mode\n");
         if ((inf->lccr0 & LCCR0_PAS) == LCCR0_Act &&
             (inf->lccr0 & LCCR0_SDS) == LCCR0_Dual)
-                dev_warn(dev, "Dual panel only valid in passive mode\n");
+                dev_warn(&dev->dev, "Dual panel only valid in passive mode\n");
         if ((inf->lccr0 & LCCR0_PAS) == LCCR0_Pas &&
              (inf->upper_margin || inf->lower_margin))
-                dev_warn(dev, "Upper and lower margins must be 0 in passive mode\n");
+                dev_warn(&dev->dev, "Upper and lower margins must be 0 in passive mode\n");
 #endif
 
-        dev_dbg(dev, "got a %dx%dx%d LCD\n",inf->xres, inf->yres, inf->bpp);
+        dev_dbg(&dev->dev, "got a %dx%dx%d LCD\n",inf->xres, inf->yres, inf->bpp);
         if (inf->xres == 0 || inf->yres == 0 || inf->bpp == 0) {
-                dev_err(dev, "Invalid resolution or bit depth\n");
+                dev_err(&dev->dev, "Invalid resolution or bit depth\n");
                 ret = -EINVAL;
                 goto failed;
         }
         pxafb_backlight_power = inf->pxafb_backlight_power;
         pxafb_lcd_power = inf->pxafb_lcd_power;
-        fbi = pxafb_init_fbinfo(dev);
+        fbi = pxafb_init_fbinfo(&dev->dev);
         if (!fbi) {
-                dev_err(dev, "Failed to initialize framebuffer device\n");
+                dev_err(&dev->dev, "Failed to initialize framebuffer device\n");
                 ret = -ENOMEM; // only reason for pxafb_init_fbinfo to fail is kmalloc
                 goto failed;
         }
@@ -1330,14 +1330,14 @@ int __init pxafb_probe(struct device *dev)
         /* Initialize video memory */
         ret = pxafb_map_video_memory(fbi);
         if (ret) {
-                dev_err(dev, "Failed to allocate video RAM: %d\n", ret);
+                dev_err(&dev->dev, "Failed to allocate video RAM: %d\n", ret);
                 ret = -ENOMEM;
                 goto failed;
         }
 
         ret = request_irq(IRQ_LCD, pxafb_handle_irq, SA_INTERRUPT, "LCD", fbi);
         if (ret) {
-                dev_err(dev, "request_irq failed: %d\n", ret);
+                dev_err(&dev->dev, "request_irq failed: %d\n", ret);
                 ret = -EBUSY;
                 goto failed;
         }
@@ -1349,11 +1349,11 @@ int __init pxafb_probe(struct device *dev)
         pxafb_check_var(&fbi->fb.var, &fbi->fb);
         pxafb_set_par(&fbi->fb);
 
-        dev_set_drvdata(dev, fbi);
+        platform_set_drvdata(dev, fbi);
 
         ret = register_framebuffer(&fbi->fb);
         if (ret < 0) {
-                dev_err(dev, "Failed to register framebuffer device: %d\n", ret);
+                dev_err(&dev->dev, "Failed to register framebuffer device: %d\n", ret);
                 goto failed;
         }
 
@@ -1376,19 +1376,20 @@ int __init pxafb_probe(struct device *dev)
         return 0;
 
 failed:
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
         kfree(fbi);
         return ret;
 }
 
-static struct device_driver pxafb_driver = {
-        .name           = "pxa2xx-fb",
-        .bus            = &platform_bus_type,
+static struct platform_driver pxafb_driver = {
         .probe          = pxafb_probe,
 #ifdef CONFIG_PM
         .suspend        = pxafb_suspend,
         .resume         = pxafb_resume,
 #endif
+        .driver         = {
+                .name   = "pxa2xx-fb",
+        },
 };
 
 #ifndef MODULE
@@ -1415,7 +1416,7 @@ int __devinit pxafb_init(void)
                 return -ENODEV;
         pxafb_setup(option);
 #endif
-        return driver_register(&pxafb_driver);
+        return platform_driver_register(&pxafb_driver);
 }
 
 module_init(pxafb_init);
diff --git a/drivers/video/q40fb.c b/drivers/video/q40fb.c
index bfc41f2c902a..fc91dbf896d2 100644
--- a/drivers/video/q40fb.c
+++ b/drivers/video/q40fb.c
@@ -86,9 +86,8 @@ static struct fb_ops q40fb_ops = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-static int __init q40fb_probe(struct device *device)
+static int __init q40fb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct fb_info *info;
 
         if (!MACH_IS_Q40)
@@ -128,10 +127,11 @@ static int __init q40fb_probe(struct device *device)
         return 0;
 }
 
-static struct device_driver q40fb_driver = {
-        .name   = "q40fb",
-        .bus    = &platform_bus_type,
+static struct platform_driver q40fb_driver = {
         .probe  = q40fb_probe,
+        .driver = {
+                .name   = "q40fb",
+        },
 };
 
 static struct platform_device q40fb_device = {
@@ -145,12 +145,12 @@ int __init q40fb_init(void)
         if (fb_get_options("q40fb", NULL))
                 return -ENODEV;
 
-        ret = driver_register(&q40fb_driver);
+        ret = platform_driver_register(&q40fb_driver);
 
         if (!ret) {
                 ret = platform_device_register(&q40fb_device);
                 if (ret)
-                        driver_unregister(&q40fb_driver);
+                        platform_driver_unregister(&q40fb_driver);
         }
         return ret;
 }
diff --git a/drivers/video/s1d13xxxfb.c b/drivers/video/s1d13xxxfb.c
index 3edbd14c5c46..e5d0f92eeae3 100644
--- a/drivers/video/s1d13xxxfb.c
+++ b/drivers/video/s1d13xxxfb.c
@@ -503,10 +503,9 @@ s1d13xxxfb_fetch_hw_state(struct fb_info *info)
 
 
 static int
-s1d13xxxfb_remove(struct device *dev)
+s1d13xxxfb_remove(struct platform_device *pdev)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
-        struct platform_device *pdev = to_platform_device(dev);
+        struct fb_info *info = platform_get_drvdata(pdev);
         struct s1d13xxxfb_par *par = NULL;
 
         if (info) {
@@ -534,9 +533,8 @@ s1d13xxxfb_remove(struct device *dev)
 }
 
 static int __devinit
-s1d13xxxfb_probe(struct device *dev)
+s1d13xxxfb_probe(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         struct s1d13xxxfb_par *default_par;
         struct fb_info *info;
         struct s1d13xxxfb_pdata *pdata = NULL;
@@ -548,8 +546,8 @@ s1d13xxxfb_probe(struct device *dev)
         printk(KERN_INFO "Epson S1D13XXX FB Driver\n");
 
         /* enable platform-dependent hardware glue, if any */
-        if (dev->platform_data)
-                pdata = dev->platform_data;
+        if (pdev->dev.platform_data)
+                pdata = pdev->dev.platform_data;
 
         if (pdata && pdata->platform_init_video)
                 pdata->platform_init_video();
@@ -572,14 +570,14 @@ s1d13xxxfb_probe(struct device *dev)
 
         if (!request_mem_region(pdev->resource[0].start,
                 pdev->resource[0].end - pdev->resource[0].start +1, "s1d13xxxfb mem")) {
-                dev_dbg(dev, "request_mem_region failed\n");
+                dev_dbg(&pdev->dev, "request_mem_region failed\n");
                 ret = -EBUSY;
                 goto bail;
         }
 
         if (!request_mem_region(pdev->resource[1].start,
                 pdev->resource[1].end - pdev->resource[1].start +1, "s1d13xxxfb regs")) {
-                dev_dbg(dev, "request_mem_region failed\n");
+                dev_dbg(&pdev->dev, "request_mem_region failed\n");
                 ret = -EBUSY;
                 goto bail;
         }
@@ -640,7 +638,7 @@ s1d13xxxfb_probe(struct device *dev)
                 goto bail;
         }
 
-        dev_set_drvdata(&pdev->dev, info);
+        platform_set_drvdata(pdev, info);
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n",
                info->node, info->fix.id);
@@ -648,15 +646,15 @@ s1d13xxxfb_probe(struct device *dev)
         return 0;
 
 bail:
-        s1d13xxxfb_remove(dev);
+        s1d13xxxfb_remove(pdev);
         return ret;
 
 }
 
 #ifdef CONFIG_PM
-static int s1d13xxxfb_suspend(struct device *dev, pm_message_t state)
+static int s1d13xxxfb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
         struct s1d13xxxfb_par *s1dfb = info->par;
         struct s1d13xxxfb_pdata *pdata = NULL;
 
@@ -664,8 +662,8 @@ static int s1d13xxxfb_suspend(struct device *dev, pm_message_t state)
         lcd_enable(s1dfb, 0);
         crt_enable(s1dfb, 0);
 
-        if (dev->platform_data)
-                pdata = dev->platform_data;
+        if (dev->dev.platform_data)
+                pdata = dev->dev.platform_data;
 
 #if 0
         if (!s1dfb->disp_save)
@@ -701,9 +699,9 @@ static int s1d13xxxfb_suspend(struct device *dev, pm_message_t state)
                 return 0;
 }
 
-static int s1d13xxxfb_resume(struct device *dev)
+static int s1d13xxxfb_resume(struct platform_device *dev)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
         struct s1d13xxxfb_par *s1dfb = info->par;
         struct s1d13xxxfb_pdata *pdata = NULL;
 
@@ -714,8 +712,8 @@ static int s1d13xxxfb_resume(struct device *dev)
         while ((s1d13xxxfb_readreg(s1dfb, S1DREG_PS_STATUS) & 0x01))
                 udelay(10);
 
-        if (dev->platform_data)
-                pdata = dev->platform_data;
+        if (dev->dev.platform_data)
+                pdata = dev->dev.platform_data;
 
         if (s1dfb->regs_save) {
                 /* will write RO regs, *should* get away with it :) */
@@ -741,15 +739,16 @@ static int s1d13xxxfb_resume(struct device *dev)
 }
 #endif /* CONFIG_PM */
 
-static struct device_driver s1d13xxxfb_driver = {
-        .name           = S1D_DEVICENAME,
-        .bus            = &platform_bus_type,
+static struct platform_driver s1d13xxxfb_driver = {
         .probe          = s1d13xxxfb_probe,
         .remove         = s1d13xxxfb_remove,
 #ifdef CONFIG_PM
         .suspend        = s1d13xxxfb_suspend,
-        .resume         = s1d13xxxfb_resume
+        .resume         = s1d13xxxfb_resume,
 #endif
+        .driver         = {
+                .name   = S1D_DEVICENAME,
+        },
 };
 
 
@@ -759,14 +758,14 @@ s1d13xxxfb_init(void)
         if (fb_get_options("s1d13xxxfb", NULL))
                 return -ENODEV;
 
-        return driver_register(&s1d13xxxfb_driver);
+        return platform_driver_register(&s1d13xxxfb_driver);
 }
 
 
 static void __exit
 s1d13xxxfb_exit(void)
 {
-        driver_unregister(&s1d13xxxfb_driver);
+        platform_driver_unregister(&s1d13xxxfb_driver);
 }
 
 module_init(s1d13xxxfb_init);
diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c
index 855a6778b9eb..ce6e749db3a7 100644
--- a/drivers/video/s3c2410fb.c
+++ b/drivers/video/s3c2410fb.c
@@ -634,19 +634,18 @@ static irqreturn_t s3c2410fb_irq(int irq, void *dev_id, struct pt_regs *r)
 
 static char driver_name[]="s3c2410fb";
 
-int __init s3c2410fb_probe(struct device *dev)
+int __init s3c2410fb_probe(struct platform_device *pdev)
 {
         struct s3c2410fb_info *info;
         struct fb_info     *fbinfo;
-        struct platform_device *pdev = to_platform_device(dev);
         struct s3c2410fb_hw *mregs;
         int ret;
         int irq;
         int i;
 
-        mach_info = dev->platform_data;
+        mach_info = pdev->dev.platform_data;
         if (mach_info == NULL) {
-                dev_err(dev,"no platform data for lcd, cannot attach\n");
+                dev_err(&pdev->dev,"no platform data for lcd, cannot attach\n");
                 return -EINVAL;
         }
 
@@ -654,11 +653,11 @@ int __init s3c2410fb_probe(struct device *dev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
-                dev_err(dev, "no irq for device\n");
+                dev_err(&pdev->dev, "no irq for device\n");
                 return -ENOENT;
         }
 
-        fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), dev);
+        fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);
         if (!fbinfo) {
                 return -ENOMEM;
         }
@@ -666,7 +665,7 @@ int __init s3c2410fb_probe(struct device *dev)
 
         info = fbinfo->par;
         info->fb = fbinfo;
-        dev_set_drvdata(dev, fbinfo);
+        platform_set_drvdata(pdev, fbinfo);
 
         s3c2410fb_init_registers(info);
 
@@ -676,7 +675,7 @@ int __init s3c2410fb_probe(struct device *dev)
 
         memcpy(&info->regs, &mach_info->regs, sizeof(info->regs));
 
-        info->mach_info             = dev->platform_data;
+        info->mach_info             = pdev->dev.platform_data;
 
         fbinfo->fix.type            = FB_TYPE_PACKED_PIXELS;
         fbinfo->fix.type_aux        = 0;
@@ -735,7 +734,7 @@ int __init s3c2410fb_probe(struct device *dev)
 
         ret = request_irq(irq, s3c2410fb_irq, SA_INTERRUPT, pdev->name, info);
         if (ret) {
-                dev_err(dev, "cannot get irq %d - err %d\n", irq, ret);
+                dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
                 ret = -EBUSY;
                 goto release_mem;
         }
@@ -773,7 +772,7 @@ int __init s3c2410fb_probe(struct device *dev)
         }
 
         /* create device files */
-        device_create_file(dev, &dev_attr_debug);
+        device_create_file(&pdev->dev, &dev_attr_debug);
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n",
                 fbinfo->node, fbinfo->fix.id);
@@ -816,10 +815,9 @@ static void s3c2410fb_stop_lcd(void)
 /*
  *  Cleanup
  */
-static int s3c2410fb_remove(struct device *dev)
+static int s3c2410fb_remove(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct fb_info     *fbinfo = dev_get_drvdata(dev);
+        struct fb_info     *fbinfo = platform_get_drvdata(pdev);
         struct s3c2410fb_info *info = fbinfo->par;
         int irq;
 
@@ -847,9 +845,9 @@ static int s3c2410fb_remove(struct device *dev)
 
 /* suspend and resume support for the lcd controller */
 
-static int s3c2410fb_suspend(struct device *dev, pm_message_t state)
+static int s3c2410fb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct fb_info     *fbinfo = dev_get_drvdata(dev);
+        struct fb_info     *fbinfo = platform_get_drvdata(dev);
         struct s3c2410fb_info *info = fbinfo->par;
 
         s3c2410fb_stop_lcd();
@@ -864,9 +862,9 @@ static int s3c2410fb_suspend(struct device *dev, pm_message_t state)
         return 0;
 }
 
-static int s3c2410fb_resume(struct device *dev)
+static int s3c2410fb_resume(struct platform_device *dev)
 {
-        struct fb_info     *fbinfo = dev_get_drvdata(dev);
+        struct fb_info     *fbinfo = platform_get_drvdata(dev);
         struct s3c2410fb_info *info = fbinfo->par;
 
         clk_enable(info->clk);
@@ -882,24 +880,25 @@ static int s3c2410fb_resume(struct device *dev)
 #define s3c2410fb_resume  NULL
 #endif
 
-static struct device_driver s3c2410fb_driver = {
-        .name           = "s3c2410-lcd",
-        .owner          = THIS_MODULE,
-        .bus            = &platform_bus_type,
+static struct platform_driver s3c2410fb_driver = {
         .probe          = s3c2410fb_probe,
+        .remove         = s3c2410fb_remove,
         .suspend        = s3c2410fb_suspend,
         .resume         = s3c2410fb_resume,
-        .remove         = s3c2410fb_remove
+        .driver         = {
+                .name   = "s3c2410-lcd",
+                .owner  = THIS_MODULE,
+        },
 };
 
 int __devinit s3c2410fb_init(void)
 {
-        return driver_register(&s3c2410fb_driver);
+        return platform_driver_register(&s3c2410fb_driver);
 }
 
 static void __exit s3c2410fb_cleanup(void)
 {
-        driver_unregister(&s3c2410fb_driver);
+        platform_driver_unregister(&s3c2410fb_driver);
 }
 
 
diff --git a/drivers/video/sa1100fb.c b/drivers/video/sa1100fb.c
index a5184575cfae..2ea1354e439f 100644
--- a/drivers/video/sa1100fb.c
+++ b/drivers/video/sa1100fb.c
@@ -1308,17 +1308,17 @@ sa1100fb_freq_policy(struct notifier_block *nb, unsigned long val,
  * Power management hooks.  Note that we won't be called from IRQ context,
  * unlike the blank functions above, so we may sleep.
  */
-static int sa1100fb_suspend(struct device *dev, pm_message_t state)
+static int sa1100fb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct sa1100fb_info *fbi = dev_get_drvdata(dev);
+        struct sa1100fb_info *fbi = platform_get_drvdata(dev);
 
         set_ctrlr_state(fbi, C_DISABLE_PM);
         return 0;
 }
 
-static int sa1100fb_resume(struct device *dev)
+static int sa1100fb_resume(struct platform_device *dev)
 {
-        struct sa1100fb_info *fbi = dev_get_drvdata(dev);
+        struct sa1100fb_info *fbi = platform_get_drvdata(dev);
 
         set_ctrlr_state(fbi, C_ENABLE_PM);
         return 0;
@@ -1452,7 +1452,7 @@ static struct sa1100fb_info * __init sa1100fb_init_fbinfo(struct device *dev)
         return fbi;
 }
 
-static int __init sa1100fb_probe(struct device *dev)
+static int __init sa1100fb_probe(struct platform_device *pdev)
 {
         struct sa1100fb_info *fbi;
         int ret;
@@ -1460,7 +1460,7 @@ static int __init sa1100fb_probe(struct device *dev)
         if (!request_mem_region(0xb0100000, 0x10000, "LCD"))
                 return -EBUSY;
 
-        fbi = sa1100fb_init_fbinfo(dev);
+        fbi = sa1100fb_init_fbinfo(&pdev->dev);
         ret = -ENOMEM;
         if (!fbi)
                 goto failed;
@@ -1488,7 +1488,7 @@ static int __init sa1100fb_probe(struct device *dev)
          */
         sa1100fb_check_var(&fbi->fb.var, &fbi->fb);
 
-        dev_set_drvdata(dev, fbi);
+        platform_set_drvdata(pdev, fbi);
 
         ret = register_framebuffer(&fbi->fb);
         if (ret < 0)
@@ -1505,18 +1505,19 @@ static int __init sa1100fb_probe(struct device *dev)
         return 0;
 
 failed:
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
         kfree(fbi);
         release_mem_region(0xb0100000, 0x10000);
         return ret;
 }
 
-static struct device_driver sa1100fb_driver = {
-        .name           = "sa11x0-fb",
-        .bus            = &platform_bus_type,
+static struct platform_driver sa1100fb_driver = {
         .probe          = sa1100fb_probe,
         .suspend        = sa1100fb_suspend,
         .resume         = sa1100fb_resume,
+        .driver         = {
+                .name   = "sa11x0-fb",
+        },
 };
 
 int __init sa1100fb_init(void)
@@ -1524,7 +1525,7 @@ int __init sa1100fb_init(void)
         if (fb_get_options("sa1100fb", NULL))
                 return -ENODEV;
 
-        return driver_register(&sa1100fb_driver);
+        return platform_driver_register(&sa1100fb_driver);
 }
 
 int __init sa1100fb_setup(char *options)
diff --git a/drivers/video/sgivwfb.c b/drivers/video/sgivwfb.c
index 2e8769dd345a..7054660767e4 100644
--- a/drivers/video/sgivwfb.c
+++ b/drivers/video/sgivwfb.c
@@ -750,9 +750,8 @@ int __init sgivwfb_setup(char *options)
 /*
  *  Initialisation
  */
-static int __init sgivwfb_probe(struct device *device)
+static int __init sgivwfb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct sgivw_par *par;
         struct fb_info *info;
         char *monitor;
@@ -813,7 +812,7 @@ static int __init sgivwfb_probe(struct device *device)
                 goto fail_register_framebuffer;
         }
 
-        dev_set_drvdata(&dev->dev, info);
+        platform_set_drvdata(dev, info);
 
         printk(KERN_INFO "fb%d: SGI DBE frame buffer device, using %ldK of video memory at %#lx\n",      
                 info->node, sgivwfb_mem_size >> 10, sgivwfb_mem_phys);
@@ -831,9 +830,9 @@ fail_ioremap_regs:
         return -ENXIO;
 }
 
-static int sgivwfb_remove(struct device *device)
+static int sgivwfb_remove(struct platform_device *dev)
 {
-        struct fb_info *info = dev_get_drvdata(device);
+        struct fb_info *info = platform_get_drvdata(dev);
 
         if (info) {
                 struct sgivw_par *par = info->par;
@@ -847,11 +846,12 @@ static int sgivwfb_remove(struct device *device)
         return 0;
 }
 
-static struct device_driver sgivwfb_driver = {
-        .name   = "sgivwfb",
-        .bus    = &platform_bus_type,
+static struct platform_driver sgivwfb_driver = {
         .probe  = sgivwfb_probe,
         .remove = sgivwfb_remove,
+        .driver = {
+                .name   = "sgivwfb",
+        },
 };
 
 static struct platform_device *sgivwfb_device;
@@ -867,7 +867,7 @@ int __init sgivwfb_init(void)
                 return -ENODEV;
         sgivwfb_setup(option);
 #endif
-        ret = driver_register(&sgivwfb_driver);
+        ret = platform_driver_register(&sgivwfb_driver);
         if (!ret) {
                 sgivwfb_device = platform_device_alloc("sgivwfb", 0);
                 if (sgivwfb_device) {
@@ -875,7 +875,7 @@ int __init sgivwfb_init(void)
                 } else
                         ret = -ENOMEM;
                 if (ret) {
-                        driver_unregister(&sgivwfb_driver);
+                        platform_driver_unregister(&sgivwfb_driver);
                         platform_device_put(sgivwfb_device);
                 }
         }
@@ -890,7 +890,7 @@ MODULE_LICENSE("GPL");
 static void __exit sgivwfb_exit(void)
 {
         platform_device_unregister(sgivwfb_device);
-        driver_unregister(&sgivwfb_driver);
+        platform_driver_unregister(&sgivwfb_driver);
 }
 
 module_exit(sgivwfb_exit);
diff --git a/drivers/video/vesafb.c b/drivers/video/vesafb.c
index e25eae1a78c1..2c3aa2fcfd91 100644
--- a/drivers/video/vesafb.c
+++ b/drivers/video/vesafb.c
@@ -245,9 +245,8 @@ static int __init vesafb_setup(char *options)
         return 0;
 }
 
-static int __init vesafb_probe(struct device *device)
+static int __init vesafb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct fb_info *info;
         int i, err;
         unsigned int size_vmode;
@@ -480,10 +479,11 @@ err:
         return err;
 }
 
-static struct device_driver vesafb_driver = {
-        .name   = "vesafb",
-        .bus    = &platform_bus_type,
+static struct platform_driver vesafb_driver = {
         .probe  = vesafb_probe,
+        .driver = {
+                .name   = "vesafb",
+        },
 };
 
 static struct platform_device vesafb_device = {
@@ -498,12 +498,12 @@ static int __init vesafb_init(void)
         /* ignore error return of fb_get_options */
         fb_get_options("vesafb", &option);
         vesafb_setup(option);
-        ret = driver_register(&vesafb_driver);
+        ret = platform_driver_register(&vesafb_driver);
 
         if (!ret) {
                 ret = platform_device_register(&vesafb_device);
                 if (ret)
-                        driver_unregister(&vesafb_driver);
+                        platform_driver_unregister(&vesafb_driver);
         }
         return ret;
 }
diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c
index 8794dc5d2466..ffa1ad474226 100644
--- a/drivers/video/vfb.c
+++ b/drivers/video/vfb.c
@@ -403,9 +403,8 @@ static void vfb_platform_release(struct device *device)
         // This is called when the reference count goes to zero.
 }
 
-static int __init vfb_probe(struct device *device)
+static int __init vfb_probe(struct platform_device *dev)
 {
-        struct platform_device *dev = to_platform_device(device);
         struct fb_info *info;
         int retval = -ENOMEM;
 
@@ -447,7 +446,7 @@ static int __init vfb_probe(struct device *device)
         retval = register_framebuffer(info);
         if (retval < 0)
                 goto err2;
-        dev_set_drvdata(&dev->dev, info);
+        platform_set_drvdata(dev, info);
 
         printk(KERN_INFO
                "fb%d: Virtual frame buffer device, using %ldK of video memory\n",
@@ -462,9 +461,9 @@ err:
         return retval;
 }
 
-static int vfb_remove(struct device *device)
+static int vfb_remove(struct platform_device *dev)
 {
-        struct fb_info *info = dev_get_drvdata(device);
+        struct fb_info *info = platform_get_drvdata(dev);
 
         if (info) {
                 unregister_framebuffer(info);
@@ -474,11 +473,12 @@ static int vfb_remove(struct device *device)
         return 0;
 }
 
-static struct device_driver vfb_driver = {
-        .name   = "vfb",
-        .bus    = &platform_bus_type,
+static struct platform_driver vfb_driver = {
         .probe  = vfb_probe,
         .remove = vfb_remove,
+        .driver = {
+                .name   = "vfb",
+        },
 };
 
 static struct platform_device vfb_device = {
@@ -504,12 +504,12 @@ static int __init vfb_init(void)
         if (!vfb_enable)
                 return -ENXIO;
 
-        ret = driver_register(&vfb_driver);
+        ret = platform_driver_register(&vfb_driver);
 
         if (!ret) {
                 ret = platform_device_register(&vfb_device);
                 if (ret)
-                        driver_unregister(&vfb_driver);
+                        platform_driver_unregister(&vfb_driver);
         }
         return ret;
 }
@@ -520,7 +520,7 @@ module_init(vfb_init);
 static void __exit vfb_exit(void)
 {
         platform_device_unregister(&vfb_device);
-        driver_unregister(&vfb_driver);
+        platform_driver_unregister(&vfb_driver);
 }
 
 module_exit(vfb_exit);
diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c
index 48e70f153c4b..daa46051f55d 100644
--- a/drivers/video/w100fb.c
+++ b/drivers/video/w100fb.c
@@ -437,9 +437,9 @@ static void w100fb_restore_vidmem(struct w100fb_par *par)
         }
 }
 
-static int w100fb_suspend(struct device *dev, pm_message_t state)
+static int w100fb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
         struct w100fb_par *par=info->par;
         struct w100_tg_info *tg = par->mach->tg;
 
@@ -452,9 +452,9 @@ static int w100fb_suspend(struct device *dev, pm_message_t state)
         return 0;
 }
 
-static int w100fb_resume(struct device *dev)
+static int w100fb_resume(struct platform_device *dev)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(dev);
         struct w100fb_par *par=info->par;
         struct w100_tg_info *tg = par->mach->tg;
 
@@ -473,13 +473,12 @@ static int w100fb_resume(struct device *dev)
 #endif
 
 
-int __init w100fb_probe(struct device *dev)
+int __init w100fb_probe(struct platform_device *pdev)
 {
         int err = -EIO;
         struct w100fb_mach_info *inf;
         struct fb_info *info = NULL;
         struct w100fb_par *par;
-        struct platform_device *pdev = to_platform_device(dev);
         struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         unsigned int chip_id;
 
@@ -522,9 +521,9 @@ int __init w100fb_probe(struct device *dev)
         }
 
         par = info->par;
-        dev_set_drvdata(dev, info);
+        platform_set_drvdata(pdev, info);
 
-        inf = dev->platform_data;
+        inf = pdev->dev.platform_data;
         par->chip_id = chip_id;
         par->mach = inf;
         par->fastpll_mode = 0;
@@ -600,10 +599,10 @@ int __init w100fb_probe(struct device *dev)
                 goto out;
         }
 
-        device_create_file(dev, &dev_attr_fastpllclk);
-        device_create_file(dev, &dev_attr_reg_read);
-        device_create_file(dev, &dev_attr_reg_write);
-        device_create_file(dev, &dev_attr_flip);
+        device_create_file(&pdev->dev, &dev_attr_fastpllclk);
+        device_create_file(&pdev->dev, &dev_attr_reg_read);
+        device_create_file(&pdev->dev, &dev_attr_reg_write);
+        device_create_file(&pdev->dev, &dev_attr_flip);
 
         printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
         return 0;
@@ -622,15 +621,15 @@ out:
 }
 
 
-static int w100fb_remove(struct device *dev)
+static int w100fb_remove(struct platform_device *pdev)
 {
-        struct fb_info *info = dev_get_drvdata(dev);
+        struct fb_info *info = platform_get_drvdata(pdev);
         struct w100fb_par *par=info->par;
 
-        device_remove_file(dev, &dev_attr_fastpllclk);
-        device_remove_file(dev, &dev_attr_reg_read);
-        device_remove_file(dev, &dev_attr_reg_write);
-        device_remove_file(dev, &dev_attr_flip);
+        device_remove_file(&pdev->dev, &dev_attr_fastpllclk);
+        device_remove_file(&pdev->dev, &dev_attr_reg_read);
+        device_remove_file(&pdev->dev, &dev_attr_reg_write);
+        device_remove_file(&pdev->dev, &dev_attr_flip);
 
         unregister_framebuffer(info);
 
@@ -1448,23 +1447,24 @@ static void w100_vsync(void)
         writel(0x00000002, remapped_regs + mmGEN_INT_STATUS);
 }
 
-static struct device_driver w100fb_driver = {
-        .name           = "w100fb",
-        .bus            = &platform_bus_type,
+static struct platform_driver w100fb_driver = {
         .probe          = w100fb_probe,
         .remove         = w100fb_remove,
         .suspend        = w100fb_suspend,
         .resume         = w100fb_resume,
+        .driver         = {
+                .name   = "w100fb",
+        },
 };
 
 int __devinit w100fb_init(void)
 {
-        return driver_register(&w100fb_driver);
+        return platform_driver_register(&w100fb_driver);
 }
 
 void __exit w100fb_cleanup(void)
 {
-        driver_unregister(&w100fb_driver);
+        platform_driver_unregister(&w100fb_driver);
 }
 
 module_init(w100fb_init);