AHCI_SHT("ahci_platform"),
 };
 
-static int __devinit ahci_probe(struct platform_device *pdev)
+static int ahci_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct ahci_platform_data *pdata = dev_get_platdata(dev);
 
  *     they are found return an error code so we can turn off DMA
  */
 
-static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
+static int piix_check_450nx_errata(struct pci_dev *ata_dev)
 {
        struct pci_dev *pdev = NULL;
        u16 cfg;
        return no_piix_dma;
 }
 
-static void __devinit piix_init_pcs(struct ata_host *host,
-                                   const struct piix_map_db *map_db)
+static void piix_init_pcs(struct ata_host *host,
+                         const struct piix_map_db *map_db)
 {
        struct pci_dev *pdev = to_pci_dev(host->dev);
        u16 pcs, new_pcs;
        }
 }
 
-static const int *__devinit piix_init_sata_map(struct pci_dev *pdev,
-                                              struct ata_port_info *pinfo,
-                                              const struct piix_map_db *map_db)
+static const int *piix_init_sata_map(struct pci_dev *pdev,
+                                    struct ata_port_info *pinfo,
+                                    const struct piix_map_db *map_db)
 {
        const int *map;
        int i, invalid_map = 0;
        return false;
 }
 
-static int __devinit piix_init_sidpr(struct ata_host *host)
+static int piix_init_sidpr(struct ata_host *host)
 {
        struct pci_dev *pdev = to_pci_dev(host->dev);
        struct piix_host_priv *hpriv = host->private_data;
  *     Zero on success, or -ERRNO value.
  */
 
-static int __devinit piix_init_one(struct pci_dev *pdev,
-                                  const struct pci_device_id *ent)
+static int piix_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
        struct device *dev = &pdev->dev;
        struct ata_port_info port_info[2];
 
        .set_dmamode = arasan_cf_set_dmamode,
 };
 
-static int __devinit arasan_cf_probe(struct platform_device *pdev)
+static int arasan_cf_probe(struct platform_device *pdev)
 {
        struct arasan_cf_dev *acdev;
        struct arasan_cf_pdata *pdata = dev_get_platdata(&pdev->dev);
        return ret;
 }
 
