static SIMPLE_DEV_PM_OPS(pm80x_rtc_pm_ops, pm80x_rtc_suspend, pm80x_rtc_resume);
 
-static int __devinit pm80x_rtc_probe(struct platform_device *pdev)
+static int pm80x_rtc_probe(struct platform_device *pdev)
 {
        struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
        struct pm80x_platform_data *pm80x_pdata;
        return ret;
 }
 
-static int __devexit pm80x_rtc_remove(struct platform_device *pdev)
+static int pm80x_rtc_remove(struct platform_device *pdev)
 {
        struct pm80x_rtc_info *info = platform_get_drvdata(pdev);
        platform_set_drvdata(pdev, NULL);
                   .pm = &pm80x_rtc_pm_ops,
                   },
        .probe = pm80x_rtc_probe,
-       .remove = __devexit_p(pm80x_rtc_remove),
+       .remove = pm80x_rtc_remove,
 };
 
 module_platform_driver(pm80x_rtc_driver);
 
 #endif
 
 #ifdef CONFIG_OF
-static int __devinit pm860x_rtc_dt_init(struct platform_device *pdev,
-                                       struct pm860x_rtc_info *info)
+static int pm860x_rtc_dt_init(struct platform_device *pdev,
+                             struct pm860x_rtc_info *info)
 {
        struct device_node *np = pdev->dev.parent->of_node;
        int ret;
 #define pm860x_rtc_dt_init(x, y)       (-1)
 #endif
 
-static int __devinit pm860x_rtc_probe(struct platform_device *pdev)
+static int pm860x_rtc_probe(struct platform_device *pdev)
 {
        struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
        struct pm860x_rtc_pdata *pdata = NULL;
        return ret;
 }
 
-static int __devexit pm860x_rtc_remove(struct platform_device *pdev)
+static int pm860x_rtc_remove(struct platform_device *pdev)
 {
        struct pm860x_rtc_info *info = platform_get_drvdata(pdev);
 
                .pm     = &pm860x_rtc_pm_ops,
        },
        .probe          = pm860x_rtc_probe,
-       .remove         = __devexit_p(pm860x_rtc_remove),
+       .remove         = pm860x_rtc_remove,
 };
 
 module_platform_driver(pm860x_rtc_driver);
 
        .alarm_irq_enable       = ab8500_rtc_irq_enable,
 };
 
-static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
+static int ab8500_rtc_probe(struct platform_device *pdev)
 {
        int err;
        struct rtc_device *rtc;
        return 0;
 }
 
-static int __devexit ab8500_rtc_remove(struct platform_device *pdev)
+static int ab8500_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc = platform_get_drvdata(pdev);
        int irq = platform_get_irq_byname(pdev, "ALARM");
                .owner = THIS_MODULE,
        },
        .probe  = ab8500_rtc_probe,
-       .remove = __devexit_p(ab8500_rtc_remove),
+       .remove = ab8500_rtc_remove,
 };
 
 module_platform_driver(ab8500_rtc_driver);
 
 /*
  * Initialize and install RTC driver
  */
-static int __devinit at91_rtc_probe(struct platform_device *pdev)
+static int at91_rtc_probe(struct platform_device *pdev)
 {
        struct resource *r, *r_gpbr;
        struct sam9_rtc *rtc;
 /*
  * Disable and remove the RTC driver
  */
-static int __devexit at91_rtc_remove(struct platform_device *pdev)
+static int at91_rtc_remove(struct platform_device *pdev)
 {
        struct sam9_rtc *rtc = platform_get_drvdata(pdev);
        u32             mr = rtt_readl(rtc, MR);
 
 static struct platform_driver at91_rtc_driver = {
        .probe          = at91_rtc_probe,
-       .remove         = __devexit_p(at91_rtc_remove),
+       .remove         = at91_rtc_remove,
        .shutdown       = at91_rtc_shutdown,
        .suspend        = at91_rtc_suspend,
        .resume         = at91_rtc_resume,
 
        .set_time       = au1xtoy_rtc_set_time,
 };
 
-static int __devinit au1xtoy_rtc_probe(struct platform_device *pdev)
+static int au1xtoy_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtcdev;
        unsigned long t;
        return ret;
 }
 
-static int __devexit au1xtoy_rtc_remove(struct platform_device *pdev)
+static int au1xtoy_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtcdev = platform_get_drvdata(pdev);
 
                .name   = "rtc-au1xxx",
                .owner  = THIS_MODULE,
        },
-       .remove         = __devexit_p(au1xtoy_rtc_remove),
+       .remove         = au1xtoy_rtc_remove,
 };
 
 static int __init au1xtoy_rtc_init(void)
 
        .alarm_irq_enable = bfin_rtc_alarm_irq_enable,
 };
 
-static int __devinit bfin_rtc_probe(struct platform_device *pdev)
+static int bfin_rtc_probe(struct platform_device *pdev)
 {
        struct bfin_rtc *rtc;
        struct device *dev = &pdev->dev;
        return ret;
 }
 
-static int __devexit bfin_rtc_remove(struct platform_device *pdev)
+static int bfin_rtc_remove(struct platform_device *pdev)
 {
        struct bfin_rtc *rtc = platform_get_drvdata(pdev);
        struct device *dev = &pdev->dev;
                .owner  = THIS_MODULE,
        },
        .probe          = bfin_rtc_probe,
-       .remove         = __devexit_p(bfin_rtc_remove),
+       .remove         = bfin_rtc_remove,
        .suspend        = bfin_rtc_suspend,
        .resume         = bfin_rtc_resume,
 };
 
        return 0;
 }
 
-static int __devexit bq32k_remove(struct i2c_client *client)
+static int bq32k_remove(struct i2c_client *client)
 {
        struct rtc_device *rtc = i2c_get_clientdata(client);
 
                .owner  = THIS_MODULE,
        },
        .probe          = bq32k_probe,
-       .remove         = __devexit_p(bq32k_remove),
+       .remove         = bq32k_remove,
        .id_table       = bq32k_id,
 };
 
 
        .set_time       = bq4802_set_time,
 };
 
-static int __devinit bq4802_probe(struct platform_device *pdev)
+static int bq4802_probe(struct platform_device *pdev)
 {
        struct bq4802 *p = kzalloc(sizeof(*p), GFP_KERNEL);
        int err = -ENOMEM;
        goto out;
 }
 
