tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Drivers: ata: remove __dev* attributes.

CONFIG_HOTPLUG is going away as an option. As a result, the __dev*
markings need to be removed.

This change removes the use of __devinit, __devexit_p, __devinitdata,
and __devexit from these drivers.

Based on patches originally written by Bill Pemberton, but redone by me
in order to handle some of the coding style issues better, by hand.

Cc: Bill Pemberton <wfp5p@virginia.edu>
Cc: Jeff Garzik <jgarzik@pobox.com>
Cc: Viresh Kumar <viresh.linux@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Greg Kroah-Hartman 0ec24914 d8929942

+85 -94
+1 -1
drivers/ata/ahci_platform.c
··· 86 86 AHCI_SHT("ahci_platform"), 87 87 }; 88 88 89 - static int __devinit ahci_probe(struct platform_device *pdev) 89 + static int ahci_probe(struct platform_device *pdev) 90 90 { 91 91 struct device *dev = &pdev->dev; 92 92 struct ahci_platform_data *pdata = dev_get_platdata(dev);
+8 -9
drivers/ata/ata_piix.c
··· 1270 1270 * they are found return an error code so we can turn off DMA 1271 1271 */ 1272 1272 1273 - static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev) 1273 + static int piix_check_450nx_errata(struct pci_dev *ata_dev) 1274 1274 { 1275 1275 struct pci_dev *pdev = NULL; 1276 1276 u16 cfg; ··· 1296 1296 return no_piix_dma; 1297 1297 } 1298 1298 1299 - static void __devinit piix_init_pcs(struct ata_host *host, 1300 - const struct piix_map_db *map_db) 1299 + static void piix_init_pcs(struct ata_host *host, 1300 + const struct piix_map_db *map_db) 1301 1301 { 1302 1302 struct pci_dev *pdev = to_pci_dev(host->dev); 1303 1303 u16 pcs, new_pcs; ··· 1313 1313 } 1314 1314 } 1315 1315 1316 - static const int *__devinit piix_init_sata_map(struct pci_dev *pdev, 1317 - struct ata_port_info *pinfo, 1318 - const struct piix_map_db *map_db) 1316 + static const int *piix_init_sata_map(struct pci_dev *pdev, 1317 + struct ata_port_info *pinfo, 1318 + const struct piix_map_db *map_db) 1319 1319 { 1320 1320 const int *map; 1321 1321 int i, invalid_map = 0; ··· 1392 1392 return false; 1393 1393 } 1394 1394 1395 - static int __devinit piix_init_sidpr(struct ata_host *host) 1395 + static int piix_init_sidpr(struct ata_host *host) 1396 1396 { 1397 1397 struct pci_dev *pdev = to_pci_dev(host->dev); 1398 1398 struct piix_host_priv *hpriv = host->private_data; ··· 1595 1595 * Zero on success, or -ERRNO value. 1596 1596 */ 1597 1597 1598 - static int __devinit piix_init_one(struct pci_dev *pdev, 1599 - const struct pci_device_id *ent) 1598 + static int piix_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 1600 1599 { 1601 1600 struct device *dev = &pdev->dev; 1602 1601 struct ata_port_info port_info[2];
+3 -3
drivers/ata/pata_arasan_cf.c
··· 791 791 .set_dmamode = arasan_cf_set_dmamode, 792 792 }; 793 793 794 - static int __devinit arasan_cf_probe(struct platform_device *pdev) 794 + static int arasan_cf_probe(struct platform_device *pdev) 795 795 { 796 796 struct arasan_cf_dev *acdev; 797 797 struct arasan_cf_pdata *pdata = dev_get_platdata(&pdev->dev); ··· 905 905 return ret; 906 906 } 907 907 908 - static int __devexit arasan_cf_remove(struct platform_device *pdev) 908 + static int arasan_cf_remove(struct platform_device *pdev) 909 909 { 910 910 struct ata_host *host = dev_get_drvdata(&pdev->dev); 911 911 struct arasan_cf_dev *acdev = host->ports[0]->private_data; ··· 955 955 956 956 static struct platform_driver arasan_cf_driver = { 957 957 .probe = arasan_cf_probe, 958 - .remove = __devexit_p(arasan_cf_remove), 958 + .remove = arasan_cf_remove, 959 959 .driver = { 960 960 .name = DRIVER_NAME, 961 961 .owner = THIS_MODULE,
+3 -3
drivers/ata/pata_at91.c
··· 313 313 .cable_detect = ata_cable_40wire, 314 314 }; 315 315 316 - static int __devinit pata_at91_probe(struct platform_device *pdev) 316 + static int pata_at91_probe(struct platform_device *pdev) 317 317 { 318 318 struct at91_cf_data *board = pdev->dev.platform_data; 319 319 struct device *dev = &pdev->dev; ··· 420 420 return ret; 421 421 } 422 422 423 - static int __devexit pata_at91_remove(struct platform_device *pdev) 423 + static int pata_at91_remove(struct platform_device *pdev) 424 424 { 425 425 struct ata_host *host = dev_get_drvdata(&pdev->dev); 426 426 struct at91_ide_info *info; ··· 441 441 442 442 static struct platform_driver pata_at91_driver = { 443 443 .probe = pata_at91_probe, 444 - .remove = __devexit_p(pata_at91_remove), 444 + .remove = pata_at91_remove, 445 445 .driver = { 446 446 .name = DRV_NAME, 447 447 .owner = THIS_MODULE,
+3 -3
drivers/ata/pata_bf54x.c
··· 1538 1538 * - IRQ (IORESOURCE_IRQ) 1539 1539 * 1540 1540 */ 1541 - static int __devinit bfin_atapi_probe(struct platform_device *pdev) 1541 + static int bfin_atapi_probe(struct platform_device *pdev) 1542 1542 { 1543 1543 int board_idx = 0; 1544 1544 struct resource *res; ··· 1608 1608 * A bfin atapi device has been unplugged. Perform the needed 1609 1609 * cleanup. Also called on module unload for any active devices. 1610 1610 */ 1611 - static int __devexit bfin_atapi_remove(struct platform_device *pdev) 1611 + static int bfin_atapi_remove(struct platform_device *pdev) 1612 1612 { 1613 1613 struct device *dev = &pdev->dev; 1614 1614 struct ata_host *host = dev_get_drvdata(dev); ··· 1654 1654 1655 1655 static struct platform_driver bfin_atapi_driver = { 1656 1656 .probe = bfin_atapi_probe, 1657 - .remove = __devexit_p(bfin_atapi_remove), 1657 + .remove = bfin_atapi_remove, 1658 1658 .suspend = bfin_atapi_suspend, 1659 1659 .resume = bfin_atapi_resume, 1660 1660 .driver = {
+1 -1
drivers/ata/pata_cs5520.c
··· 115 115 .set_piomode = cs5520_set_piomode, 116 116 }; 117 117 118 - static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id) 118 + static int cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id) 119 119 { 120 120 static const unsigned int cmd_port[] = { 0x1F0, 0x170 }; 121 121 static const unsigned int ctl_port[] = { 0x3F6, 0x376 };
+3 -3
drivers/ata/pata_ep93xx.c
··· 910 910 .port_start = ep93xx_pata_port_start, 911 911 }; 912 912 913 - static int __devinit ep93xx_pata_probe(struct platform_device *pdev) 913 + static int ep93xx_pata_probe(struct platform_device *pdev) 914 914 { 915 915 struct ep93xx_pata_data *drv_data; 916 916 struct ata_host *host; ··· 1011 1011 return err; 1012 1012 } 1013 1013 1014 - static int __devexit ep93xx_pata_remove(struct platform_device *pdev) 1014 + static int ep93xx_pata_remove(struct platform_device *pdev) 1015 1015 { 1016 1016 struct ata_host *host = platform_get_drvdata(pdev); 1017 1017 struct ep93xx_pata_data *drv_data = host->private_data; ··· 1029 1029 .owner = THIS_MODULE, 1030 1030 }, 1031 1031 .probe = ep93xx_pata_probe, 1032 - .remove = __devexit_p(ep93xx_pata_remove), 1032 + .remove = ep93xx_pata_remove, 1033 1033 }; 1034 1034 1035 1035 module_platform_driver(ep93xx_pata_platform_driver);
+10 -11
drivers/ata/pata_icside.c
··· 337 337 .port_start = ATA_OP_NULL, /* don't need PRD table */ 338 338 }; 339 339 340 - static void __devinit 341 - pata_icside_setup_ioaddr(struct ata_port *ap, void __iomem *base, 342 - struct pata_icside_info *info, 343 - const struct portinfo *port) 340 + static void pata_icside_setup_ioaddr(struct ata_port *ap, void __iomem *base, 341 + struct pata_icside_info *info, 342 + const struct portinfo *port) 344 343 { 345 344 struct ata_ioports *ioaddr = &ap->ioaddr; 346 345 void __iomem *cmd = base + port->dataoffset; ··· 367 368 ata_port_desc(ap, "iocbase 0x%lx", info->raw_ioc_base); 368 369 } 369 370 370 - static int __devinit pata_icside_register_v5(struct pata_icside_info *info) 371 + static int pata_icside_register_v5(struct pata_icside_info *info) 371 372 { 372 373 struct pata_icside_state *state = info->state; 373 374 void __iomem *base; ··· 390 391 return 0; 391 392 } 392 393 393 - static int __devinit pata_icside_register_v6(struct pata_icside_info *info) 394 + static int pata_icside_register_v6(struct pata_icside_info *info) 394 395 { 395 396 struct pata_icside_state *state = info->state; 396 397 struct expansion_card *ec = info->ec; ··· 433 434 return icside_dma_init(info); 434 435 } 435 436 436 - static int __devinit pata_icside_add_ports(struct pata_icside_info *info) 437 + static int pata_icside_add_ports(struct pata_icside_info *info) 437 438 { 438 439 struct expansion_card *ec = info->ec; 439 440 struct ata_host *host; ··· 473 474 &pata_icside_sht); 474 475 } 475 476 476 - static int __devinit 477 - pata_icside_probe(struct expansion_card *ec, const struct ecard_id *id) 477 + static int pata_icside_probe(struct expansion_card *ec, 478 + const struct ecard_id *id) 478 479 { 479 480 struct pata_icside_state *state; 480 481 struct pata_icside_info info; ··· 574 575 } 575 576 } 576 577 577 - static void __devexit pata_icside_remove(struct expansion_card *ec) 578 + static void pata_icside_remove(struct expansion_card *ec) 578 579 { 579 580 struct ata_host *host = ecard_get_drvdata(ec); 580 581 struct pata_icside_state *state = host->private_data; ··· 601 602 602 603 static struct ecard_driver pata_icside_driver = { 603 604 .probe = pata_icside_probe, 604 - .remove = __devexit_p(pata_icside_remove), 605 + .remove = pata_icside_remove, 605 606 .shutdown = pata_icside_shutdown, 606 607 .id_table = pata_icside_ids, 607 608 .drv = {
+3 -3
drivers/ata/pata_imx.c
··· 91 91 ioaddr->command_addr = ioaddr->cmd_addr + (ATA_REG_CMD << 2); 92 92 } 93 93 94 - static int __devinit pata_imx_probe(struct platform_device *pdev) 94 + static int pata_imx_probe(struct platform_device *pdev) 95 95 { 96 96 struct ata_host *host; 97 97 struct ata_port *ap; ··· 167 167 return -ENOMEM; 168 168 } 169 169 170 - static int __devexit pata_imx_remove(struct platform_device *pdev) 170 + static int pata_imx_remove(struct platform_device *pdev) 171 171 { 172 172 struct ata_host *host = dev_get_drvdata(&pdev->dev); 173 173 struct pata_imx_priv *priv = host->private_data; ··· 225 225 226 226 static struct platform_driver pata_imx_driver = { 227 227 .probe = pata_imx_probe, 228 - .remove = __devexit_p(pata_imx_remove), 228 + .remove = pata_imx_remove, 229 229 .driver = { 230 230 .name = DRV_NAME, 231 231 .owner = THIS_MODULE,
+1 -1
drivers/ata/pata_ixp4xx_cf.c
··· 137 137 ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", raw_cmd, raw_ctl); 138 138 } 139 139 140 - static __devinit int ixp4xx_pata_probe(struct platform_device *pdev) 140 + static int ixp4xx_pata_probe(struct platform_device *pdev) 141 141 { 142 142 unsigned int irq; 143 143 struct resource *cs0, *cs1;
+16 -17
drivers/ata/pata_macio.c
··· 935 935 .sff_irq_clear = pata_macio_irq_clear, 936 936 }; 937 937 938 - static void __devinit pata_macio_invariants(struct pata_macio_priv *priv) 938 + static void pata_macio_invariants(struct pata_macio_priv *priv) 939 939 { 940 940 const int *bidp; 941 941 ··· 976 976 priv->aapl_bus_id = 1; 977 977 } 978 978 979 - static void __devinit pata_macio_setup_ios(struct ata_ioports *ioaddr, 980 - void __iomem * base, 981 - void __iomem * dma) 979 + static void pata_macio_setup_ios(struct ata_ioports *ioaddr, 980 + void __iomem * base, void __iomem * dma) 982 981 { 983 982 /* cmd_addr is the base of regs for that port */ 984 983 ioaddr->cmd_addr = base; ··· 998 999 ioaddr->bmdma_addr = dma; 999 1000 } 1000 1001 1001 - static void __devinit pmac_macio_calc_timing_masks(struct pata_macio_priv *priv, 1002 - struct ata_port_info *pinfo) 1002 + static void pmac_macio_calc_timing_masks(struct pata_macio_priv *priv, 1003 + struct ata_port_info *pinfo) 1003 1004 { 1004 1005 int i = 0; 1005 1006 ··· 1026 1027 pinfo->pio_mask, pinfo->mwdma_mask, pinfo->udma_mask); 1027 1028 } 1028 1029 1029 - static int __devinit pata_macio_common_init(struct pata_macio_priv *priv, 1030 - resource_size_t tfregs, 1031 - resource_size_t dmaregs, 1032 - resource_size_t fcregs, 1033 - unsigned long irq) 1030 + static int pata_macio_common_init(struct pata_macio_priv *priv, 1031 + resource_size_t tfregs, 1032 + resource_size_t dmaregs, 1033 + resource_size_t fcregs, 1034 + unsigned long irq) 1034 1035 { 1035 1036 struct ata_port_info pinfo; 1036 1037 const struct ata_port_info *ppi[] = { &pinfo, NULL }; ··· 1112 1113 &pata_macio_sht); 1113 1114 } 1114 1115 1115 - static int __devinit pata_macio_attach(struct macio_dev *mdev, 1116 - const struct of_device_id *match) 1116 + static int pata_macio_attach(struct macio_dev *mdev, 1117 + const struct of_device_id *match) 1117 1118 { 1118 1119 struct pata_macio_priv *priv; 1119 1120 resource_size_t tfregs, dmaregs = 0; ··· 1189 1190 return rc; 1190 1191 } 1191 1192 1192 - static int __devexit pata_macio_detach(struct macio_dev *mdev) 1193 + static int pata_macio_detach(struct macio_dev *mdev) 1193 1194 { 1194 1195 struct ata_host *host = macio_get_drvdata(mdev); 1195 1196 struct pata_macio_priv *priv = host->private_data; ··· 1256 1257 #endif /* CONFIG_PMAC_MEDIABAY */ 1257 1258 1258 1259 1259 - static int __devinit pata_macio_pci_attach(struct pci_dev *pdev, 1260 - const struct pci_device_id *id) 1260 + static int pata_macio_pci_attach(struct pci_dev *pdev, 1261 + const struct pci_device_id *id) 1261 1262 { 1262 1263 struct pata_macio_priv *priv; 1263 1264 struct device_node *np; ··· 1309 1310 return 0; 1310 1311 } 1311 1312 1312 - static void __devexit pata_macio_pci_detach(struct pci_dev *pdev) 1313 + static void pata_macio_pci_detach(struct pci_dev *pdev) 1313 1314 { 1314 1315 struct ata_host *host = dev_get_drvdata(&pdev->dev); 1315 1316
+5 -5
drivers/ata/pata_mpc52xx.c
··· 621 621 .qc_prep = ata_noop_qc_prep, 622 622 }; 623 623 624 - static int __devinit 625 - mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv, 626 - unsigned long raw_ata_regs, int mwdma_mask, int udma_mask) 624 + static int mpc52xx_ata_init_one(struct device *dev, 625 + struct mpc52xx_ata_priv *priv, 626 + unsigned long raw_ata_regs, 627 + int mwdma_mask, int udma_mask) 627 628 { 628 629 struct ata_host *host; 629 630 struct ata_port *ap; ··· 668 667 /* OF Platform driver */ 669 668 /* ======================================================================== */ 670 669 671 - static int __devinit 672 - mpc52xx_ata_probe(struct platform_device *op) 670 + static int mpc52xx_ata_probe(struct platform_device *op) 673 671 { 674 672 unsigned int ipb_freq; 675 673 struct resource res_mem;
+1 -1
drivers/ata/pata_octeon_cf.c
··· 840 840 .dev_config = octeon_cf_dev_config, 841 841 }; 842 842 843 - static int __devinit octeon_cf_probe(struct platform_device *pdev) 843 + static int octeon_cf_probe(struct platform_device *pdev) 844 844 { 845 845 struct resource *res_cs0, *res_cs1; 846 846
+1 -1
drivers/ata/pata_of_platform.c
··· 16 16 #include <linux/ata_platform.h> 17 17 #include <linux/libata.h> 18 18 19 - static int __devinit pata_of_platform_probe(struct platform_device *ofdev) 19 + static int pata_of_platform_probe(struct platform_device *ofdev) 20 20 { 21 21 int ret; 22 22 struct device_node *dn = ofdev->dev.of_node;
+3 -3
drivers/ata/pata_palmld.c
··· 48 48 .cable_detect = ata_cable_40wire, 49 49 }; 50 50 51 - static __devinit int palmld_pata_probe(struct platform_device *pdev) 51 + static int palmld_pata_probe(struct platform_device *pdev) 52 52 { 53 53 struct ata_host *host; 54 54 struct ata_port *ap; ··· 109 109 return ret; 110 110 } 111 111 112 - static __devexit int palmld_pata_remove(struct platform_device *dev) 112 + static int palmld_pata_remove(struct platform_device *dev) 113 113 { 114 114 ata_platform_remove_one(dev); 115 115 ··· 127 127 .owner = THIS_MODULE, 128 128 }, 129 129 .probe = palmld_pata_probe, 130 - .remove = __devexit_p(palmld_pata_remove), 130 + .remove = palmld_pata_remove, 131 131 }; 132 132 133 133 module_platform_driver(palmld_pata_platform_driver);
+2 -1
drivers/ata/pata_pdc2027x.c
··· 700 700 * @pdev: instance of pci_dev found 701 701 * @ent: matching entry in the id_tbl[] 702 702 */ 703 - static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 703 + static int pdc2027x_init_one(struct pci_dev *pdev, 704 + const struct pci_device_id *ent) 704 705 { 705 706 static const unsigned long cmd_offset[] = { 0x17c0, 0x15c0 }; 706 707 static const unsigned long bmdma_offset[] = { 0x1000, 0x1008 };
+4 -7
drivers/ata/pata_platform.c
··· 98 98 * 99 99 * If no IRQ resource is present, PIO polling mode is used instead. 100 100 */ 101 - int __devinit __pata_platform_probe(struct device *dev, 102 - struct resource *io_res, 103 - struct resource *ctl_res, 104 - struct resource *irq_res, 105 - unsigned int ioport_shift, 106 - int __pio_mask) 101 + int __pata_platform_probe(struct device *dev, struct resource *io_res, 102 + struct resource *ctl_res, struct resource *irq_res, 103 + unsigned int ioport_shift, int __pio_mask) 107 104 { 108 105 struct ata_host *host; 109 106 struct ata_port *ap; ··· 175 178 } 176 179 EXPORT_SYMBOL_GPL(__pata_platform_probe); 177 180 178 - static int __devinit pata_platform_probe(struct platform_device *pdev) 181 + static int pata_platform_probe(struct platform_device *pdev) 179 182 { 180 183 struct resource *io_res; 181 184 struct resource *ctl_res;
+3 -3
drivers/ata/pata_pxa.c
··· 229 229 complete(&pd->dma_done); 230 230 } 231 231 232 - static int __devinit pxa_ata_probe(struct platform_device *pdev) 232 + static int pxa_ata_probe(struct platform_device *pdev) 233 233 { 234 234 struct ata_host *host; 235 235 struct ata_port *ap; ··· 369 369 return ret; 370 370 } 371 371 372 - static int __devexit pxa_ata_remove(struct platform_device *pdev) 372 + static int pxa_ata_remove(struct platform_device *pdev) 373 373 { 374 374 struct ata_host *host = dev_get_drvdata(&pdev->dev); 375 375 struct pata_pxa_data *data = host->ports[0]->private_data; ··· 383 383 384 384 static struct platform_driver pxa_ata_driver = { 385 385 .probe = pxa_ata_probe, 386 - .remove = __devexit_p(pxa_ata_remove), 386 + .remove = pxa_ata_remove, 387 387 .driver = { 388 388 .name = DRV_NAME, 389 389 .owner = THIS_MODULE,
+3 -3
drivers/ata/pata_rb532_cf.c
··· 102 102 ap->ioaddr.error_addr = info->iobase + RB500_CF_REG_ERR; 103 103 } 104 104 105 - static __devinit int rb532_pata_driver_probe(struct platform_device *pdev) 105 + static int rb532_pata_driver_probe(struct platform_device *pdev) 106 106 { 107 107 int irq; 108 108 int gpio; ··· 177 177 return ret; 178 178 } 179 179 180 - static __devexit int rb532_pata_driver_remove(struct platform_device *pdev) 180 + static int rb532_pata_driver_remove(struct platform_device *pdev) 181 181 { 182 182 struct ata_host *ah = platform_get_drvdata(pdev); 183 183 struct rb532_cf_info *info = ah->private_data; ··· 190 190 191 191 static struct platform_driver rb532_pata_platform_driver = { 192 192 .probe = rb532_pata_driver_probe, 193 - .remove = __devexit_p(rb532_pata_driver_remove), 193 + .remove = rb532_pata_driver_remove, 194 194 .driver = { 195 195 .name = DRV_NAME, 196 196 .owner = THIS_MODULE,
+1 -2
drivers/ata/pata_rdc.c
··· 321 321 * Zero on success, or -ERRNO value. 322 322 */ 323 323 324 - static int __devinit rdc_init_one(struct pci_dev *pdev, 325 - const struct pci_device_id *ent) 324 + static int rdc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 326 325 { 327 326 struct device *dev = &pdev->dev; 328 327 struct ata_port_info port_info[2];
+1 -2
drivers/ata/pata_sch.c
··· 169 169 * Zero on success, or -ERRNO value. 170 170 */ 171 171 172 - static int __devinit sch_init_one(struct pci_dev *pdev, 173 - const struct pci_device_id *ent) 172 + static int sch_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 174 173 { 175 174 const struct ata_port_info *ppi[] = { &sch_port_info, NULL }; 176 175
+1 -2
drivers/ata/pata_sil680.c
··· 323 323 return tmpbyte & 0x30; 324 324 } 325 325 326 - static int __devinit sil680_init_one(struct pci_dev *pdev, 327 - const struct pci_device_id *id) 326 + static int sil680_init_one(struct pci_dev *pdev, const struct pci_device_id *id) 328 327 { 329 328 static const struct ata_port_info info = { 330 329 .flags = ATA_FLAG_SLAVE_POSS,
+1 -1
drivers/ata/sata_highbank.c
··· 260 260 }; 261 261 MODULE_DEVICE_TABLE(of, ahci_of_match); 262 262 263 - static int __devinit ahci_highbank_probe(struct platform_device *pdev) 263 + static int ahci_highbank_probe(struct platform_device *pdev) 264 264 { 265 265 struct device *dev = &pdev->dev; 266 266 struct ahci_host_priv *hpriv;
+4 -4
drivers/ata/sata_mv.c
··· 4148 4148 * A platform bus SATA device has been unplugged. Perform the needed 4149 4149 * cleanup. Also called on module unload for any active devices. 4150 4150 */ 4151 - static int __devexit mv_platform_remove(struct platform_device *pdev) 4151 + static int mv_platform_remove(struct platform_device *pdev) 4152 4152 { 4153 4153 struct ata_host *host = platform_get_drvdata(pdev); 4154 4154 #if defined(CONFIG_HAVE_CLK) ··· 4215 4215 #endif 4216 4216 4217 4217 #ifdef CONFIG_OF 4218 - static struct of_device_id mv_sata_dt_ids[] __devinitdata = { 4218 + static struct of_device_id mv_sata_dt_ids[] = { 4219 4219 { .compatible = "marvell,orion-sata", }, 4220 4220 {}, 4221 4221 }; ··· 4224 4224 4225 4225 static struct platform_driver mv_platform_driver = { 4226 4226 .probe = mv_platform_probe, 4227 - .remove = __devexit_p(mv_platform_remove), 4227 + .remove = mv_platform_remove, 4228 4228 .suspend = mv_platform_suspend, 4229 4229 .resume = mv_platform_resume, 4230 4230 .driver = { ··· 4429 4429 #endif 4430 4430 4431 4431 static int mv_platform_probe(struct platform_device *pdev); 4432 - static int __devexit mv_platform_remove(struct platform_device *pdev); 4432 + static int mv_platform_remove(struct platform_device *pdev); 4433 4433 4434 4434 static int __init mv_init(void) 4435 4435 {
+3 -4
drivers/ata/sata_vsc.c
··· 312 312 .scr_write = vsc_sata_scr_write, 313 313 }; 314 314 315 - static void __devinit vsc_sata_setup_port(struct ata_ioports *port, 316 - void __iomem *base) 315 + static void vsc_sata_setup_port(struct ata_ioports *port, void __iomem *base) 317 316 { 318 317 port->cmd_addr = base + VSC_SATA_TF_CMD_OFFSET; 319 318 port->data_addr = base + VSC_SATA_TF_DATA_OFFSET; ··· 334 335 } 335 336 336 337 337 - static int __devinit vsc_sata_init_one(struct pci_dev *pdev, 338 - const struct pci_device_id *ent) 338 + static int vsc_sata_init_one(struct pci_dev *pdev, 339 + const struct pci_device_id *ent) 339 340 { 340 341 static const struct ata_port_info pi = { 341 342 .flags = ATA_FLAG_SATA,