* triggers a section mismatch warning.
  */
 static struct platform_driver amifb_driver __refdata = {
-       .remove_new = __exit_p(amifb_remove),
-       .driver   = {
+       .remove = __exit_p(amifb_remove),
+       .driver = {
                .name   = "amiga-video",
        },
 };
 
 
 static struct platform_driver arcfb_driver = {
        .probe  = arcfb_probe,
-       .remove_new = arcfb_remove,
+       .remove = arcfb_remove,
        .driver = {
                .name   = "arcfb",
        },
 
 
 static struct platform_driver atmel_lcdfb_driver = {
        .probe          = atmel_lcdfb_probe,
-       .remove_new     = atmel_lcdfb_remove,
+       .remove         = atmel_lcdfb_remove,
        .suspend        = atmel_lcdfb_suspend,
        .resume         = atmel_lcdfb_resume,
        .driver         = {
 
                .name           = "au1100-lcd",
        },
        .probe          = au1100fb_drv_probe,
-       .remove_new     = au1100fb_drv_remove,
+       .remove         = au1100fb_drv_remove,
        .suspend        = au1100fb_drv_suspend,
        .resume         = au1100fb_drv_resume,
 };
 
                .pm     = AU1200FB_PMOPS,
        },
        .probe          = au1200fb_drv_probe,
-       .remove_new     = au1200fb_drv_remove,
+       .remove         = au1200fb_drv_remove,
 };
 module_platform_driver(au1200fb_driver);
 
 
 
 static struct platform_driver broadsheetfb_driver = {
        .probe  = broadsheetfb_probe,
-       .remove_new = broadsheetfb_remove,
+       .remove = broadsheetfb_remove,
        .driver = {
                .name   = "broadsheetfb",
        },
 
                .of_match_table = bw2_match,
        },
        .probe          = bw2_probe,
-       .remove_new     = bw2_remove,
+       .remove         = bw2_remove,
 };
 
 static int __init bw2_init(void)
 
                .of_match_table = cg14_match,
        },
        .probe          = cg14_probe,
-       .remove_new     = cg14_remove,
+       .remove         = cg14_remove,
 };
 
 static int __init cg14_init(void)
 
                .of_match_table = cg3_match,
        },
        .probe          = cg3_probe,
-       .remove_new     = cg3_remove,
+       .remove         = cg3_remove,
 };
 
 static int __init cg3_init(void)
 
                .of_match_table = cg6_match,
        },
        .probe          = cg6_probe,
-       .remove_new     = cg6_remove,
+       .remove         = cg6_remove,
 };
 
 static int __init cg6_init(void)
 
                .of_match_table = clps711x_fb_dt_ids,
        },
        .probe  = clps711x_fb_probe,