-static int __devexit bq4802_remove(struct platform_device *pdev)
+static int bq4802_remove(struct platform_device *pdev)
 {
        struct bq4802 *p = platform_get_drvdata(pdev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = bq4802_probe,
-       .remove         = __devexit_p(bq4802_remove),
+       .remove         = bq4802_remove,
 };
 
 module_platform_driver(bq4802_driver);
 
  */
 static struct cmos_rtc_board_info acpi_rtc_info;
 
-static void __devinit
-cmos_wake_setup(struct device *dev)
+static void cmos_wake_setup(struct device *dev)
 {
        if (acpi_disabled)
                return;
 
 #else
 
-static void __devinit
-cmos_wake_setup(struct device *dev)
+static void cmos_wake_setup(struct device *dev)
 {
 }
 
 
 #include <linux/pnp.h>
 
-static int __devinit
-cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
+static int cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
 {
        cmos_wake_setup(&pnp->dev);
 
 
        .alarm_irq_enable = da9052_rtc_alarm_irq_enable,
 };
 
-static int __devinit da9052_rtc_probe(struct platform_device *pdev)
+static int da9052_rtc_probe(struct platform_device *pdev)
 {
        struct da9052_rtc *rtc;
        int ret;
        return ret;
 }
 
-static int __devexit da9052_rtc_remove(struct platform_device *pdev)
+static int da9052_rtc_remove(struct platform_device *pdev)
 {
        struct da9052_rtc *rtc = pdev->dev.platform_data;
 
 
 static struct platform_driver da9052_rtc_driver = {
        .probe  = da9052_rtc_probe,
-       .remove = __devexit_p(da9052_rtc_remove),
+       .remove = da9052_rtc_remove,
        .driver = {
                .name   = "da9052-rtc",
                .owner  = THIS_MODULE,
 
        return ret;
 }
 
-static int __devexit davinci_rtc_remove(struct platform_device *pdev)
+static int davinci_rtc_remove(struct platform_device *pdev)
 {
        struct davinci_rtc *davinci_rtc = platform_get_drvdata(pdev);
 
 
 static struct platform_driver davinci_rtc_driver = {
        .probe          = davinci_rtc_probe,
-       .remove         = __devexit_p(davinci_rtc_remove),
+       .remove         = davinci_rtc_remove,
        .driver         = {
                .name = "rtc_davinci",
                .owner = THIS_MODULE,
 
 
 /*----------------------------------------------------------------------*/
 
-static int __devinit dm355evm_rtc_probe(struct platform_device *pdev)
+static int dm355evm_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
 
        return 0;
 }
 
-static int __devexit dm355evm_rtc_remove(struct platform_device *pdev)
+static int dm355evm_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
  */
 static struct platform_driver rtc_dm355evm_driver = {
        .probe          = dm355evm_rtc_probe,
-       .remove         = __devexit_p(dm355evm_rtc_remove),
+       .remove         = dm355evm_rtc_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "rtc-dm355evm",
 
        .alarm_irq_enable = ds1286_alarm_irq_enable,
 };
 
-static int __devinit ds1286_probe(struct platform_device *pdev)
+static int ds1286_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        struct resource *res;
        return ret;
 }
 
-static int __devexit ds1286_remove(struct platform_device *pdev)
+static int ds1286_remove(struct platform_device *pdev)
 {
        struct ds1286_priv *priv = platform_get_drvdata(pdev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = ds1286_probe,
-       .remove         = __devexit_p(ds1286_remove),
+       .remove         = ds1286_remove,
 };
 
 module_platform_driver(ds1286_platform_driver);
 
        return 0;
 }
 
-static int __devexit ds1302_rtc_remove(struct platform_device *pdev)
+static int ds1302_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,
        },
-       .remove         = __devexit_p(ds1302_rtc_remove),
+       .remove         = ds1302_rtc_remove,
 };
 
 static int __init ds1302_rtc_init(void)
 
  * Interface to SPI stack
  */
 
-static int __devinit ds1305_probe(struct spi_device *spi)
+static int ds1305_probe(struct spi_device *spi)
 {
        struct ds1305                   *ds1305;
        int                             status;
        return status;
 }
 
-static int __devexit ds1305_remove(struct spi_device *spi)
+static int ds1305_remove(struct spi_device *spi)
 {
        struct ds1305 *ds1305 = spi_get_drvdata(spi);
 
        .driver.name    = "rtc-ds1305",
        .driver.owner   = THIS_MODULE,
        .probe          = ds1305_probe,
-       .remove         = __devexit_p(ds1305_remove),
+       .remove         = ds1305_remove,
        /* REVISIT add suspend/resume */
 };
 
 
 
 /*----------------------------------------------------------------------*/
 
-static int __devinit ds1307_probe(struct i2c_client *client,
-                                 const struct i2c_device_id *id)
+static int ds1307_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
 {
        struct ds1307           *ds1307;
        int                     err = -ENODEV;
        return err;
 }
 
-static int __devexit ds1307_remove(struct i2c_client *client)
+static int ds1307_remove(struct i2c_client *client)
 {
        struct ds1307 *ds1307 = i2c_get_clientdata(client);
 
                .owner  = THIS_MODULE,
        },
        .probe          = ds1307_probe,
-       .remove         = __devexit_p(ds1307_remove),
+       .remove         = ds1307_remove,
        .id_table       = ds1307_id,
 };
 
 
        return ret;
 }
 
-static int __devexit ds1374_remove(struct i2c_client *client)
+static int ds1374_remove(struct i2c_client *client)
 {
        struct ds1374 *ds1374 = i2c_get_clientdata(client);
 
                .pm = DS1374_PM,
        },
        .probe = ds1374_probe,
-       .remove = __devexit_p(ds1374_remove),
+       .remove = ds1374_remove,
        .id_table = ds1374_id,
 };
 
 
        .set_time       = ds1390_set_time,
 };
 
-static int __devinit ds1390_probe(struct spi_device *spi)
+static int ds1390_probe(struct spi_device *spi)
 {
        unsigned char tmp;
        struct ds1390 *chip;
        return res;
 }
 
-static int __devexit ds1390_remove(struct spi_device *spi)
+static int ds1390_remove(struct spi_device *spi)
 {
        struct ds1390 *chip = spi_get_drvdata(spi);
 
                .owner  = THIS_MODULE,
        },
        .probe  = ds1390_probe,
-       .remove = __devexit_p(ds1390_remove),
+       .remove = ds1390_remove,
 };
 
 module_spi_driver(ds1390_driver);
 
        .write = ds1511_nvram_write,
 };
 