-static int __devexit arasan_cf_remove(struct platform_device *pdev)
+static int arasan_cf_remove(struct platform_device *pdev)
 {
        struct ata_host *host = dev_get_drvdata(&pdev->dev);
        struct arasan_cf_dev *acdev = host->ports[0]->private_data;
 
 static struct platform_driver arasan_cf_driver = {
        .probe          = arasan_cf_probe,
-       .remove         = __devexit_p(arasan_cf_remove),
+       .remove         = arasan_cf_remove,
        .driver         = {
                .name   = DRIVER_NAME,
                .owner  = THIS_MODULE,
 
        .cable_detect   = ata_cable_40wire,
 };
 
-static int __devinit pata_at91_probe(struct platform_device *pdev)
+static int pata_at91_probe(struct platform_device *pdev)
 {
        struct at91_cf_data *board = pdev->dev.platform_data;
        struct device *dev = &pdev->dev;
        return ret;
 }
 
-static int __devexit pata_at91_remove(struct platform_device *pdev)
+static int pata_at91_remove(struct platform_device *pdev)
 {
        struct ata_host *host = dev_get_drvdata(&pdev->dev);
        struct at91_ide_info *info;
 
 static struct platform_driver pata_at91_driver = {
        .probe          = pata_at91_probe,
-       .remove         = __devexit_p(pata_at91_remove),
+       .remove         = pata_at91_remove,
        .driver         = {
                .name           = DRV_NAME,
                .owner          = THIS_MODULE,
 
  *             - IRQ      (IORESOURCE_IRQ)
  *
  */
-static int __devinit bfin_atapi_probe(struct platform_device *pdev)
+static int bfin_atapi_probe(struct platform_device *pdev)
 {
        int board_idx = 0;
        struct resource *res;
  *     A bfin atapi device has been unplugged. Perform the needed
  *     cleanup. Also called on module unload for any active devices.
  */
-static int __devexit bfin_atapi_remove(struct platform_device *pdev)
+static int bfin_atapi_remove(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct ata_host *host = dev_get_drvdata(dev);
 
 static struct platform_driver bfin_atapi_driver = {
        .probe                  = bfin_atapi_probe,
-       .remove                 = __devexit_p(bfin_atapi_remove),
+       .remove                 = bfin_atapi_remove,
        .suspend                = bfin_atapi_suspend,
        .resume                 = bfin_atapi_resume,
        .driver = {
 
        .set_piomode            = cs5520_set_piomode,
 };
 
-static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
+static int cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const unsigned int cmd_port[] = { 0x1F0, 0x170 };
        static const unsigned int ctl_port[] = { 0x3F6, 0x376 };
 
        .port_start             = ep93xx_pata_port_start,
 };
 
-static int __devinit ep93xx_pata_probe(struct platform_device *pdev)
+static int ep93xx_pata_probe(struct platform_device *pdev)
 {
        struct ep93xx_pata_data *drv_data;
        struct ata_host *host;
        return err;
 }
 
-static int __devexit ep93xx_pata_remove(struct platform_device *pdev)
+static int ep93xx_pata_remove(struct platform_device *pdev)
 {
        struct ata_host *host = platform_get_drvdata(pdev);
        struct ep93xx_pata_data *drv_data = host->private_data;
                .owner = THIS_MODULE,
        },
        .probe = ep93xx_pata_probe,
-       .remove = __devexit_p(ep93xx_pata_remove),
+       .remove = ep93xx_pata_remove,
 };
 
 module_platform_driver(ep93xx_pata_platform_driver);
 
        .port_start             = ATA_OP_NULL,  /* don't need PRD table */
 };
 
-static void __devinit
-pata_icside_setup_ioaddr(struct ata_port *ap, void __iomem *base,
-                        struct pata_icside_info *info,
-                        const struct portinfo *port)
+static void pata_icside_setup_ioaddr(struct ata_port *ap, void __iomem *base,
+                                    struct pata_icside_info *info,
+                                    const struct portinfo *port)
 {
        struct ata_ioports *ioaddr = &ap->ioaddr;
        void __iomem *cmd = base + port->dataoffset;
                ata_port_desc(ap, "iocbase 0x%lx", info->raw_ioc_base);
 }
 
-static int __devinit pata_icside_register_v5(struct pata_icside_info *info)
+static int pata_icside_register_v5(struct pata_icside_info *info)
 {
        struct pata_icside_state *state = info->state;
        void __iomem *base;
        return 0;
 }
 
-static int __devinit pata_icside_register_v6(struct pata_icside_info *info)
+static int pata_icside_register_v6(struct pata_icside_info *info)
 {
        struct pata_icside_state *state = info->state;
        struct expansion_card *ec = info->ec;
        return icside_dma_init(info);
 }
 
-static int __devinit pata_icside_add_ports(struct pata_icside_info *info)
+static int pata_icside_add_ports(struct pata_icside_info *info)
 {
        struct expansion_card *ec = info->ec;
        struct ata_host *host;
                                 &pata_icside_sht);
 }
 
-static int __devinit
-pata_icside_probe(struct expansion_card *ec, const struct ecard_id *id)
+static int pata_icside_probe(struct expansion_card *ec,
+                            const struct ecard_id *id)
 {
        struct pata_icside_state *state;
        struct pata_icside_info info;
        }
 }
 
-static void __devexit pata_icside_remove(struct expansion_card *ec)
+static void pata_icside_remove(struct expansion_card *ec)
 {
        struct ata_host *host = ecard_get_drvdata(ec);
        struct pata_icside_state *state = host->private_data;
 
 static struct ecard_driver pata_icside_driver = {
        .probe          = pata_icside_probe,
-       .remove         = __devexit_p(pata_icside_remove),
+       .remove         = pata_icside_remove,
        .shutdown       = pata_icside_shutdown,
        .id_table       = pata_icside_ids,
        .drv = {
 
        ioaddr->command_addr    = ioaddr->cmd_addr + (ATA_REG_CMD     << 2);
 }
 
-static int __devinit pata_imx_probe(struct platform_device *pdev)
+static int pata_imx_probe(struct platform_device *pdev)
 {
        struct ata_host *host;
        struct ata_port *ap;
        return -ENOMEM;
 }
 
-static int __devexit pata_imx_remove(struct platform_device *pdev)
+static int pata_imx_remove(struct platform_device *pdev)
 {
        struct ata_host *host = dev_get_drvdata(&pdev->dev);
        struct pata_imx_priv *priv = host->private_data;
 
 static struct platform_driver pata_imx_driver = {
        .probe          = pata_imx_probe,
-       .remove         = __devexit_p(pata_imx_remove),
+       .remove         = pata_imx_remove,
        .driver = {
                .name           = DRV_NAME,
                .owner          = THIS_MODULE,
 
        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", raw_cmd, raw_ctl);
 }
 
-static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
+static int ixp4xx_pata_probe(struct platform_device *pdev)
 {
        unsigned int irq;
        struct resource *cs0, *cs1;
 
        .sff_irq_clear          = pata_macio_irq_clear,
 };
 
-static void __devinit pata_macio_invariants(struct pata_macio_priv *priv)
+static void pata_macio_invariants(struct pata_macio_priv *priv)
 {
        const int *bidp;
 
                priv->aapl_bus_id = 1;
 }
 
-static void __devinit pata_macio_setup_ios(struct ata_ioports *ioaddr,
-                                          void __iomem * base,
-                                          void __iomem * dma)
+static void pata_macio_setup_ios(struct ata_ioports *ioaddr,
+                                void __iomem * base, void __iomem * dma)
 {
        /* cmd_addr is the base of regs for that port */
        ioaddr->cmd_addr        = base;
        ioaddr->bmdma_addr      = dma;
 }
 
-static void __devinit pmac_macio_calc_timing_masks(struct pata_macio_priv *priv,
-                                                  struct ata_port_info   *pinfo)
+static void pmac_macio_calc_timing_masks(struct pata_macio_priv *priv,
+                                        struct ata_port_info *pinfo)
 {
        int i = 0;
 
                pinfo->pio_mask, pinfo->mwdma_mask, pinfo->udma_mask);
 }
 
-static int __devinit pata_macio_common_init(struct pata_macio_priv     *priv,
-                                           resource_size_t             tfregs,
-                                           resource_size_t             dmaregs,
-                                           resource_size_t             fcregs,
-                                           unsigned long               irq)
+static int pata_macio_common_init(struct pata_macio_priv *priv,
+                                 resource_size_t tfregs,
+                                 resource_size_t dmaregs,
+                                 resource_size_t fcregs,
+                                 unsigned long irq)
 {
        struct ata_port_info            pinfo;
        const struct ata_port_info      *ppi[] = { &pinfo, NULL };
                                 &pata_macio_sht);
 }
 
-static int __devinit pata_macio_attach(struct macio_dev *mdev,
-                                      const struct of_device_id *match)
+static int pata_macio_attach(struct macio_dev *mdev,
+                            const struct of_device_id *match)
 {
        struct pata_macio_priv  *priv;
        resource_size_t         tfregs, dmaregs = 0;
        return rc;
 }
 
-static int __devexit pata_macio_detach(struct macio_dev *mdev)
+static int pata_macio_detach(struct macio_dev *mdev)
 {
        struct ata_host *host = macio_get_drvdata(mdev);
        struct pata_macio_priv *priv = host->private_data;
 #endif /* CONFIG_PMAC_MEDIABAY */
 
 
-static int __devinit pata_macio_pci_attach(struct pci_dev *pdev,
-                                          const struct pci_device_id *id)
+static int pata_macio_pci_attach(struct pci_dev *pdev,
+                                const struct pci_device_id *id)
 {
        struct pata_macio_priv  *priv;
        struct device_node      *np;
        return 0;
 }
 
-static void __devexit pata_macio_pci_detach(struct pci_dev *pdev)
+static void pata_macio_pci_detach(struct pci_dev *pdev)
 {
        struct ata_host *host = dev_get_drvdata(&pdev->dev);
 
 
        .qc_prep                = ata_noop_qc_prep,
 };
 
-static int __devinit
-mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv,
-                    unsigned long raw_ata_regs, int mwdma_mask, int udma_mask)
+static int mpc52xx_ata_init_one(struct device *dev,
+                               struct mpc52xx_ata_priv *priv,
+                               unsigned long raw_ata_regs,
+                               int mwdma_mask, int udma_mask)
 {
        struct ata_host *host;
        struct ata_port *ap;
 /* OF Platform driver                                                       */
 /* ======================================================================== */
 
-static int __devinit
-mpc52xx_ata_probe(struct platform_device *op)
+static int mpc52xx_ata_probe(struct platform_device *op)
 {
        unsigned int ipb_freq;
        struct resource res_mem;
 
        .dev_config             = octeon_cf_dev_config,
 };
 
-static int __devinit octeon_cf_probe(struct platform_device *pdev)
+static int octeon_cf_probe(struct platform_device *pdev)
 {
        struct resource *res_cs0, *res_cs1;
 
 
 #include <linux/ata_platform.h>
 #include <linux/libata.h>
 
-static int __devinit pata_of_platform_probe(struct platform_device *ofdev)
+static int pata_of_platform_probe(struct platform_device *ofdev)
 {
        int ret;
        struct device_node *dn = ofdev->dev.of_node;
 
        .cable_detect           = ata_cable_40wire,
 };
 
-static __devinit int palmld_pata_probe(struct platform_device *pdev)
+static int palmld_pata_probe(struct platform_device *pdev)
 {
        struct ata_host *host;
        struct ata_port *ap;
        return ret;
 }
 
-static __devexit int palmld_pata_remove(struct platform_device *dev)
+static int palmld_pata_remove(struct platform_device *dev)
 {
        ata_platform_remove_one(dev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = palmld_pata_probe,
-       .remove         = __devexit_p(palmld_pata_remove),
+       .remove         = palmld_pata_remove,
 };
 
 module_platform_driver(palmld_pata_platform_driver);
 
  * @pdev: instance of pci_dev found
  * @ent:  matching entry in the id_tbl[]
  */
-static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int pdc2027x_init_one(struct pci_dev *pdev,
+                            const struct pci_device_id *ent)
 {
        static const unsigned long cmd_offset[] = { 0x17c0, 0x15c0 };
        static const unsigned long bmdma_offset[] = { 0x1000, 0x1008 };
 
  *
  *     If no IRQ resource is present, PIO polling mode is used instead.
  */
-int __devinit __pata_platform_probe(struct device *dev,
-                                   struct resource *io_res,
-                                   struct resource *ctl_res,
-                                   struct resource *irq_res,
-                                   unsigned int ioport_shift,
-                                   int __pio_mask)
+int __pata_platform_probe(struct device *dev, struct resource *io_res,
+                         struct resource *ctl_res, struct resource *irq_res,
+                         unsigned int ioport_shift, int __pio_mask)
 {
        struct ata_host *host;
        struct ata_port *ap;
 }
 EXPORT_SYMBOL_GPL(__pata_platform_probe);
 
-static int __devinit pata_platform_probe(struct platform_device *pdev)
+static int pata_platform_probe(struct platform_device *pdev)
 {
        struct resource *io_res;
        struct resource *ctl_res;
 
                complete(&pd->dma_done);
 }
 
-static int __devinit pxa_ata_probe(struct platform_device *pdev)
+static int pxa_ata_probe(struct platform_device *pdev)
 {
        struct ata_host *host;
        struct ata_port *ap;
        return ret;
 }
 
-static int __devexit pxa_ata_remove(struct platform_device *pdev)
+static int pxa_ata_remove(struct platform_device *pdev)
 {
        struct ata_host *host = dev_get_drvdata(&pdev->dev);
        struct pata_pxa_data *data = host->ports[0]->private_data;
 
 static struct platform_driver pxa_ata_driver = {
        .probe          = pxa_ata_probe,
-       .remove         = __devexit_p(pxa_ata_remove),
+       .remove         = pxa_ata_remove,
        .driver         = {
                .name           = DRV_NAME,
                .owner          = THIS_MODULE,
 
        ap->ioaddr.error_addr   = info->iobase + RB500_CF_REG_ERR;
 }
 
-static __devinit int rb532_pata_driver_probe(struct platform_device *pdev)
+static int rb532_pata_driver_probe(struct platform_device *pdev)
 {
        int irq;
        int gpio;
        return ret;
 }
 
-static __devexit int rb532_pata_driver_remove(struct platform_device *pdev)
+static int rb532_pata_driver_remove(struct platform_device *pdev)
 {
        struct ata_host *ah = platform_get_drvdata(pdev);
        struct rb532_cf_info *info = ah->private_data;
 
 static struct platform_driver rb532_pata_platform_driver = {
        .probe          = rb532_pata_driver_probe,
-       .remove         = __devexit_p(rb532_pata_driver_remove),
+       .remove         = rb532_pata_driver_remove,
        .driver  = {
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,
 
  *     Zero on success, or -ERRNO value.
  */
 
-static int __devinit rdc_init_one(struct pci_dev *pdev,
-                                  const struct pci_device_id *ent)
+static int rdc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
        struct device *dev = &pdev->dev;
        struct ata_port_info port_info[2];
 
  *     Zero on success, or -ERRNO value.
  */
 
-static int __devinit sch_init_one(struct pci_dev *pdev,
-                                  const struct pci_device_id *ent)
+static int sch_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
        const struct ata_port_info *ppi[] = { &sch_port_info, NULL };
 
 
        return tmpbyte & 0x30;
 }
 
-static int __devinit sil680_init_one(struct pci_dev *pdev,
-                                    const struct pci_device_id *id)
+static int sil680_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
        static const struct ata_port_info info = {
                .flags = ATA_FLAG_SLAVE_POSS,
 
 };
 MODULE_DEVICE_TABLE(of, ahci_of_match);
 
-static int __devinit ahci_highbank_probe(struct platform_device *pdev)
+static int ahci_highbank_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct ahci_host_priv *hpriv;
 
  *      A platform bus SATA device has been unplugged. Perform the needed
  *      cleanup. Also called on module unload for any active devices.
  */
-static int __devexit mv_platform_remove(struct platform_device *pdev)
+static int mv_platform_remove(struct platform_device *pdev)
 {
        struct ata_host *host = platform_get_drvdata(pdev);
 #if defined(CONFIG_HAVE_CLK)
 #endif
 
 #ifdef CONFIG_OF
-static struct of_device_id mv_sata_dt_ids[] __devinitdata = {
+static struct of_device_id mv_sata_dt_ids[] = {
        { .compatible = "marvell,orion-sata", },
        {},
 };
 
 static struct platform_driver mv_platform_driver = {
        .probe          = mv_platform_probe,
-       .remove         = __devexit_p(mv_platform_remove),
+       .remove         = mv_platform_remove,
        .suspend        = mv_platform_suspend,
        .resume         = mv_platform_resume,
        .driver         = {
 #endif
 
 static int mv_platform_probe(struct platform_device *pdev);
-static int __devexit mv_platform_remove(struct platform_device *pdev);
+static int mv_platform_remove(struct platform_device *pdev);
 
 static int __init mv_init(void)
 {
 
        .scr_write              = vsc_sata_scr_write,
 };
 
-static void __devinit vsc_sata_setup_port(struct ata_ioports *port,
-                                         void __iomem *base)
+static void vsc_sata_setup_port(struct ata_ioports *port, void __iomem *base)
 {
        port->cmd_addr          = base + VSC_SATA_TF_CMD_OFFSET;
        port->data_addr         = base + VSC_SATA_TF_DATA_OFFSET;
 }
 
 
-static int __devinit vsc_sata_init_one(struct pci_dev *pdev,
-                                      const struct pci_device_id *ent)
+static int vsc_sata_init_one(struct pci_dev *pdev,
+                            const struct pci_device_id *ent)
 {
        static const struct ata_port_info pi = {
                .flags          = ATA_FLAG_SATA,