dispc_init_mflag();
 }
 
-static const struct dispc_features omap24xx_dispc_feats __initconst = {
+static const struct dispc_features omap24xx_dispc_feats = {
        .sw_start               =       5,
        .fp_start               =       15,
        .bp_start               =       27,
        .set_max_preload        =       false,
 };
 
-static const struct dispc_features omap34xx_rev1_0_dispc_feats __initconst = {
+static const struct dispc_features omap34xx_rev1_0_dispc_feats = {
        .sw_start               =       5,
        .fp_start               =       15,
        .bp_start               =       27,
        .set_max_preload        =       false,
 };
 
-static const struct dispc_features omap34xx_rev3_0_dispc_feats __initconst = {
+static const struct dispc_features omap34xx_rev3_0_dispc_feats = {
        .sw_start               =       7,
        .fp_start               =       19,
        .bp_start               =       31,
        .set_max_preload        =       false,
 };
 
-static const struct dispc_features omap44xx_dispc_feats __initconst = {
+static const struct dispc_features omap44xx_dispc_feats = {
        .sw_start               =       7,
        .fp_start               =       19,
        .bp_start               =       31,
        .set_max_preload        =       true,
 };
 
-static const struct dispc_features omap54xx_dispc_feats __initconst = {
+static const struct dispc_features omap54xx_dispc_feats = {
        .sw_start               =       7,
        .fp_start               =       19,
        .bp_start               =       31,
        .set_max_preload        =       true,
 };
 
-static int __init dispc_init_features(struct platform_device *pdev)
+static int dispc_init_features(struct platform_device *pdev)
 {
        const struct dispc_features *src;
        struct dispc_features *dst;
 EXPORT_SYMBOL(dispc_free_irq);
 
 /* DISPC HW IP initialisation */
-static int __init omap_dispchw_probe(struct platform_device *pdev)
+static int omap_dispchw_probe(struct platform_device *pdev)
 {
        u32 rev;
        int r = 0;
        return r;
 }
 
-static int __exit omap_dispchw_remove(struct platform_device *pdev)
+static int omap_dispchw_remove(struct platform_device *pdev)
 {
        pm_runtime_disable(&pdev->dev);
 
 };
 
 static struct platform_driver omap_dispchw_driver = {
-       .remove         = __exit_p(omap_dispchw_remove),
+       .remove         = omap_dispchw_remove,
        .driver         = {
                .name   = "omapdss_dispc",
                .pm     = &dispc_pm_ops,
        return platform_driver_probe(&omap_dispchw_driver, omap_dispchw_probe);
 }
 
-void __exit dispc_uninit_platform_driver(void)
+void dispc_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omap_dispchw_driver);
 }
 
        omapdss_register_output(out);
 }
 
-static void __exit dpi_uninit_output(struct platform_device *pdev)
+static void dpi_uninit_output(struct platform_device *pdev)
 {
        struct dpi_data *dpi = dpi_get_data_from_pdev(pdev);
        struct omap_dss_device *out = &dpi->output;
        omapdss_register_output(out);
 }
 
-static void __exit dpi_uninit_output_port(struct device_node *port)
+static void dpi_uninit_output_port(struct device_node *port)
 {
        struct dpi_data *dpi = port->data;
        struct omap_dss_device *out = &dpi->output;
        return 0;
 }
 
-static int __exit omap_dpi_remove(struct platform_device *pdev)
+static int omap_dpi_remove(struct platform_device *pdev)
 {
        dpi_uninit_output(pdev);
 
 
 static struct platform_driver omap_dpi_driver = {
        .probe          = omap_dpi_probe,
-       .remove         = __exit_p(omap_dpi_remove),
+       .remove         = omap_dpi_remove,
        .driver         = {
                .name   = "omapdss_dpi",
                .suppress_bind_attrs = true,
        return platform_driver_register(&omap_dpi_driver);
 }
 
-void __exit dpi_uninit_platform_driver(void)
+void dpi_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omap_dpi_driver);
 }
 
-int __init dpi_init_port(struct platform_device *pdev, struct device_node *port)
+int dpi_init_port(struct platform_device *pdev, struct device_node *port)
 {
        struct dpi_data *dpi;
        struct device_node *ep;
        return r;
 }
 
-void __exit dpi_uninit_port(struct device_node *port)
+void dpi_uninit_port(struct device_node *port)
 {
        struct dpi_data *dpi = port->data;
 
 
        return r;
 }
 
-static int __exit omap_dsihw_remove(struct platform_device *dsidev)
+static int omap_dsihw_remove(struct platform_device *dsidev)
 {
        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
 
 static struct platform_driver omap_dsihw_driver = {
        .probe          = omap_dsihw_probe,
-       .remove         = __exit_p(omap_dsihw_remove),
+       .remove         = omap_dsihw_remove,
        .driver         = {
                .name   = "omapdss_dsi",
                .pm     = &dsi_pm_ops,
        return platform_driver_register(&omap_dsihw_driver);
 }
 
-void __exit dsi_uninit_platform_driver(void)
+void dsi_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omap_dsihw_driver);
 }
 
        OMAP_DISPLAY_TYPE_DPI,
 };
 
-static const struct dss_features omap24xx_dss_feats __initconst = {
+static const struct dss_features omap24xx_dss_feats = {
        /*
         * fck div max is really 16, but the divider range has gaps. The range
         * from 1 to 6 has no gaps, so let's use that as a max.
        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
-static const struct dss_features omap34xx_dss_feats __initconst = {
+static const struct dss_features omap34xx_dss_feats = {
        .fck_div_max            =       16,
        .dss_fck_multiplier     =       2,
        .parent_clk_name        =       "dpll4_ck",
        .num_ports              =       ARRAY_SIZE(omap34xx_ports),
 };
 
-static const struct dss_features omap3630_dss_feats __initconst = {
+static const struct dss_features omap3630_dss_feats = {
        .fck_div_max            =       32,
        .dss_fck_multiplier     =       1,
        .parent_clk_name        =       "dpll4_ck",
        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
-static const struct dss_features omap44xx_dss_feats __initconst = {
+static const struct dss_features omap44xx_dss_feats = {
        .fck_div_max            =       32,
        .dss_fck_multiplier     =       1,
        .parent_clk_name        =       "dpll_per_x2_ck",
        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
-static const struct dss_features omap54xx_dss_feats __initconst = {
+static const struct dss_features omap54xx_dss_feats = {
        .fck_div_max            =       64,
        .dss_fck_multiplier     =       1,
        .parent_clk_name        =       "dpll_per_x2_ck",
        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
-static const struct dss_features am43xx_dss_feats __initconst = {
+static const struct dss_features am43xx_dss_feats = {
        .fck_div_max            =       0,
        .dss_fck_multiplier     =       0,
        .parent_clk_name        =       NULL,
        .num_ports              =       ARRAY_SIZE(omap2plus_ports),
 };
 
-static const struct dss_features dra7xx_dss_feats __initconst = {
+static const struct dss_features dra7xx_dss_feats = {
        .fck_div_max            =       64,
        .dss_fck_multiplier     =       1,
        .parent_clk_name        =       "dpll_per_x2_ck",
        .num_ports              =       ARRAY_SIZE(dra7xx_ports),
 };
 
-static int __init dss_init_features(struct platform_device *pdev)
+static int dss_init_features(struct platform_device *pdev)
 {
        const struct dss_features *src;
        struct dss_features *dst;
        return 0;
 }
 
-static int __init dss_init_ports(struct platform_device *pdev)
+static int dss_init_ports(struct platform_device *pdev)
 {
        struct device_node *parent = pdev->dev.of_node;
        struct device_node *port;
        return 0;
 }
 
-static void __exit dss_uninit_ports(struct platform_device *pdev)
+static void dss_uninit_ports(struct platform_device *pdev)
 {
        struct device_node *parent = pdev->dev.of_node;
        struct device_node *port;
 }
 
 /* DSS HW IP initialisation */
-static int __init omap_dsshw_probe(struct platform_device *pdev)
+static int omap_dsshw_probe(struct platform_device *pdev)
 {
        struct resource *dss_mem;
        u32 rev;
        return r;
 }
 
-static int __exit omap_dsshw_remove(struct platform_device *pdev)
+static int omap_dsshw_remove(struct platform_device *pdev)
 {
        dss_initialized = false;
 
 MODULE_DEVICE_TABLE(of, dss_of_match);
 
 static struct platform_driver omap_dsshw_driver = {
-       .remove         = __exit_p(omap_dsshw_remove),
+       .remove         = omap_dsshw_remove,
        .driver         = {
                .name   = "omapdss_dss",
                .pm     = &dss_pm_ops,
 
 
 /* SDI */
 int sdi_init_platform_driver(void) __init;
-void sdi_uninit_platform_driver(void) __exit;
+void sdi_uninit_platform_driver(void);
 
 #ifdef CONFIG_OMAP2_DSS_SDI
-int sdi_init_port(struct platform_device *pdev, struct device_node *port) __init;
-void sdi_uninit_port(struct device_node *port) __exit;
+int sdi_init_port(struct platform_device *pdev, struct device_node *port);
+void sdi_uninit_port(struct device_node *port);
 #else
-static inline int __init sdi_init_port(struct platform_device *pdev,
+static inline int sdi_init_port(struct platform_device *pdev,
                struct device_node *port)
 {
        return 0;
 }
-static inline void __exit sdi_uninit_port(struct device_node *port)
+static inline void sdi_uninit_port(struct device_node *port)
 {
 }
 #endif
 struct file_operations;
 
 int dsi_init_platform_driver(void) __init;
-void dsi_uninit_platform_driver(void) __exit;
+void dsi_uninit_platform_driver(void);
 
 void dsi_dump_clocks(struct seq_file *s);
 
 
 /* DPI */
 int dpi_init_platform_driver(void) __init;
-void dpi_uninit_platform_driver(void) __exit;
+void dpi_uninit_platform_driver(void);
 
 #ifdef CONFIG_OMAP2_DSS_DPI
-int dpi_init_port(struct platform_device *pdev, struct device_node *port) __init;
-void dpi_uninit_port(struct device_node *port) __exit;
+int dpi_init_port(struct platform_device *pdev, struct device_node *port);
+void dpi_uninit_port(struct device_node *port);
 #else
-static inline int __init dpi_init_port(struct platform_device *pdev,
+static inline int dpi_init_port(struct platform_device *pdev,
                struct device_node *port)
 {
        return 0;
 }
-static inline void __exit dpi_uninit_port(struct device_node *port)
+static inline void dpi_uninit_port(struct device_node *port)
 {
 }
 #endif
 
 /* DISPC */
 int dispc_init_platform_driver(void) __init;
-void dispc_uninit_platform_driver(void) __exit;
+void dispc_uninit_platform_driver(void);
 void dispc_dump_clocks(struct seq_file *s);
 
 void dispc_enable_sidle(void);
 
 /* VENC */
 int venc_init_platform_driver(void) __init;
-void venc_uninit_platform_driver(void) __exit;
+void venc_uninit_platform_driver(void);
 
 /* HDMI */
 int hdmi4_init_platform_driver(void) __init;
-void hdmi4_uninit_platform_driver(void) __exit;
+void hdmi4_uninit_platform_driver(void);
 
 int hdmi5_init_platform_driver(void) __init;
-void hdmi5_uninit_platform_driver(void) __exit;
+void hdmi5_uninit_platform_driver(void);
 
 /* RFBI */
 int rfbi_init_platform_driver(void) __init;
-void rfbi_uninit_platform_driver(void) __exit;
+void rfbi_uninit_platform_driver(void);
 
 
 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
 
        return r;
 }
 
-static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
+static int omapdss_hdmihw_remove(struct platform_device *pdev)
 {
        if (hdmi.audio_pdev)
                platform_device_unregister(hdmi.audio_pdev);
 
 static struct platform_driver omapdss_hdmihw_driver = {
        .probe          = omapdss_hdmihw_probe,
-       .remove         = __exit_p(omapdss_hdmihw_remove),
+       .remove         = omapdss_hdmihw_remove,
        .driver         = {
                .name   = "omapdss_hdmi",
                .pm     = &hdmi_pm_ops,
        return platform_driver_register(&omapdss_hdmihw_driver);
 }
 
-void __exit hdmi4_uninit_platform_driver(void)
+void hdmi4_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omapdss_hdmihw_driver);
 }
 
        return r;
 }
 
-static int __exit omapdss_hdmihw_remove(struct platform_device *pdev)
+static int omapdss_hdmihw_remove(struct platform_device *pdev)
 {
        if (hdmi.audio_pdev)
                platform_device_unregister(hdmi.audio_pdev);
 
 static struct platform_driver omapdss_hdmihw_driver = {
        .probe          = omapdss_hdmihw_probe,
-       .remove         = __exit_p(omapdss_hdmihw_remove),
+       .remove         = omapdss_hdmihw_remove,
        .driver         = {
                .name   = "omapdss_hdmi5",
                .pm     = &hdmi_pm_ops,
        return platform_driver_register(&omapdss_hdmihw_driver);
 }
 
-void __exit hdmi5_uninit_platform_driver(void)
+void hdmi5_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omapdss_hdmihw_driver);
 }
 
        omapdss_register_output(out);
 }
 
-static void __exit rfbi_uninit_output(struct platform_device *pdev)
+static void rfbi_uninit_output(struct platform_device *pdev)
 {
        struct omap_dss_device *out = &rfbi.output;
 
        return r;
 }
 
-static int __exit omap_rfbihw_remove(struct platform_device *pdev)
+static int omap_rfbihw_remove(struct platform_device *pdev)
 {
        rfbi_uninit_output(pdev);
 
 
 static struct platform_driver omap_rfbihw_driver = {
        .probe          = omap_rfbihw_probe,
-       .remove         = __exit_p(omap_rfbihw_remove),
+       .remove         = omap_rfbihw_remove,
        .driver         = {
                .name   = "omapdss_rfbi",
                .pm     = &rfbi_pm_ops,
        return platform_driver_register(&omap_rfbihw_driver);
 }
 
-void __exit rfbi_uninit_platform_driver(void)
+void rfbi_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omap_rfbihw_driver);
 }
 
        omapdss_register_output(out);
 }
 
-static void __exit sdi_uninit_output(struct platform_device *pdev)
+static void sdi_uninit_output(struct platform_device *pdev)
 {
        struct omap_dss_device *out = &sdi.output;
 
        return 0;
 }
 
-static int __exit omap_sdi_remove(struct platform_device *pdev)
+static int omap_sdi_remove(struct platform_device *pdev)
 {
        sdi_uninit_output(pdev);
 
 
 static struct platform_driver omap_sdi_driver = {
        .probe          = omap_sdi_probe,
-       .remove         = __exit_p(omap_sdi_remove),
+       .remove         = omap_sdi_remove,
        .driver         = {
                .name   = "omapdss_sdi",
                .suppress_bind_attrs = true,
        return platform_driver_register(&omap_sdi_driver);
 }
 
-void __exit sdi_uninit_platform_driver(void)
+void sdi_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omap_sdi_driver);
 }
 
-int __init sdi_init_port(struct platform_device *pdev, struct device_node *port)
+int sdi_init_port(struct platform_device *pdev, struct device_node *port)
 {
        struct device_node *ep;
        u32 datapairs;
        return r;
 }
 
-void __exit sdi_uninit_port(struct device_node *port)
+void sdi_uninit_port(struct device_node *port)
 {
        if (!sdi.port_initialized)
                return;
 
        omapdss_register_output(out);
 }
 
-static void __exit venc_uninit_output(struct platform_device *pdev)
+static void venc_uninit_output(struct platform_device *pdev)
 {
        struct omap_dss_device *out = &venc.output;
 
        return r;
 }
 
-static int __exit omap_venchw_remove(struct platform_device *pdev)
+static int omap_venchw_remove(struct platform_device *pdev)
 {
        venc_uninit_output(pdev);
 
 
 static struct platform_driver omap_venchw_driver = {
        .probe          = omap_venchw_probe,
-       .remove         = __exit_p(omap_venchw_remove),
+       .remove         = omap_venchw_remove,
        .driver         = {
                .name   = "omapdss_venc",
                .pm     = &venc_pm_ops,
        return platform_driver_register(&omap_venchw_driver);
 }
 
-void __exit venc_uninit_platform_driver(void)
+void venc_uninit_platform_driver(void)
 {
        platform_driver_unregister(&omap_venchw_driver);
 }