- static int __devinit
-ds1511_rtc_probe(struct platform_device *pdev)
+static int ds1511_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        struct resource *res;
        return ret;
 }
 
- static int __devexit
-ds1511_rtc_remove(struct platform_device *pdev)
+static int ds1511_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
 
 static struct platform_driver ds1511_rtc_driver = {
        .probe          = ds1511_rtc_probe,
-       .remove         = __devexit_p(ds1511_rtc_remove),
+       .remove         = ds1511_rtc_remove,
        .driver         = {
                .name   = "ds1511",
                .owner  = THIS_MODULE,
 
        .write = ds1553_nvram_write,
 };
 
-static int __devinit ds1553_rtc_probe(struct platform_device *pdev)
+static int ds1553_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        struct resource *res;
        return ret;
 }
 
-static int __devexit ds1553_rtc_remove(struct platform_device *pdev)
+static int ds1553_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
 
 static struct platform_driver ds1553_rtc_driver = {
        .probe          = ds1553_rtc_probe,
-       .remove         = __devexit_p(ds1553_rtc_remove),
+       .remove         = ds1553_rtc_remove,
        .driver         = {
                .name   = "rtc-ds1553",
                .owner  = THIS_MODULE,
 
        return count;
 }
 
-static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
+static int ds1742_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        struct resource *res;
        return ret;
 }
 
-static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
+static int ds1742_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
 
 static struct platform_driver ds1742_rtc_driver = {
        .probe          = ds1742_rtc_probe,
-       .remove         = __devexit_p(ds1742_rtc_remove),
+       .remove         = ds1742_rtc_remove,
        .driver         = {
                .name   = "rtc-ds1742",
                .owner  = THIS_MODULE,
 
        .alarm_irq_enable = ds3232_alarm_irq_enable,
 };
 
-static int __devinit ds3232_probe(struct i2c_client *client,
-               const struct i2c_device_id *id)
+static int ds3232_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
 {
        struct ds3232 *ds3232;
        int ret;
        return ret;
 }
 
-static int __devexit ds3232_remove(struct i2c_client *client)
+static int ds3232_remove(struct i2c_client *client)
 {
        struct ds3232 *ds3232 = i2c_get_clientdata(client);
 
                .owner = THIS_MODULE,
        },
        .probe = ds3232_probe,
-       .remove = __devexit_p(ds3232_remove),
+       .remove = ds3232_remove,
        .id_table = ds3232_id,
 };
 
 
        .set_time       = ds3234_set_time,
 };
 
-static int __devinit ds3234_probe(struct spi_device *spi)
+static int ds3234_probe(struct spi_device *spi)
 {
        struct rtc_device *rtc;
        unsigned char tmp;
        return 0;
 }
 
-static int __devexit ds3234_remove(struct spi_device *spi)
+static int ds3234_remove(struct spi_device *spi)
 {
        struct rtc_device *rtc = spi_get_drvdata(spi);
 
                .owner  = THIS_MODULE,
        },
        .probe   = ds3234_probe,
-       .remove = __devexit_p(ds3234_remove),
+       .remove = ds3234_remove,
 };
 
 module_spi_driver(ds3234_driver);
 
        .attrs  = ep93xx_rtc_attrs,
 };
 
-static int __devinit ep93xx_rtc_probe(struct platform_device *pdev)
+static int ep93xx_rtc_probe(struct platform_device *pdev)
 {
        struct ep93xx_rtc *ep93xx_rtc;
        struct resource *res;
        return err;
 }
 
-static int __devexit ep93xx_rtc_remove(struct platform_device *pdev)
+static int ep93xx_rtc_remove(struct platform_device *pdev)
 {
        struct ep93xx_rtc *ep93xx_rtc = platform_get_drvdata(pdev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = ep93xx_rtc_probe,
-       .remove         = __devexit_p(ep93xx_rtc_remove),
+       .remove         = ep93xx_rtc_remove,
 };
 
 module_platform_driver(ep93xx_rtc_driver);
 
 
 static struct i2c_driver fm3130_driver;
 
-static int __devinit fm3130_probe(struct i2c_client *client,
-                                 const struct i2c_device_id *id)
+static int fm3130_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
 {
        struct fm3130           *fm3130;
        int                     err = -ENODEV;
        return err;
 }
 
-static int __devexit fm3130_remove(struct i2c_client *client)
+static int fm3130_remove(struct i2c_client *client)
 {
        struct fm3130 *fm3130 = i2c_get_clientdata(client);
 
                .owner  = THIS_MODULE,
        },
        .probe          = fm3130_probe,
-       .remove         = __devexit_p(fm3130_remove),
+       .remove         = fm3130_remove,
        .id_table       = fm3130_id,
 };
 
 
        return rc;
 }
 
-static int __devexit dryice_rtc_remove(struct platform_device *pdev)
+static int dryice_rtc_remove(struct platform_device *pdev)
 {
        struct imxdi_dev *imxdi = platform_get_drvdata(pdev);
 
                   .owner = THIS_MODULE,
                   .of_match_table = of_match_ptr(dryice_dt_ids),
                   },
-       .remove = __devexit_p(dryice_rtc_remove),
+       .remove = dryice_rtc_remove,
 };
 
 static int __init dryice_rtc_init(void)
 
 }
 EXPORT_SYMBOL_GPL(jz4740_rtc_poweroff);
 
-static int __devinit jz4740_rtc_probe(struct platform_device *pdev)
+static int jz4740_rtc_probe(struct platform_device *pdev)
 {
        int ret;
        struct jz4740_rtc *rtc;
        return ret;
 }
 