-       .remove_new = clps711x_fb_remove,
+       .remove = clps711x_fb_remove,
 };
 module_platform_driver(clps711x_fb_driver);
 
 
 
 static struct platform_driver cobalt_lcdfb_driver = {
        .probe  = cobalt_lcdfb_probe,
-       .remove_new = cobalt_lcdfb_remove,
+       .remove = cobalt_lcdfb_remove,
        .driver = {
                .name   = "cobalt-lcd",
        },
 
 
 static struct platform_driver da8xx_fb_driver = {
        .probe = fb_probe,
-       .remove_new = fb_remove,
+       .remove = fb_remove,
        .driver = {
                   .name = DRIVER_NAME,
                   .pm  = &fb_pm_ops,
 
 
 static struct platform_driver ep93xxfb_driver = {
        .probe          = ep93xxfb_probe,
-       .remove_new     = ep93xxfb_remove,
+       .remove         = ep93xxfb_remove,
        .driver = {
                .name   = "ep93xx-fb",
        },
 
                .of_match_table = ffb_match,
        },
        .probe          = ffb_probe,
-       .remove_new     = ffb_remove,
+       .remove         = ffb_remove,
 };
 
 static int __init ffb_init(void)
 
 MODULE_DEVICE_TABLE(of, fsl_diu_match);
 
 static struct platform_driver fsl_diu_driver = {
-       .driver = {
+       .driver         = {
                .name = "fsl-diu-fb",
                .of_match_table = fsl_diu_match,
        },
-       .probe          = fsl_diu_probe,
-       .remove_new     = fsl_diu_remove,
+       .probe          = fsl_diu_probe,
+       .remove         = fsl_diu_remove,
        .suspend        = fsl_diu_suspend,
        .resume         = fsl_diu_resume,
 };
 
 
 static struct platform_driver gbefb_driver = {
        .probe = gbefb_probe,
-       .remove_new = gbefb_remove,
-       .driver = {
+       .remove = gbefb_remove,
+       .driver = {
                .name = "gbefb",
-               .dev_groups     = gbefb_groups,
+               .dev_groups = gbefb_groups,
        },
 };
 
 
 
 static struct platform_driver goldfish_fb_driver = {
        .probe          = goldfish_fb_probe,
-       .remove_new     = goldfish_fb_remove,
+       .remove         = goldfish_fb_remove,
        .driver = {
                .name = "goldfish_fb",
                .of_match_table = goldfish_fb_of_match,
 
                .of_match_table = svgactrl_of_match,
        },
        .probe          = grvga_probe,
-       .remove_new     = grvga_remove,
+       .remove         = grvga_remove,
 };
 
 module_platform_driver(grvga_driver);
 
 
 static struct platform_driver hecubafb_driver = {
        .probe  = hecubafb_probe,
-       .remove_new = hecubafb_remove,
+       .remove = hecubafb_remove,
        .driver = {
                .name   = "hecubafb",
        },
 
 
 static struct platform_driver hgafb_driver = {
        .probe = hgafb_probe,
-       .remove_new = hgafb_remove,
+       .remove = hgafb_remove,
        .driver = {
                .name = "hgafb",
        },
 
 
 static struct platform_driver hitfb_driver = {
        .probe          = hitfb_probe,
-       .remove_new     = hitfb_remove,
+       .remove         = hitfb_remove,
        .driver         = {
                .name   = "hitfb",
                .pm     = &hitfb_dev_pm_ops,
 
                .pm     = pm_sleep_ptr(&imxfb_pm_ops),
        },
        .probe          = imxfb_probe,
-       .remove_new     = imxfb_remove,
+       .remove         = imxfb_remove,
        .id_table       = imxfb_devtype,
 };
 module_platform_driver(imxfb_driver);
 
                .of_match_table = leo_match,
        },
        .probe          = leo_probe,
-       .remove_new     = leo_remove,
+       .remove         = leo_remove,
 };
 
 static int __init leo_init(void)
 
                .of_match_table = of_platform_mb862xx_tbl,
        },
        .probe          = of_platform_mb862xx_probe,
-       .remove_new     = of_platform_mb862xx_remove,
+       .remove         = of_platform_mb862xx_remove,
 };
 #endif
 
 
 
 static struct platform_driver metronomefb_driver = {
        .probe  = metronomefb_probe,
-       .remove_new = metronomefb_remove,
+       .remove = metronomefb_remove,
        .driver = {
                .name   = "metronomefb",
        },
 
 
 static struct platform_driver ocfb_driver = {
        .probe  = ocfb_probe,
-       .remove_new = ocfb_remove,
+       .remove = ocfb_remove,
        .driver = {
                .name = "ocfb_fb",
                .of_match_table = ocfb_match,
 
                .name = "bootx-noscreen",
        },
        .probe = offb_probe_bootx_noscreen,
-       .remove_new = offb_remove,
+       .remove = offb_remove,
 };
 
 static int offb_probe_display(struct platform_device *pdev)
                .of_match_table = offb_of_match_display,
        },
        .probe = offb_probe_display,
-       .remove_new = offb_remove,
+       .remove = offb_remove,
 };
 
 static int __init offb_init(void)
 
 
 static struct platform_driver omapfb_driver = {
        .probe          = omapfb_probe,
-       .remove_new     = omapfb_remove,
+       .remove         = omapfb_remove,
        .suspend        = omapfb_suspend,
        .resume         = omapfb_resume,
        .driver         = {
 
 
 static struct platform_driver tvc_connector_driver = {
        .probe  = tvc_probe,
-       .remove_new = tvc_remove,
+       .remove = tvc_remove,
        .driver = {
                .name   = "connector-analog-tv",
                .of_match_table = tvc_of_match,
 
 
 static struct platform_driver dvi_connector_driver = {
        .probe  = dvic_probe,
-       .remove_new = dvic_remove,
+       .remove = dvic_remove,
        .driver = {
                .name   = "connector-dvi",
                .of_match_table = dvic_of_match,
 
 
 static struct platform_driver hdmi_connector_driver = {
        .probe  = hdmic_probe,
-       .remove_new = hdmic_remove,
+       .remove = hdmic_remove,
        .driver = {
                .name   = "connector-hdmi",
                .of_match_table = hdmic_of_match,
 
 
 static struct platform_driver opa362_driver = {
        .probe  = opa362_probe,
-       .remove_new = opa362_remove,
+       .remove = opa362_remove,
        .driver = {
                .name   = "amplifier-opa362",
                .of_match_table = opa362_of_match,
 
 
 static struct platform_driver tfp410_driver = {
        .probe  = tfp410_probe,
-       .remove_new = tfp410_remove,
+       .remove = tfp410_remove,
        .driver = {
                .name   = "tfp410",
                .of_match_table = tfp410_of_match,
 
 
 static struct platform_driver tpd_driver = {
        .probe  = tpd_probe,
-       .remove_new = tpd_remove,
+       .remove = tpd_remove,
        .driver = {
                .name   = "tpd12s015",
                .of_match_table = tpd_of_match,
 
 
 static struct platform_driver panel_dpi_driver = {
        .probe = panel_dpi_probe,
-       .remove_new = panel_dpi_remove,
+       .remove = panel_dpi_remove,
        .driver = {
                .name = "panel-dpi",
                .of_match_table = panel_dpi_of_match,
 
 
 static struct platform_driver dsicm_driver = {
        .probe = dsicm_probe,
-       .remove_new = dsicm_remove,
+       .remove = dsicm_remove,
        .driver = {
                .name = "panel-dsi-cm",
                .of_match_table = dsicm_of_match,
 
 
 static struct platform_driver sharp_ls_driver = {
        .probe = sharp_ls_probe,
-       .remove_new = sharp_ls_remove,
+       .remove = sharp_ls_remove,
        .driver = {
                .name = "panel-sharp-ls037v7dw01",
                .of_match_table = sharp_ls_of_match,
 
 }
 
 static struct platform_driver omap_dss_driver = {
-       .remove_new     = omap_dss_remove,
+       .remove         = omap_dss_remove,
        .shutdown       = omap_dss_shutdown,
-       .driver         = {
-               .name   = "omapdss",
+       .driver         = {
+               .name   = "omapdss",
        },
 };
 
 
 
 static struct platform_driver omap_dispchw_driver = {
        .probe          = dispc_probe,
-       .remove_new     = dispc_remove,
+       .remove         = dispc_remove,
        .driver         = {
                .name   = "omapdss_dispc",
                .pm     = &dispc_pm_ops,
 
 
 static struct platform_driver omap_dpi_driver = {
        .probe          = dpi_probe,
-       .remove_new     = dpi_remove,
-       .driver         = {
+       .remove         = dpi_remove,
+       .driver         = {
                .name   = "omapdss_dpi",
                .suppress_bind_attrs = true,
        },
 
 
 static struct platform_driver omap_dsihw_driver = {
        .probe          = dsi_probe,
-       .remove_new     = dsi_remove,
+       .remove         = dsi_remove,
        .driver         = {
                .name   = "omapdss_dsi",
                .pm     = &dsi_pm_ops,
 
 
 static struct platform_driver omap_dsshw_driver = {
        .probe          = dss_probe,
-       .remove_new     = dss_remove,
+       .remove         = dss_remove,
        .driver         = {
                .name   = "omapdss_dss",
                .pm     = &dss_pm_ops,
 
 
 static struct platform_driver omapdss_hdmihw_driver = {
        .probe          = hdmi4_probe,
-       .remove_new     = hdmi4_remove,
-       .driver         = {
-               .name   = "omapdss_hdmi",
+       .remove         = hdmi4_remove,
+       .driver         = {
+               .name   = "omapdss_hdmi",
                .pm     = &hdmi_pm_ops,
                .of_match_table = hdmi_of_match,
                .suppress_bind_attrs = true,
 
 
 static struct platform_driver omapdss_hdmihw_driver = {
        .probe          = hdmi5_probe,
-       .remove_new     = hdmi5_remove,
+       .remove         = hdmi5_remove,
        .driver         = {
                .name   = "omapdss_hdmi5",
                .pm     = &hdmi_pm_ops,
 
 
 static struct platform_driver omap_sdi_driver = {
        .probe          = sdi_probe,
-       .remove_new     = sdi_remove,
-       .driver         = {
-               .name   = "omapdss_sdi",
+       .remove         = sdi_remove,
+       .driver         = {
+               .name   = "omapdss_sdi",
                .suppress_bind_attrs = true,
        },
 };
 
 
 static struct platform_driver omap_venchw_driver = {
        .probe          = venc_probe,
-       .remove_new     = venc_remove,
-       .driver         = {
-               .name   = "omapdss_venc",
+       .remove         = venc_remove,
+       .driver         = {
+               .name   = "omapdss_venc",
                .pm     = &venc_pm_ops,
                .of_match_table = venc_of_match,
                .suppress_bind_attrs = true,
 
 
 static struct platform_driver omapfb_driver = {
        .probe          = omapfb_probe,
-       .remove_new     = omapfb_remove,
+       .remove         = omapfb_remove,
        .driver         = {
                .name   = "omapfb",
        },
 
                .of_match_table = p9100_match,
        },
        .probe          = p9100_probe,
-       .remove_new     = p9100_remove,
+       .remove         = p9100_remove,
 };
 
 static int __init p9100_init(void)
 
                .of_match_table = platinumfb_match,
        },
        .probe          = platinumfb_probe,
-       .remove_new     = platinumfb_remove,
+       .remove         = platinumfb_remove,
 };
 
 static int __init platinumfb_init(void)
 
                .name   = "pxa168-fb",
        },
        .probe          = pxa168fb_probe,
-       .remove_new     = pxa168fb_remove,
+       .remove         = pxa168fb_remove,
 };
 
 module_platform_driver(pxa168fb_driver);
 
 #endif
 
 static struct platform_driver pxa3xx_gcu_driver = {
-       .probe    = pxa3xx_gcu_probe,
-       .remove_new      = pxa3xx_gcu_remove,
-       .driver  = {
-               .name   = DRV_NAME,
+       .probe = pxa3xx_gcu_probe,
+       .remove = pxa3xx_gcu_remove,
+       .driver = {
+               .name = DRV_NAME,
                .of_match_table = of_match_ptr(pxa3xx_gcu_of_match),
        },
 };
 
 
 static struct platform_driver pxafb_driver = {
        .probe          = pxafb_probe,
-       .remove_new     = pxafb_remove,
+       .remove         = pxafb_remove,
        .driver         = {
                .name   = "pxa2xx-fb",
                .of_match_table = pxafb_of_dev_id,
 
 
 static struct platform_driver s1d13xxxfb_driver = {
        .probe          = s1d13xxxfb_probe,
-       .remove_new     = s1d13xxxfb_remove,
+       .remove         = s1d13xxxfb_remove,
 #ifdef CONFIG_PM
        .suspend        = s1d13xxxfb_suspend,
        .resume         = s1d13xxxfb_resume,
 
 
 static struct platform_driver s3c_fb_driver = {
        .probe          = s3c_fb_probe,
-       .remove_new     = s3c_fb_remove,
+       .remove         = s3c_fb_remove,
        .id_table       = s3c_fb_driver_ids,
        .driver         = {
                .name   = "s3c-fb",
 
                   .name = "sh7760-lcdc",
                   },
        .probe = sh7760fb_probe,
-       .remove_new = sh7760fb_remove,
+       .remove = sh7760fb_remove,
 };
 
 module_platform_driver(sh7760_lcdc_driver);
 
                .pm             = &sh_mobile_lcdc_dev_pm_ops,
        },
        .probe          = sh_mobile_lcdc_probe,
-       .remove_new     = sh_mobile_lcdc_remove,
+       .remove         = sh_mobile_lcdc_remove,
 };
 
 module_platform_driver(sh_mobile_lcdc_driver);
 
                .of_match_table = simplefb_of_match,
        },
        .probe = simplefb_probe,
-       .remove_new = simplefb_remove,
+       .remove = simplefb_remove,
 };
 
 module_platform_driver(simplefb_driver);
 
 
 static struct platform_driver sm501fb_driver = {
        .probe          = sm501fb_probe,
-       .remove_new     = sm501fb_remove,
+       .remove         = sm501fb_remove,
        .suspend        = sm501fb_suspend,
        .resume         = sm501fb_resume,
        .driver         = {
 
                .of_match_table = tcx_match,
        },
        .probe          = tcx_probe,
-       .remove_new     = tcx_remove,
+       .remove         = tcx_remove,
 };
 
 static int __init tcx_init(void)
 
 
 static struct platform_driver uvesafb_driver = {
        .probe  = uvesafb_probe,
-       .remove_new = uvesafb_remove,
+       .remove = uvesafb_remove,
        .driver = {
                .name = "uvesafb",
        },
 
                .name = "vesa-framebuffer",
        },
        .probe = vesafb_probe,
-       .remove_new = vesafb_remove,
+       .remove = vesafb_remove,
 };
 
 module_platform_driver(vesafb_driver);
 
 
 static struct platform_driver vfb_driver = {
        .probe  = vfb_probe,
-       .remove_new = vfb_remove,
+       .remove = vfb_remove,
        .driver = {
                .name   = "vfb",
        },
 
 
 static struct platform_driver vga16fb_driver = {
        .probe = vga16fb_probe,
-       .remove_new = vga16fb_remove,
+       .remove = vga16fb_remove,
        .driver = {
                .name = "vga16fb",
        },
 
                .name = "viafb-gpio",
        },
        .probe = viafb_gpio_probe,
-       .remove_new = viafb_gpio_remove,
+       .remove = viafb_gpio_remove,
 };
 
 int viafb_gpio_init(void)
 
                .name = "viafb-i2c",
        },
        .probe = viafb_i2c_probe,
-       .remove_new = viafb_i2c_remove,
+       .remove = viafb_i2c_remove,
 };
 
 int viafb_i2c_init(void)
 
 
 static struct platform_driver vt8500lcd_driver = {
        .probe          = vt8500lcd_probe,
-       .remove_new     = vt8500lcd_remove,
+       .remove         = vt8500lcd_remove,
        .driver         = {
                .name   = "vt8500-lcd",
                .of_match_table = of_match_ptr(via_dt_ids),
 
 
 static struct platform_driver wm8505fb_driver = {
        .probe          = wm8505fb_probe,
-       .remove_new     = wm8505fb_remove,
+       .remove         = wm8505fb_remove,
        .driver         = {
                .name   = DRIVER_NAME,
                .of_match_table = wmt_dt_ids,
 
 
 static struct platform_driver wmt_ge_rops_driver = {
        .probe          = wmt_ge_rops_probe,
-       .remove_new     = wmt_ge_rops_remove,
+       .remove         = wmt_ge_rops_remove,
        .driver         = {
                .name   = "wmt_ge_rops",
                .of_match_table = wmt_dt_ids,
 
 
 static struct platform_driver xilinxfb_of_driver = {
        .probe = xilinxfb_of_probe,
-       .remove_new = xilinxfb_of_remove,
+       .remove = xilinxfb_of_remove,
        .driver = {
                .name = DRIVER_NAME,
                .of_match_table = xilinxfb_of_match,