static int wled_remove(struct platform_device *pdev)
 {
-       struct wled *wled = dev_get_drvdata(&pdev->dev);
+       struct wled *wled = platform_get_drvdata(pdev);
 
        mutex_destroy(&wled->lock);
        cancel_delayed_work_sync(&wled->ovp_work);
 
        if (err)
                goto free_irq;
 
-       dev_set_drvdata(&pdev->dev, info);
+       platform_set_drvdata(pdev, info);
 
        err = register_framebuffer(info);
        if (err)
 
 static int __exit amifb_remove(struct platform_device *pdev)
 {
-       struct fb_info *info = dev_get_drvdata(&pdev->dev);
+       struct fb_info *info = platform_get_drvdata(pdev);
 
        unregister_framebuffer(info);
        fb_dealloc_cmap(&info->cmap);
 
 
 static int fb_remove(struct platform_device *dev)
 {
-       struct fb_info *info = dev_get_drvdata(&dev->dev);
+       struct fb_info *info = platform_get_drvdata(dev);
        struct da8xx_fb_par *par = info->par;
        int ret;
 
        da8xx_fb_var.activate = FB_ACTIVATE_FORCE;
        fb_set_var(da8xx_fb_info, &da8xx_fb_var);
 
-       dev_set_drvdata(&device->dev, da8xx_fb_info);
+       platform_set_drvdata(device, da8xx_fb_info);
 
        /* initialize the vsync wait queue */
        init_waitqueue_head(&par->vsync_wait);
 
 static int imxfb_init_fbinfo(struct platform_device *pdev)
 {
        struct imx_fb_platform_data *pdata = dev_get_platdata(&pdev->dev);
-       struct fb_info *info = dev_get_drvdata(&pdev->dev);
+       struct fb_info *info = platform_get_drvdata(pdev);
        struct imxfb_info *fbi = info->par;
        struct device_node *np;
 
 
 static int lb035q02_probe_of(struct spi_device *spi)
 {
        struct device_node *node = spi->dev.of_node;
-       struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
+       struct panel_drv_data *ddata = spi_get_drvdata(spi);
        struct omap_dss_device *in;
        struct gpio_desc *gpio;
 
        if (ddata == NULL)
                return -ENOMEM;
 
-       dev_set_drvdata(&spi->dev, ddata);
+       spi_set_drvdata(spi, ddata);
 
        ddata->spi = spi;
 
 
 static int lb035q02_panel_spi_remove(struct spi_device *spi)
 {
-       struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
+       struct panel_drv_data *ddata = spi_get_drvdata(spi);
        struct omap_dss_device *dssdev = &ddata->dssdev;
        struct omap_dss_device *in = ddata->in;
 
 
 /* only used in non-DT mode */
 static struct dpi_data *dpi_get_data_from_pdev(struct platform_device *pdev)
 {
-       return dev_get_drvdata(&pdev->dev);
+       return platform_get_drvdata(pdev);
 }
 
 static struct dss_pll *dpi_get_pll(enum omap_channel channel)
 
        dpi->pdev = pdev;
 
-       dev_set_drvdata(&pdev->dev, dpi);
+       platform_set_drvdata(pdev, dpi);
 
        mutex_init(&dpi->lock);
 
 
 
 static inline struct dsi_data *dsi_get_dsidrv_data(struct platform_device *dsidev)
 {
-       return dev_get_drvdata(&dsidev->dev);
+       return platform_get_drvdata(dsidev);
 }
 
 static inline struct platform_device *dsi_get_dsidev_from_dssdev(struct omap_dss_device *dssdev)
                return -ENOMEM;
 
        dsi->pdev = dsidev;
-       dev_set_drvdata(&dsidev->dev, dsi);
+       platform_set_drvdata(dsidev, dsi);
 
        spin_lock_init(&dsi->irq_lock);
        spin_lock_init(&dsi->errors_lock);
 
        int irq;
 
        hdmi.pdev = pdev;
-       dev_set_drvdata(&pdev->dev, &hdmi);
+       platform_set_drvdata(pdev, &hdmi);
 
        mutex_init(&hdmi.lock);
        spin_lock_init(&hdmi.audio_playing_lock);
 
        int irq;
 
        hdmi.pdev = pdev;
-       dev_set_drvdata(&pdev->dev, &hdmi);
+       platform_set_drvdata(pdev, &hdmi);
 
        mutex_init(&hdmi.lock);
        spin_lock_init(&hdmi.audio_playing_lock);
 
        if (of_find_property(pdev->dev.of_node, "rotate-display", NULL))
                pdata.rotate_screen = 1;
 
-       dev_set_drvdata(&pdev->dev, drvdata);
+       platform_set_drvdata(pdev, drvdata);
        return xilinxfb_assign(pdev, drvdata, &pdata);
 }