-static int __devexit jz4740_rtc_remove(struct platform_device *pdev)
+static int jz4740_rtc_remove(struct platform_device *pdev)
 {
        struct jz4740_rtc *rtc = platform_get_drvdata(pdev);
 
 
 static struct platform_driver jz4740_rtc_driver = {
        .probe   = jz4740_rtc_probe,
-       .remove  = __devexit_p(jz4740_rtc_remove),
+       .remove  = jz4740_rtc_remove,
        .driver  = {
                .name  = "jz4740-rtc",
                .owner = THIS_MODULE,
 
        .alarm_irq_enable       = lpc32xx_rtc_alarm_irq_enable,
 };
 
-static int __devinit lpc32xx_rtc_probe(struct platform_device *pdev)
+static int lpc32xx_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct lpc32xx_rtc *rtc;
        return 0;
 }
 
-static int __devexit lpc32xx_rtc_remove(struct platform_device *pdev)
+static int lpc32xx_rtc_remove(struct platform_device *pdev)
 {
        struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
 
 
 static struct platform_driver lpc32xx_rtc_driver = {
        .probe          = lpc32xx_rtc_probe,
-       .remove         = __devexit_p(lpc32xx_rtc_remove),
+       .remove         = lpc32xx_rtc_remove,
        .driver = {
                .name   = RTC_NAME,
                .owner  = THIS_MODULE,
 
        .set_time       = ls1x_rtc_set_time,
 };
 
-static int __devinit ls1x_rtc_probe(struct platform_device *pdev)
+static int ls1x_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtcdev;
        unsigned long v;
        return ret;
 }
 
-static int __devexit ls1x_rtc_remove(struct platform_device *pdev)
+static int ls1x_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtcdev = platform_get_drvdata(pdev);
 
                .name   = "ls1x-rtc",
                .owner  = THIS_MODULE,
        },
-       .remove         = __devexit_p(ls1x_rtc_remove),
+       .remove         = ls1x_rtc_remove,
        .probe          = ls1x_rtc_probe,
 };
 
 
 
 static struct spi_driver m41t93_driver;
 
-static int __devinit m41t93_probe(struct spi_device *spi)
+static int m41t93_probe(struct spi_device *spi)
 {
        struct rtc_device *rtc;
        int res;
 }
 
 
-static int __devexit m41t93_remove(struct spi_device *spi)
+static int m41t93_remove(struct spi_device *spi)
 {
        struct rtc_device *rtc = spi_get_drvdata(spi);
 
                .owner  = THIS_MODULE,
        },
        .probe  = m41t93_probe,
-       .remove = __devexit_p(m41t93_remove),
+       .remove = m41t93_remove,
 };
 
 module_spi_driver(m41t93_driver);
 
 
 static struct spi_driver m41t94_driver;
 
-static int __devinit m41t94_probe(struct spi_device *spi)
+static int m41t94_probe(struct spi_device *spi)
 {
        struct rtc_device *rtc;
        int res;
        return 0;
 }
 
-static int __devexit m41t94_remove(struct spi_device *spi)
+static int m41t94_remove(struct spi_device *spi)
 {
        struct rtc_device *rtc = spi_get_drvdata(spi);
 
                .owner  = THIS_MODULE,
        },
        .probe  = m41t94_probe,
-       .remove = __devexit_p(m41t94_remove),
+       .remove = m41t94_remove,
 };
 
 module_spi_driver(m41t94_driver);
 
        .set_time       = m48t35_set_time,
 };
 
-static int __devinit m48t35_probe(struct platform_device *pdev)
+static int m48t35_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct m48t35_priv *priv;
        return ret;
 }
 
-static int __devexit m48t35_remove(struct platform_device *pdev)
+static int m48t35_remove(struct platform_device *pdev)
 {
        struct m48t35_priv *priv = platform_get_drvdata(pdev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = m48t35_probe,
-       .remove         = __devexit_p(m48t35_remove),
+       .remove         = m48t35_remove,
 };
 
 module_platform_driver(m48t35_platform_driver);
 
        .write = m48t59_nvram_write,
 };
 
-static int __devinit m48t59_rtc_probe(struct platform_device *pdev)
+static int m48t59_rtc_probe(struct platform_device *pdev)
 {
        struct m48t59_plat_data *pdata = pdev->dev.platform_data;
        struct m48t59_private *m48t59 = NULL;
        return ret;
 }
 
-static int __devexit m48t59_rtc_remove(struct platform_device *pdev)
+static int m48t59_rtc_remove(struct platform_device *pdev)
 {
        struct m48t59_private *m48t59 = platform_get_drvdata(pdev);
        struct m48t59_plat_data *pdata = pdev->dev.platform_data;
                .owner  = THIS_MODULE,
        },
        .probe          = m48t59_rtc_probe,
-       .remove         = __devexit_p(m48t59_rtc_remove),
+       .remove         = m48t59_rtc_remove,
 };
 
 module_platform_driver(m48t59_rtc_driver);
 
        .proc           = m48t86_rtc_proc,
 };
 
-static int __devinit m48t86_rtc_probe(struct platform_device *dev)
+static int m48t86_rtc_probe(struct platform_device *dev)
 {
        unsigned char reg;
        struct m48t86_ops *ops = dev->dev.platform_data;
        return 0;
 }
 
-static int __devexit m48t86_rtc_remove(struct platform_device *dev)
+static int m48t86_rtc_remove(struct platform_device *dev)
 {
        struct rtc_device *rtc = platform_get_drvdata(dev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = m48t86_rtc_probe,
-       .remove         = __devexit_p(m48t86_rtc_remove),
+       .remove         = m48t86_rtc_remove,
 };
 
 module_platform_driver(m48t86_rtc_platform_driver);
 
        .set_time       = max6902_set_time,
 };
 
-static int __devinit max6902_probe(struct spi_device *spi)
+static int max6902_probe(struct spi_device *spi)
 {
        struct rtc_device *rtc;
        unsigned char tmp;
        return 0;
 }
 
-static int __devexit max6902_remove(struct spi_device *spi)
+static int max6902_remove(struct spi_device *spi)
 {
        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
 
                .owner  = THIS_MODULE,
        },
        .probe  = max6902_probe,
-       .remove = __devexit_p(max6902_remove),
+       .remove = max6902_remove,
 };
 
 module_spi_driver(max6902_driver);
 
        .set_alarm      = max8907_rtc_set_alarm,
 };
 
-static int __devinit max8907_rtc_probe(struct platform_device *pdev)
+static int max8907_rtc_probe(struct platform_device *pdev)
 {
        struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
        struct max8907_rtc *rtc;
        return ret;
 }
 
-static int __devexit max8907_rtc_remove(struct platform_device *pdev)
+static int max8907_rtc_remove(struct platform_device *pdev)
 {
        struct max8907_rtc *rtc = platform_get_drvdata(pdev);
 
                .owner = THIS_MODULE,
        },
        .probe = max8907_rtc_probe,
-       .remove = __devexit_p(max8907_rtc_remove),
+       .remove = max8907_rtc_remove,
 };
 module_platform_driver(max8907_rtc_driver);
 
 
        .set_alarm      = max8925_rtc_set_alarm,
 };
 
