return err;
 }
 
-static int __devinit atmel_aes_probe(struct platform_device *pdev)
+static int atmel_aes_probe(struct platform_device *pdev)
 {
        struct atmel_aes_dev *aes_dd;
        struct aes_platform_data        *pdata;
        return err;
 }
 
-static int __devexit atmel_aes_remove(struct platform_device *pdev)
+static int atmel_aes_remove(struct platform_device *pdev)
 {
        static struct atmel_aes_dev *aes_dd;
 
 
 static struct platform_driver atmel_aes_driver = {
        .probe          = atmel_aes_probe,
-       .remove         = __devexit_p(atmel_aes_remove),
+       .remove         = atmel_aes_remove,
        .driver         = {
                .name   = "atmel_aes",
                .owner  = THIS_MODULE,
 
        return err;
 }
 
-static int __devinit atmel_sha_probe(struct platform_device *pdev)
+static int atmel_sha_probe(struct platform_device *pdev)
 {
        struct atmel_sha_dev *sha_dd;
        struct device *dev = &pdev->dev;
        return err;
 }
 
-static int __devexit atmel_sha_remove(struct platform_device *pdev)
+static int atmel_sha_remove(struct platform_device *pdev)
 {
        static struct atmel_sha_dev *sha_dd;
 
 
 static struct platform_driver atmel_sha_driver = {
        .probe          = atmel_sha_probe,
-       .remove         = __devexit_p(atmel_sha_remove),
+       .remove         = atmel_sha_remove,
        .driver         = {
                .name   = "atmel_sha",
                .owner  = THIS_MODULE,
 
        return err;
 }
 
-static int __devinit atmel_tdes_probe(struct platform_device *pdev)
+static int atmel_tdes_probe(struct platform_device *pdev)
 {
        struct atmel_tdes_dev *tdes_dd;
        struct device *dev = &pdev->dev;
        return err;
 }
 
-static int __devexit atmel_tdes_remove(struct platform_device *pdev)
+static int atmel_tdes_remove(struct platform_device *pdev)
 {
        static struct atmel_tdes_dev *tdes_dd;
 
 
 static struct platform_driver atmel_tdes_driver = {
        .probe          = atmel_tdes_probe,
-       .remove         = __devexit_p(atmel_tdes_remove),
+       .remove         = atmel_tdes_remove,
        .driver         = {
                .name   = "atmel_tdes",
                .owner  = THIS_MODULE,
 
  *     bfin_crypto_crc_probe - Initialize module
  *
  */
-static int __devinit bfin_crypto_crc_probe(struct platform_device *pdev)
+static int bfin_crypto_crc_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct resource *res;
  *     bfin_crypto_crc_remove - Initialize module
  *
  */
-static int __devexit bfin_crypto_crc_remove(struct platform_device *pdev)
+static int bfin_crypto_crc_remove(struct platform_device *pdev)
 {
        struct bfin_crypto_crc *crc = platform_get_drvdata(pdev);
 
 
 static struct platform_driver bfin_crypto_crc_driver = {
        .probe     = bfin_crypto_crc_probe,
-       .remove    = __devexit_p(bfin_crypto_crc_remove),
+       .remove    = bfin_crypto_crc_remove,
        .suspend   = bfin_crypto_crc_suspend,
        .resume    = bfin_crypto_crc_resume,
        .driver    = {
 
                .of_match_table = caam_match,
        },
        .probe       = caam_probe,
-       .remove      = __devexit_p(caam_remove),
+       .remove      = caam_remove,
 };
 
 module_platform_driver(caam_driver);
 
        }
 };
 
-static void __devexit
-geode_aes_remove(struct pci_dev *dev)
+static void geode_aes_remove(struct pci_dev *dev)
 {
        crypto_unregister_alg(&geode_alg);
        crypto_unregister_alg(&geode_ecb_alg);
 }
 
 
-static int __devinit
-geode_aes_probe(struct pci_dev *dev, const struct pci_device_id *id)
+static int geode_aes_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
        int ret;
        ret = pci_enable_device(dev);
        .name = "Geode LX AES",
        .id_table = geode_aes_tbl,
        .probe = geode_aes_probe,
-       .remove = __devexit_p(geode_aes_remove)
+       .remove = geode_aes_remove,
 };
 
 module_pci_driver(geode_aes_driver);
 
                hifn_process_queue(dev);
 }
 
-static int __devinit hifn_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+static int hifn_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        int err, i;
        struct hifn_device *dev;
        return err;
 }
 
-static void __devexit hifn_remove(struct pci_dev *pdev)
+static void hifn_remove(struct pci_dev *pdev)
 {
        int i;
        struct hifn_device *dev;
        .name     = "hifn795x",
        .id_table = hifn_pci_tbl,
        .probe    = hifn_probe,
-       .remove   = __devexit_p(hifn_remove),
+       .remove   = hifn_remove,
 };
 
 static int __init hifn_init(void)
 
 
 static struct platform_driver marvell_crypto = {
        .probe          = mv_probe,
-       .remove         = __devexit_p(mv_remove),
+       .remove         = mv_remove,
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "mv_crypto",
 
 #define DRV_MODULE_VERSION     "0.2"
 #define DRV_MODULE_RELDATE     "July 28, 2011"
 
-static char version[] __devinitdata =
+static char version[] =
        DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 
 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
        return 0;
 }
 
-static int __devinit __n2_register_one_cipher(const struct n2_cipher_tmpl *tmpl)
+static int __n2_register_one_cipher(const struct n2_cipher_tmpl *tmpl)
 {
        struct n2_cipher_alg *p = kzalloc(sizeof(*p), GFP_KERNEL);
        struct crypto_alg *alg;
        return err;
 }
 
-static int __devinit __n2_register_one_hmac(struct n2_ahash_alg *n2ahash)
+static int __n2_register_one_hmac(struct n2_ahash_alg *n2ahash)
 {
        struct n2_hmac_alg *p = kzalloc(sizeof(*p), GFP_KERNEL);
        struct ahash_alg *ahash;
        return err;
 }
 
-static int __devinit __n2_register_one_ahash(const struct n2_hash_tmpl *tmpl)
+static int __n2_register_one_ahash(const struct n2_hash_tmpl *tmpl)
 {
        struct n2_ahash_alg *p = kzalloc(sizeof(*p), GFP_KERNEL);
        struct hash_alg_common *halg;
        return err;
 }
 
-static int __devinit n2_register_algs(void)
+static int n2_register_algs(void)
 {
        int i, err = 0;
 
        return err;
 }
 
-static void __devexit n2_unregister_algs(void)
+static void n2_unregister_algs(void)
 {
        mutex_lock(&spu_lock);
        if (!--algs_registered)
        return err;
 }
 
-static int __devinit get_irq_props(struct mdesc_handle *mdesc, u64 node,
-                                  struct spu_mdesc_info *ip)
+static int get_irq_props(struct mdesc_handle *mdesc, u64 node,
+                        struct spu_mdesc_info *ip)
 {
        const u64 *ino;
        int ino_len;
        return 0;
 }
 
-static int __devinit grab_mdesc_irq_props(struct mdesc_handle *mdesc,
-                                         struct platform_device *dev,
-                                         struct spu_mdesc_info *ip,
-                                         const char *node_name)
+static int grab_mdesc_irq_props(struct mdesc_handle *mdesc,
+                               struct platform_device *dev,
+                               struct spu_mdesc_info *ip,
+                               const char *node_name)
 {
        const unsigned int *reg;
        u64 node;
 static unsigned long n2_spu_hvapi_major;
 static unsigned long n2_spu_hvapi_minor;
 
-static int __devinit n2_spu_hvapi_register(void)
+static int n2_spu_hvapi_register(void)
 {
        int err;
 
 
 static int global_ref;
 
-static int __devinit grab_global_resources(void)
+static int grab_global_resources(void)
 {
        int err = 0;
 
        mutex_unlock(&spu_lock);
 }
 
-static struct n2_crypto * __devinit alloc_n2cp(void)
+static struct n2_crypto *alloc_n2cp(void)
 {
        struct n2_crypto *np = kzalloc(sizeof(struct n2_crypto), GFP_KERNEL);
 
        kfree(np);
 }
 
-static void __devinit n2_spu_driver_version(void)
+static void n2_spu_driver_version(void)
 {
        static int n2_spu_version_printed;
 
                pr_info("%s", version);
 }
 
-static int __devinit n2_crypto_probe(struct platform_device *dev)
+static int n2_crypto_probe(struct platform_device *dev)
 {
        struct mdesc_handle *mdesc;
        const char *full_name;
        return err;
 }
 
-static int __devexit n2_crypto_remove(struct platform_device *dev)
+static int n2_crypto_remove(struct platform_device *dev)
 {
        struct n2_crypto *np = dev_get_drvdata(&dev->dev);
 
        return 0;
 }
 
-static struct n2_mau * __devinit alloc_ncp(void)
+static struct n2_mau *alloc_ncp(void)
 {
        struct n2_mau *mp = kzalloc(sizeof(struct n2_mau), GFP_KERNEL);
 
        kfree(mp);
 }
 
-static int __devinit n2_mau_probe(struct platform_device *dev)
+static int n2_mau_probe(struct platform_device *dev)
 {
        struct mdesc_handle *mdesc;
        const char *full_name;
        return err;
 }
 
-static int __devexit n2_mau_remove(struct platform_device *dev)
+static int n2_mau_remove(struct platform_device *dev)
 {
        struct n2_mau *mp = dev_get_drvdata(&dev->dev);
 
                .of_match_table =       n2_crypto_match,
        },
        .probe          =       n2_crypto_probe,
-       .remove         =       __devexit_p(n2_crypto_remove),
+       .remove         =       n2_crypto_remove,
 };
 
 static struct of_device_id n2_mau_match[] = {
                .of_match_table =       n2_mau_match,
        },
        .probe          =       n2_mau_probe,
-       .remove         =       __devexit_p(n2_mau_remove),
+       .remove         =       n2_mau_remove,
 };
 
 static int __init n2_init(void)
 
        nx_ctx->out_sg = NULL;
 }
 
-static int __devinit nx_probe(struct vio_dev *viodev,
-                             const struct vio_device_id *id)
+static int nx_probe(struct vio_dev *viodev, const struct vio_device_id *id)
 {
        dev_dbg(&viodev->dev, "driver probed: %s resource id: 0x%x\n",
                viodev->name, viodev->resource_id);
        return nx_register_algs();
 }
 
-static int __devexit nx_remove(struct vio_dev *viodev)
+static int nx_remove(struct vio_dev *viodev)
 {
        dev_dbg(&viodev->dev, "entering nx_remove for UA 0x%x\n",
                viodev->unit_address);
        vio_unregister_driver(&nx_driver.viodriver);
 }
 
-static struct vio_device_id nx_crypto_driver_ids[] __devinitdata = {
+static struct vio_device_id nx_crypto_driver_ids[] = {
        { "ibm,sym-encryption-v1", "ibm,sym-encryption" },
        { "", "" }
 };
 
        }
 }
 
-static int __devinit omap_sham_probe(struct platform_device *pdev)
+static int omap_sham_probe(struct platform_device *pdev)
 {
        struct omap_sham_dev *dd;
        struct device *dev = &pdev->dev;
        return err;
 }
 
-static int __devexit omap_sham_remove(struct platform_device *pdev)
+static int omap_sham_remove(struct platform_device *pdev)
 {
        static struct omap_sham_dev *dd;
        int i;
 
        return false;
 }
 
-static int __devinit spacc_probe(struct platform_device *pdev)
+static int spacc_probe(struct platform_device *pdev)
 {
        int i, err, ret = -EINVAL;
        struct resource *mem, *irq;
        return ret;
 }
 
-static int __devexit spacc_remove(struct platform_device *pdev)
+static int spacc_remove(struct platform_device *pdev)
 {
        struct spacc_alg *alg, *next;
        struct spacc_engine *engine = platform_get_drvdata(pdev);
 
 static struct platform_driver spacc_driver = {
        .probe          = spacc_probe,
-       .remove         = __devexit_p(spacc_remove),
+       .remove         = spacc_remove,
        .driver         = {
                .name   = "picochip,spacc",
 #ifdef CONFIG_PM
 
        return err;
 }
 
-static int __devexit tegra_aes_remove(struct platform_device *pdev)
+static int tegra_aes_remove(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct tegra_aes_dev *dd = platform_get_drvdata(pdev);
        return 0;
 }
 
-static struct of_device_id tegra_aes_of_match[] __devinitdata = {
+static struct of_device_id tegra_aes_of_match[] = {
        { .compatible = "nvidia,tegra20-aes", },
        { .compatible = "nvidia,tegra30-aes", },
        { },
 
 static struct platform_driver tegra_aes_driver = {
        .probe  = tegra_aes_probe,
-       .remove = __devexit_p(tegra_aes_remove),
+       .remove = tegra_aes_remove,
        .driver = {
                .name   = "tegra-aes",
                .owner  = THIS_MODULE,