-static int __devinit max8925_rtc_probe(struct platform_device *pdev)
+static int max8925_rtc_probe(struct platform_device *pdev)
 {
        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
        struct max8925_rtc_info *info;
        return ret;
 }
 
-static int __devexit max8925_rtc_remove(struct platform_device *pdev)
+static int max8925_rtc_remove(struct platform_device *pdev)
 {
        struct max8925_rtc_info *info = platform_get_drvdata(pdev);
 
                .pm     = &max8925_rtc_pm_ops,
        },
        .probe          = max8925_rtc_probe,
-       .remove         = __devexit_p(max8925_rtc_remove),
+       .remove         = max8925_rtc_remove,
 };
 
 module_platform_driver(max8925_rtc_driver);
 
        .alarm_irq_enable = max8998_rtc_alarm_irq_enable,
 };
 
-static int __devinit max8998_rtc_probe(struct platform_device *pdev)
+static int max8998_rtc_probe(struct platform_device *pdev)
 {
        struct max8998_dev *max8998 = dev_get_drvdata(pdev->dev.parent);
        struct max8998_platform_data *pdata = dev_get_platdata(max8998->dev);
        return ret;
 }
 
-static int __devexit max8998_rtc_remove(struct platform_device *pdev)
+static int max8998_rtc_remove(struct platform_device *pdev)
 {
        struct max8998_rtc_info *info = platform_get_drvdata(pdev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = max8998_rtc_probe,
-       .remove         = __devexit_p(max8998_rtc_remove),
+       .remove         = max8998_rtc_remove,
        .id_table       = max8998_rtc_id,
 };
 
 
        .alarm_irq_enable = mpc5121_rtc_alarm_irq_enable,
 };
 
-static int __devinit mpc5121_rtc_probe(struct platform_device *op)
+static int mpc5121_rtc_probe(struct platform_device *op)
 {
        struct mpc5121_rtc_data *rtc;
        int err = 0;
        return err;
 }
 
-static int __devexit mpc5121_rtc_remove(struct platform_device *op)
+static int mpc5121_rtc_remove(struct platform_device *op)
 {
        struct mpc5121_rtc_data *rtc = dev_get_drvdata(&op->dev);
        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
        return 0;
 }
 
-static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
+static struct of_device_id mpc5121_rtc_match[] = {
        { .compatible = "fsl,mpc5121-rtc", },
        { .compatible = "fsl,mpc5200-rtc", },
        {},
                .of_match_table = mpc5121_rtc_match,
        },
        .probe = mpc5121_rtc_probe,
-       .remove = __devexit_p(mpc5121_rtc_remove),
+       .remove = mpc5121_rtc_remove,
 };
 
 module_platform_driver(mpc5121_rtc_driver);
 
        return IRQ_NONE;
 }
 
-static int __devinit
-vrtc_mrst_do_probe(struct device *dev, struct resource *iomem, int rtc_irq)
+static int vrtc_mrst_do_probe(struct device *dev, struct resource *iomem,
+                             int rtc_irq)
 {
        int retval = 0;
        unsigned char rtc_control;
        spin_unlock_irq(&rtc_lock);
 }
 
-static void __devexit rtc_mrst_do_remove(struct device *dev)
+static void rtc_mrst_do_remove(struct device *dev)
 {
        struct mrst_rtc *mrst = dev_get_drvdata(dev);
        struct resource *iomem;
 
 #endif
 
-static int __devinit vrtc_mrst_platform_probe(struct platform_device *pdev)
+static int vrtc_mrst_platform_probe(struct platform_device *pdev)
 {
        return vrtc_mrst_do_probe(&pdev->dev,
                        platform_get_resource(pdev, IORESOURCE_MEM, 0),
                        platform_get_irq(pdev, 0));
 }
 
-static int __devexit vrtc_mrst_platform_remove(struct platform_device *pdev)
+static int vrtc_mrst_platform_remove(struct platform_device *pdev)
 {
        rtc_mrst_do_remove(&pdev->dev);
        return 0;
 
 static struct platform_driver vrtc_mrst_platform_driver = {
        .probe          = vrtc_mrst_platform_probe,
-       .remove         = __devexit_p(vrtc_mrst_platform_remove),
+       .remove         = vrtc_mrst_platform_remove,
        .shutdown       = vrtc_mrst_platform_shutdown,
        .driver = {
                .name           = (char *) driver_name,
 
        .alarm_irq_enable = mv_rtc_alarm_irq_enable,
 };
 
-static int __devinit mv_rtc_probe(struct platform_device *pdev)
+static int mv_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct rtc_plat_data *pdata;
 
        .alarm_irq_enable       = mxc_rtc_alarm_irq_enable,
 };
 
-static int __devinit mxc_rtc_probe(struct platform_device *pdev)
+static int mxc_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct rtc_device *rtc;
        return ret;
 }
 
-static int __devexit mxc_rtc_remove(struct platform_device *pdev)
+static int mxc_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
        },
        .id_table = imx_rtc_devtype,
        .probe = mxc_rtc_probe,
-       .remove = __devexit_p(mxc_rtc_remove),
+       .remove = mxc_rtc_remove,
 };
 
 module_platform_driver(mxc_rtc_driver)
 
        .alarm_irq_enable = nuc900_alarm_irq_enable,
 };
 
-static int __devinit nuc900_rtc_probe(struct platform_device *pdev)
+static int nuc900_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct nuc900_rtc *nuc900_rtc;
        return err;
 }
 
-static int __devexit nuc900_rtc_remove(struct platform_device *pdev)
+static int nuc900_rtc_remove(struct platform_device *pdev)
 {
        struct nuc900_rtc *nuc900_rtc = platform_get_drvdata(pdev);
        struct resource *res;
 }
 
 static struct platform_driver nuc900_rtc_driver = {
-       .remove         = __devexit_p(nuc900_rtc_remove),
+       .remove         = nuc900_rtc_remove,
        .driver         = {
                .name   = "nuc900-rtc",
                .owner  = THIS_MODULE,
 
        .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
 };
 
-static int __devinit pcap_rtc_probe(struct platform_device *pdev)
+static int pcap_rtc_probe(struct platform_device *pdev)
 {
        struct pcap_rtc *pcap_rtc;
        int timer_irq, alarm_irq;
        return err;
 }
 
-static int __devexit pcap_rtc_remove(struct platform_device *pdev)
+static int pcap_rtc_remove(struct platform_device *pdev)
 {
        struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
 
 }
 
 static struct platform_driver pcap_rtc_driver = {
-       .remove = __devexit_p(pcap_rtc_remove),
+       .remove = pcap_rtc_remove,
        .driver = {
                .name  = "pcap-rtc",
                .owner = THIS_MODULE,
 
        .set_time       = pcf2123_rtc_set_time,
 };
 
-static int __devinit pcf2123_probe(struct spi_device *spi)
+static int pcf2123_probe(struct spi_device *spi)
 {
        struct rtc_device *rtc;
        struct pcf2123_plat_data *pdata;
        return ret;
 }
 
-static int __devexit pcf2123_remove(struct spi_device *spi)
+static int pcf2123_remove(struct spi_device *spi)
 {
        struct pcf2123_plat_data *pdata = spi->dev.platform_data;
        int i;
                        .owner  = THIS_MODULE,
        },
        .probe  = pcf2123_probe,
-       .remove = __devexit_p(pcf2123_remove),
+       .remove = pcf2123_remove,
 };
 
 module_spi_driver(pcf2123_driver);
 
        rtc->alarm_pending = 1;
 }
 
-static int __devinit pcf50633_rtc_probe(struct platform_device *pdev)
+static int pcf50633_rtc_probe(struct platform_device *pdev)
 {
        struct pcf50633_rtc *rtc;
 
        return 0;
 }
 
-static int __devexit pcf50633_rtc_remove(struct platform_device *pdev)
+static int pcf50633_rtc_remove(struct platform_device *pdev)
 {
        struct pcf50633_rtc *rtc;
 
                .name = "pcf50633-rtc",
        },
        .probe = pcf50633_rtc_probe,
-       .remove = __devexit_p(pcf50633_rtc_remove),
+       .remove = pcf50633_rtc_remove,
 };
 
 module_platform_driver(pcf50633_rtc_driver);
 
 MODULE_DEVICE_TABLE(i2c, pcf8563_id);
 
 #ifdef CONFIG_OF
-static const struct of_device_id pcf8563_of_match[] __devinitconst = {
+static const struct of_device_id pcf8563_of_match[] = {
        { .compatible = "nxp,pcf8563" },
        {}
 };
 
        return err;
 }
 
-static int __devexit pcf8583_remove(struct i2c_client *client)
+static int pcf8583_remove(struct i2c_client *client)
 {
        struct pcf8583 *pcf8583 = i2c_get_clientdata(client);
 
                .owner  = THIS_MODULE,
        },
        .probe          = pcf8583_probe,
-       .remove         = __devexit_p(pcf8583_remove),
+       .remove         = pcf8583_remove,
        .id_table       = pcf8583_id,
 };
 
 
        return IRQ_HANDLED;
 }
 
-static int __devinit pm8xxx_rtc_probe(struct platform_device *pdev)
+static int pm8xxx_rtc_probe(struct platform_device *pdev)
 {
        int rc;
        u8 ctrl_reg;
        return rc;
 }
 
-static int __devexit pm8xxx_rtc_remove(struct platform_device *pdev)
+static int pm8xxx_rtc_remove(struct platform_device *pdev)
 {
        struct pm8xxx_rtc *rtc_dd = platform_get_drvdata(pdev);
 
 
 static struct platform_driver pm8xxx_rtc_driver = {
        .probe          = pm8xxx_rtc_probe,
-       .remove         = __devexit_p(pm8xxx_rtc_remove),
+       .remove         = pm8xxx_rtc_remove,
        .driver = {
                .name   = PM8XXX_RTC_DEV_NAME,
                .owner  = THIS_MODULE,
 
        }
 }
 
-static int __devexit puv3_rtc_remove(struct platform_device *dev)
+static int puv3_rtc_remove(struct platform_device *dev)
 {
        struct rtc_device *rtc = platform_get_drvdata(dev);
 
        return 0;
 }
 
-static int __devinit puv3_rtc_probe(struct platform_device *pdev)
+static int puv3_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        struct resource *res;
 
 static struct platform_driver puv3_rtc_driver = {
        .probe          = puv3_rtc_probe,
-       .remove         = __devexit_p(puv3_rtc_remove),
+       .remove         = puv3_rtc_remove,
        .suspend        = puv3_rtc_suspend,
        .resume         = puv3_rtc_resume,
        .driver         = {
 
        .set_time       = r9701_set_datetime,
 };
 
-static int __devinit r9701_probe(struct spi_device *spi)
+static int r9701_probe(struct spi_device *spi)
 {
        struct rtc_device *rtc;
        struct rtc_time dt;
        return 0;
 }
 
-static int __devexit r9701_remove(struct spi_device *spi)
+static int r9701_remove(struct spi_device *spi)
 {
        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
 
                .owner  = THIS_MODULE,
        },
        .probe  = r9701_probe,
-       .remove = __devexit_p(r9701_remove),
+       .remove = r9701_remove,
 };
 
 module_spi_driver(r9701_driver);
 
        .alarm_irq_enable = rc5t583_rtc_alarm_irq_enable,
 };
 
-static int __devinit rc5t583_rtc_probe(struct platform_device *pdev)
+static int rc5t583_rtc_probe(struct platform_device *pdev)
 {
        struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
        struct rc5t583_rtc *ricoh_rtc;
  * Disable rc5t583 RTC interrupts.
  * Sets status flag to free.
  */
-static int __devexit rc5t583_rtc_remove(struct platform_device *pdev)
+static int rc5t583_rtc_remove(struct platform_device *pdev)
 {
        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(&pdev->dev);
 
 
 static struct platform_driver rc5t583_rtc_driver = {
        .probe          = rc5t583_rtc_probe,
-       .remove         = __devexit_p(rc5t583_rtc_remove),
+       .remove         = rc5t583_rtc_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "rtc-rc5t583",
 
        return 0;
 }
 
-static int __devexit rs5c313_rtc_remove(struct platform_device *pdev)
+static int rs5c313_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc = platform_get_drvdata( pdev );
 
                .owner  = THIS_MODULE,
        },
        .probe  = rs5c313_rtc_probe,
-       .remove = __devexit_p( rs5c313_rtc_remove ),
+       .remove = rs5c313_rtc_remove,
 };
 
 static int __init rs5c313_rtc_init(void)
 
 
 static struct spi_driver rs5c348_driver;
 
-static int __devinit rs5c348_probe(struct spi_device *spi)
+static int rs5c348_probe(struct spi_device *spi)
 {
        int ret;
        struct rtc_device *rtc;
        return ret;
 }
 
-static int __devexit rs5c348_remove(struct spi_device *spi)
+static int rs5c348_remove(struct spi_device *spi)
 {
        struct rs5c348_plat_data *pdata = spi->dev.platform_data;
        struct rtc_device *rtc = pdata->rtc;
                .owner  = THIS_MODULE,
        },
        .probe  = rs5c348_probe,
-       .remove = __devexit_p(rs5c348_remove),
+       .remove = rs5c348_remove,
 };
 
 module_spi_driver(rs5c348_driver);
 
 };
 MODULE_DEVICE_TABLE(i2c, rv3029c2_id);
 
-static int __devinit
-rv3029c2_probe(struct i2c_client *client, const struct i2c_device_id *id)
+static int rv3029c2_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
 {
        struct rtc_device *rtc;
        int rc = 0;
        return rc;
 }
 
-static int __devexit rv3029c2_remove(struct i2c_client *client)
+static int rv3029c2_remove(struct i2c_client *client)
 {
        struct rtc_device *rtc = i2c_get_clientdata(client);
 
                .name = "rtc-rv3029c2",
        },
        .probe = rv3029c2_probe,
-       .remove = __devexit_p(rv3029c2_remove),
+       .remove = rv3029c2_remove,
        .id_table = rv3029c2_id,
 };
 
 
        device_remove_file(dev, &dev_attr_clock_adjust_ppb);
 }
 
-static int __devinit rx8025_probe(struct i2c_client *client,
-                                 const struct i2c_device_id *id)
+static int rx8025_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
 {
        struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
        struct rx8025_data *rx8025;
        return err;
 }
 
-static int __devexit rx8025_remove(struct i2c_client *client)
+static int rx8025_remove(struct i2c_client *client)
 {
        struct rx8025_data *rx8025 = i2c_get_clientdata(client);
        struct mutex *lock = &rx8025->rtc->ops_lock;
                .owner = THIS_MODULE,
        },
        .probe          = rx8025_probe,
-       .remove         = __devexit_p(rx8025_remove),
+       .remove         = rx8025_remove,
        .id_table       = rx8025_id,
 };
 
 
        .set_time       = rx8581_rtc_set_time,
 };
 
-static int __devinit rx8581_probe(struct i2c_client *client,
-                               const struct i2c_device_id *id)
+static int rx8581_probe(struct i2c_client *client,
+                       const struct i2c_device_id *id)
 {
        struct rtc_device *rtc;
 
        return 0;
 }
 
-static int __devexit rx8581_remove(struct i2c_client *client)
+static int rx8581_remove(struct i2c_client *client)
 {
        struct rtc_device *rtc = i2c_get_clientdata(client);
 
                .owner  = THIS_MODULE,
        },
        .probe          = rx8581_probe,
-       .remove         = __devexit_p(rx8581_remove),
+       .remove         = rx8581_remove,
        .id_table       = rx8581_id,
 };
 
 
        clk_disable(rtc_clk);
 }
 
-static int __devexit s3c_rtc_remove(struct platform_device *dev)
+static int s3c_rtc_remove(struct platform_device *dev)
 {
        struct rtc_device *rtc = platform_get_drvdata(dev);
 
        return platform_get_device_id(pdev)->driver_data;
 }
 
-static int __devinit s3c_rtc_probe(struct platform_device *pdev)
+static int s3c_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        struct rtc_time rtc_tm;
 
 static struct platform_driver s3c_rtc_driver = {
        .probe          = s3c_rtc_probe,
-       .remove         = __devexit_p(s3c_rtc_remove),
+       .remove         = s3c_rtc_remove,
        .suspend        = s3c_rtc_suspend,
        .resume         = s3c_rtc_resume,
        .id_table       = s3c_rtc_driver_ids,
 
        return events ? IRQ_HANDLED : IRQ_NONE;
 }
 
-static int __devinit snvs_rtc_probe(struct platform_device *pdev)
+static int snvs_rtc_probe(struct platform_device *pdev)
 {
        struct snvs_rtc_data *data;
        struct resource *res;
        return 0;
 }
 
-static int __devexit snvs_rtc_remove(struct platform_device *pdev)
+static int snvs_rtc_remove(struct platform_device *pdev)
 {
        struct snvs_rtc_data *data = platform_get_drvdata(pdev);
 
 
 static SIMPLE_DEV_PM_OPS(snvs_rtc_pm_ops, snvs_rtc_suspend, snvs_rtc_resume);
 
-static const struct of_device_id __devinitconst snvs_dt_ids[] = {
+static const struct of_device_id snvs_dt_ids[] = {
        { .compatible = "fsl,sec-v4.0-mon-rtc-lp", },
        { /* sentinel */ }
 };
                .of_match_table = snvs_dt_ids,
        },
        .probe          = snvs_rtc_probe,
-       .remove         = __devexit_p(snvs_rtc_remove),
+       .remove         = snvs_rtc_remove,
 };
 module_platform_driver(snvs_rtc_driver);
 
 
        .alarm_irq_enable = spear_alarm_irq_enable,
 };
 
-static int __devinit spear_rtc_probe(struct platform_device *pdev)
+static int spear_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct spear_rtc_config *config;
        return status;
 }
 
-static int __devexit spear_rtc_remove(struct platform_device *pdev)
+static int spear_rtc_remove(struct platform_device *pdev)
 {
        struct spear_rtc_config *config = platform_get_drvdata(pdev);
 
 
 static struct platform_driver spear_rtc_driver = {
        .probe = spear_rtc_probe,
-       .remove = __devexit_p(spear_rtc_remove),
+       .remove = spear_rtc_remove,
        .suspend = spear_rtc_suspend,
        .resume = spear_rtc_resume,
        .shutdown = spear_rtc_shutdown,
 
        .write = stk17ta8_nvram_write,
 };
 
-static int __devinit stk17ta8_rtc_probe(struct platform_device *pdev)
+static int stk17ta8_rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        unsigned int cal;
        return ret;
 }
 
-static int __devexit stk17ta8_rtc_remove(struct platform_device *pdev)
+static int stk17ta8_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
 
 static struct platform_driver stk17ta8_rtc_driver = {
        .probe          = stk17ta8_rtc_probe,
-       .remove         = __devexit_p(stk17ta8_rtc_remove),
+       .remove         = stk17ta8_rtc_remove,
        .driver         = {
                .name   = "stk17ta8",
                .owner  = THIS_MODULE,
 
        .alarm_irq_enable = tegra_rtc_alarm_irq_enable,
 };
 
-static int __devinit tegra_rtc_probe(struct platform_device *pdev)
+static int tegra_rtc_probe(struct platform_device *pdev)
 {
        struct tegra_rtc_info *info;
        struct resource *res;
        return ret;
 }
 
-static int __devexit tegra_rtc_remove(struct platform_device *pdev)
+static int tegra_rtc_remove(struct platform_device *pdev)
 {
        struct tegra_rtc_info *info = platform_get_drvdata(pdev);
 
 
 MODULE_ALIAS("platform:tegra_rtc");
 static struct platform_driver tegra_rtc_driver = {
-       .remove         = __devexit_p(tegra_rtc_remove),
+       .remove         = tegra_rtc_remove,
        .shutdown       = tegra_rtc_shutdown,
        .driver         = {
                .name   = "tegra_rtc",
 
        return err;
 }
 
-static int __devexit test_remove(struct platform_device *plat_dev)
+static int test_remove(struct platform_device *plat_dev)
 {
        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
 
 
 static struct platform_driver test_driver = {
        .probe  = test_probe,
-       .remove = __devexit_p(test_remove),
+       .remove = test_remove,
        .driver = {
                .name = "rtc-test",
                .owner = THIS_MODULE,
 
 /*
  * Device probe routine.
  */
-static int __devinit tile_rtc_probe(struct platform_device *dev)
+static int tile_rtc_probe(struct platform_device *dev)
 {
        struct rtc_device *rtc;
 
 /*
  * Device cleanup routine.
  */
-static int __devexit tile_rtc_remove(struct platform_device *dev)
+static int tile_rtc_remove(struct platform_device *dev)
 {
        struct rtc_device *rtc = platform_get_drvdata(dev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = tile_rtc_probe,
-       .remove         = __devexit_p(tile_rtc_remove),
+       .remove         = tile_rtc_remove,
 };
 
 /*
 
        .alarm_irq_enable = tps65910_rtc_alarm_irq_enable,
 };
 
-static int __devinit tps65910_rtc_probe(struct platform_device *pdev)
+static int tps65910_rtc_probe(struct platform_device *pdev)
 {
        struct tps65910 *tps65910 = NULL;
        struct tps65910_rtc *tps_rtc = NULL;
  * Disable tps65910 RTC interrupts.
  * Sets status flag to free.
  */
-static int __devexit tps65910_rtc_remove(struct platform_device *pdev)
+static int tps65910_rtc_remove(struct platform_device *pdev)
 {
        /* leave rtc running, but disable irqs */
        struct tps65910_rtc *tps_rtc = platform_get_drvdata(pdev);
 
 static struct platform_driver tps65910_rtc_driver = {
        .probe          = tps65910_rtc_probe,
-       .remove         = __devexit_p(tps65910_rtc_remove),
+       .remove         = tps65910_rtc_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "tps65910-rtc",
 
 
 /*----------------------------------------------------------------------*/
 
-static int __devinit twl_rtc_probe(struct platform_device *pdev)
+static int twl_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
        int ret = -EINVAL;
  * Disable all TWL RTC module interrupts.
  * Sets status flag to free.
  */
-static int __devexit twl_rtc_remove(struct platform_device *pdev)
+static int twl_rtc_remove(struct platform_device *pdev)
 {
        /* leave rtc running, but disable irqs */
        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
 static struct platform_driver twl4030rtc_driver = {
        .probe          = twl_rtc_probe,
-       .remove         = __devexit_p(twl_rtc_remove),
+       .remove         = twl_rtc_remove,
        .shutdown       = twl_rtc_shutdown,
        .suspend        = twl_rtc_suspend,
        .resume         = twl_rtc_resume,
 
        .set_alarm      = vr41xx_rtc_set_alarm,
 };
 
-static int __devinit rtc_probe(struct platform_device *pdev)
+static int rtc_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct rtc_device *rtc;
        return retval;
 }
 
-static int __devexit rtc_remove(struct platform_device *pdev)
+static int rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
 
 
 static struct platform_driver rtc_platform_driver = {
        .probe          = rtc_probe,
-       .remove         = __devexit_p(rtc_remove),
+       .remove         = rtc_remove,
        .driver         = {
                .name   = rtc_name,
                .owner  = THIS_MODULE,
 
        .alarm_irq_enable = vt8500_alarm_irq_enable,
 };
 
-static int __devinit vt8500_rtc_probe(struct platform_device *pdev)
+static int vt8500_rtc_probe(struct platform_device *pdev)
 {
        struct vt8500_rtc *vt8500_rtc;
        int ret;
        return ret;
 }
 
-static int __devexit vt8500_rtc_remove(struct platform_device *pdev)
+static int vt8500_rtc_remove(struct platform_device *pdev)
 {
        struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
 
 
 static struct platform_driver vt8500_rtc_driver = {
        .probe          = vt8500_rtc_probe,
-       .remove         = __devexit_p(vt8500_rtc_remove),
+       .remove         = vt8500_rtc_remove,
        .driver         = {
                .name   = "vt8500-rtc",
                .owner  = THIS_MODULE,
 
        return ret;
 }
 
-static int __devexit wm831x_rtc_remove(struct platform_device *pdev)
+static int wm831x_rtc_remove(struct platform_device *pdev)
 {
        struct wm831x_rtc *wm831x_rtc = platform_get_drvdata(pdev);
        int alm_irq = platform_get_irq_byname(pdev, "ALM");
 
 static struct platform_driver wm831x_rtc_driver = {
        .probe = wm831x_rtc_probe,
-       .remove = __devexit_p(wm831x_rtc_remove),
+       .remove = wm831x_rtc_remove,
        .driver = {
                .name = "wm831x-rtc",
                .pm = &wm831x_rtc_pm_ops,
 
        return 0;
 }
 
-static int __devexit wm8350_rtc_remove(struct platform_device *pdev)
+static int wm8350_rtc_remove(struct platform_device *pdev)
 {
        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
        struct wm8350_rtc *wm_rtc = &wm8350->rtc;
 
 static struct platform_driver wm8350_rtc_driver = {
        .probe = wm8350_rtc_probe,
-       .remove = __devexit_p(wm8350_rtc_remove),
+       .remove = wm8350_rtc_remove,
        .driver = {
                .name = "wm8350-rtc",
                .pm = &wm8350_rtc_pm_ops,