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

can: remove __dev* attributes

CONFIG_HOTPLUG is going away as an option. As result the __dev*
markings will be going away.

Remove use of __devinit, __devexit_p, __devinitdata, __devinitconst,
and __devexit.

Signed-off-by: Bill Pemberton <wfp5p@virginia.edu>
Cc: Wolfgang Grandegger <wg@grandegger.com>
Cc: Marc Kleine-Budde <mkl@pengutronix.de>
Cc: linux-can@vger.kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Bill Pemberton and committed by
Greg Kroah-Hartman 3c8ac0f2 7c47bab6

+116 -116
+4 -4
drivers/net/can/at91_can.c
··· 155 155 canid_t mb0_id; 156 156 }; 157 157 158 - static const struct at91_devtype_data at91_devtype_data[] __devinitconst = { 158 + static const struct at91_devtype_data at91_devtype_data[] = { 159 159 [AT91_DEVTYPE_SAM9263] = { 160 160 .rx_first = 1, 161 161 .rx_split = 8, ··· 1242 1242 .attrs = at91_sysfs_attrs, 1243 1243 }; 1244 1244 1245 - static int __devinit at91_can_probe(struct platform_device *pdev) 1245 + static int at91_can_probe(struct platform_device *pdev) 1246 1246 { 1247 1247 const struct at91_devtype_data *devtype_data; 1248 1248 enum at91_devtype devtype; ··· 1339 1339 return err; 1340 1340 } 1341 1341 1342 - static int __devexit at91_can_remove(struct platform_device *pdev) 1342 + static int at91_can_remove(struct platform_device *pdev) 1343 1343 { 1344 1344 struct net_device *dev = platform_get_drvdata(pdev); 1345 1345 struct at91_priv *priv = netdev_priv(dev); ··· 1376 1376 1377 1377 static struct platform_driver at91_can_driver = { 1378 1378 .probe = at91_can_probe, 1379 - .remove = __devexit_p(at91_can_remove), 1379 + .remove = at91_can_remove, 1380 1380 .driver = { 1381 1381 .name = KBUILD_MODNAME, 1382 1382 .owner = THIS_MODULE,
+3 -3
drivers/net/can/bfin_can.c
··· 531 531 .ndo_start_xmit = bfin_can_start_xmit, 532 532 }; 533 533 534 - static int __devinit bfin_can_probe(struct platform_device *pdev) 534 + static int bfin_can_probe(struct platform_device *pdev) 535 535 { 536 536 int err; 537 537 struct net_device *dev; ··· 611 611 return err; 612 612 } 613 613 614 - static int __devexit bfin_can_remove(struct platform_device *pdev) 614 + static int bfin_can_remove(struct platform_device *pdev) 615 615 { 616 616 struct net_device *dev = dev_get_drvdata(&pdev->dev); 617 617 struct bfin_can_priv *priv = netdev_priv(dev); ··· 677 677 678 678 static struct platform_driver bfin_can_driver = { 679 679 .probe = bfin_can_probe, 680 - .remove = __devexit_p(bfin_can_remove), 680 + .remove = bfin_can_remove, 681 681 .suspend = bfin_can_suspend, 682 682 .resume = bfin_can_resume, 683 683 .driver = {
+3 -3
drivers/net/can/c_can/c_can_pci.c
··· 63 63 writew(val, priv->base + 2 * priv->regs[index]); 64 64 } 65 65 66 - static int __devinit c_can_pci_probe(struct pci_dev *pdev, 66 + static int c_can_pci_probe(struct pci_dev *pdev, 67 67 const struct pci_device_id *ent) 68 68 { 69 69 struct c_can_pci_data *c_can_pci_data = (void *)ent->driver_data; ··· 174 174 return ret; 175 175 } 176 176 177 - static void __devexit c_can_pci_remove(struct pci_dev *pdev) 177 + static void c_can_pci_remove(struct pci_dev *pdev) 178 178 { 179 179 struct net_device *dev = pci_get_drvdata(pdev); 180 180 struct c_can_priv *priv = netdev_priv(dev); ··· 210 210 .name = KBUILD_MODNAME, 211 211 .id_table = c_can_pci_tbl, 212 212 .probe = c_can_pci_probe, 213 - .remove = __devexit_p(c_can_pci_remove), 213 + .remove = c_can_pci_remove, 214 214 }; 215 215 216 216 module_pci_driver(c_can_pci_driver);
+3 -3
drivers/net/can/c_can/c_can_platform.c
··· 106 106 }; 107 107 MODULE_DEVICE_TABLE(of, c_can_of_table); 108 108 109 - static int __devinit c_can_plat_probe(struct platform_device *pdev) 109 + static int c_can_plat_probe(struct platform_device *pdev) 110 110 { 111 111 int ret; 112 112 void __iomem *addr; ··· 248 248 return ret; 249 249 } 250 250 251 - static int __devexit c_can_plat_remove(struct platform_device *pdev) 251 + static int c_can_plat_remove(struct platform_device *pdev) 252 252 { 253 253 struct net_device *dev = platform_get_drvdata(pdev); 254 254 struct c_can_priv *priv = netdev_priv(dev); ··· 334 334 .of_match_table = of_match_ptr(c_can_of_table), 335 335 }, 336 336 .probe = c_can_plat_probe, 337 - .remove = __devexit_p(c_can_plat_remove), 337 + .remove = c_can_plat_remove, 338 338 .suspend = c_can_suspend, 339 339 .resume = c_can_resume, 340 340 .id_table = c_can_id_table,
+9 -9
drivers/net/can/cc770/cc770_isa.c
··· 75 75 76 76 static unsigned long port[MAXDEV]; 77 77 static unsigned long mem[MAXDEV]; 78 - static int __devinitdata irq[MAXDEV]; 79 - static int __devinitdata clk[MAXDEV]; 80 - static u8 __devinitdata cir[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 81 - static u8 __devinitdata cor[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 82 - static u8 __devinitdata bcr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 83 - static int __devinitdata indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1}; 78 + static int irq[MAXDEV]; 79 + static int clk[MAXDEV]; 80 + static u8 cir[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 81 + static u8 cor[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 82 + static u8 bcr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 83 + static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1}; 84 84 85 85 module_param_array(port, ulong, NULL, S_IRUGO); 86 86 MODULE_PARM_DESC(port, "I/O port number"); ··· 166 166 spin_unlock_irqrestore(&cc770_isa_port_lock, flags); 167 167 } 168 168 169 - static int __devinit cc770_isa_probe(struct platform_device *pdev) 169 + static int cc770_isa_probe(struct platform_device *pdev) 170 170 { 171 171 struct net_device *dev; 172 172 struct cc770_priv *priv; ··· 291 291 return err; 292 292 } 293 293 294 - static int __devexit cc770_isa_remove(struct platform_device *pdev) 294 + static int cc770_isa_remove(struct platform_device *pdev) 295 295 { 296 296 struct net_device *dev = dev_get_drvdata(&pdev->dev); 297 297 struct cc770_priv *priv = netdev_priv(dev); ··· 316 316 317 317 static struct platform_driver cc770_isa_driver = { 318 318 .probe = cc770_isa_probe, 319 - .remove = __devexit_p(cc770_isa_remove), 319 + .remove = cc770_isa_remove, 320 320 .driver = { 321 321 .name = KBUILD_MODNAME, 322 322 .owner = THIS_MODULE,
+6 -6
drivers/net/can/cc770/cc770_platform.c
··· 75 75 iowrite8(val, priv->reg_base + reg); 76 76 } 77 77 78 - static int __devinit cc770_get_of_node_data(struct platform_device *pdev, 78 + static int cc770_get_of_node_data(struct platform_device *pdev, 79 79 struct cc770_priv *priv) 80 80 { 81 81 struct device_node *np = pdev->dev.of_node; ··· 148 148 return 0; 149 149 } 150 150 151 - static int __devinit cc770_get_platform_data(struct platform_device *pdev, 151 + static int cc770_get_platform_data(struct platform_device *pdev, 152 152 struct cc770_priv *priv) 153 153 { 154 154 ··· 164 164 return 0; 165 165 } 166 166 167 - static int __devinit cc770_platform_probe(struct platform_device *pdev) 167 + static int cc770_platform_probe(struct platform_device *pdev) 168 168 { 169 169 struct net_device *dev; 170 170 struct cc770_priv *priv; ··· 238 238 return err; 239 239 } 240 240 241 - static int __devexit cc770_platform_remove(struct platform_device *pdev) 241 + static int cc770_platform_remove(struct platform_device *pdev) 242 242 { 243 243 struct net_device *dev = dev_get_drvdata(&pdev->dev); 244 244 struct cc770_priv *priv = netdev_priv(dev); ··· 254 254 return 0; 255 255 } 256 256 257 - static struct of_device_id __devinitdata cc770_platform_table[] = { 257 + static struct of_device_id cc770_platform_table[] = { 258 258 {.compatible = "bosch,cc770"}, /* CC770 from Bosch */ 259 259 {.compatible = "intc,82527"}, /* AN82527 from Intel CP */ 260 260 {}, ··· 268 268 .of_match_table = cc770_platform_table, 269 269 }, 270 270 .probe = cc770_platform_probe, 271 - .remove = __devexit_p(cc770_platform_remove), 271 + .remove = cc770_platform_remove, 272 272 }; 273 273 274 274 module_platform_driver(cc770_platform_driver);
+5 -5
drivers/net/can/flexcan.c
··· 922 922 .ndo_start_xmit = flexcan_start_xmit, 923 923 }; 924 924 925 - static int __devinit register_flexcandev(struct net_device *dev) 925 + static int register_flexcandev(struct net_device *dev) 926 926 { 927 927 struct flexcan_priv *priv = netdev_priv(dev); 928 928 struct flexcan_regs __iomem *regs = priv->base; ··· 968 968 return err; 969 969 } 970 970 971 - static void __devexit unregister_flexcandev(struct net_device *dev) 971 + static void unregister_flexcandev(struct net_device *dev) 972 972 { 973 973 unregister_candev(dev); 974 974 } ··· 987 987 }; 988 988 MODULE_DEVICE_TABLE(platform, flexcan_id_table); 989 989 990 - static int __devinit flexcan_probe(struct platform_device *pdev) 990 + static int flexcan_probe(struct platform_device *pdev) 991 991 { 992 992 const struct of_device_id *of_id; 993 993 const struct flexcan_devtype_data *devtype_data; ··· 1109 1109 return err; 1110 1110 } 1111 1111 1112 - static int __devexit flexcan_remove(struct platform_device *pdev) 1112 + static int flexcan_remove(struct platform_device *pdev) 1113 1113 { 1114 1114 struct net_device *dev = platform_get_drvdata(pdev); 1115 1115 struct flexcan_priv *priv = netdev_priv(dev); ··· 1170 1170 .of_match_table = flexcan_of_match, 1171 1171 }, 1172 1172 .probe = flexcan_probe, 1173 - .remove = __devexit_p(flexcan_remove), 1173 + .remove = flexcan_remove, 1174 1174 .suspend = flexcan_suspend, 1175 1175 .resume = flexcan_resume, 1176 1176 .id_table = flexcan_id_table,
+4 -4
drivers/net/can/grcan.c
··· 1659 1659 return err; 1660 1660 } 1661 1661 1662 - static int __devinit grcan_probe(struct platform_device *ofdev) 1662 + static int grcan_probe(struct platform_device *ofdev) 1663 1663 { 1664 1664 struct device_node *np = ofdev->dev.of_node; 1665 1665 struct resource *res; ··· 1714 1714 return err; 1715 1715 } 1716 1716 1717 - static int __devexit grcan_remove(struct platform_device *ofdev) 1717 + static int grcan_remove(struct platform_device *ofdev) 1718 1718 { 1719 1719 struct net_device *dev = dev_get_drvdata(&ofdev->dev); 1720 1720 struct grcan_priv *priv = netdev_priv(dev); ··· 1729 1729 return 0; 1730 1730 } 1731 1731 1732 - static struct of_device_id grcan_match[] __devinitconst = { 1732 + static struct of_device_id grcan_match[] = { 1733 1733 {.name = "GAISLER_GRCAN"}, 1734 1734 {.name = "01_03d"}, 1735 1735 {.name = "GAISLER_GRHCAN"}, ··· 1746 1746 .of_match_table = grcan_match, 1747 1747 }, 1748 1748 .probe = grcan_probe, 1749 - .remove = __devexit_p(grcan_remove), 1749 + .remove = grcan_remove, 1750 1750 }; 1751 1751 1752 1752 module_platform_driver(grcan_driver);
+12 -12
drivers/net/can/janz-ican3.c
··· 365 365 * ICAN3 "new-style" Host Interface Setup 366 366 */ 367 367 368 - static void __devinit ican3_init_new_host_interface(struct ican3_dev *mod) 368 + static void ican3_init_new_host_interface(struct ican3_dev *mod) 369 369 { 370 370 struct ican3_new_desc desc; 371 371 unsigned long flags; ··· 444 444 * ICAN3 Fast Host Interface Setup 445 445 */ 446 446 447 - static void __devinit ican3_init_fast_host_interface(struct ican3_dev *mod) 447 + static void ican3_init_fast_host_interface(struct ican3_dev *mod) 448 448 { 449 449 struct ican3_fast_desc desc; 450 450 unsigned long flags; ··· 631 631 * Quick Pre-constructed Messages 632 632 */ 633 633 634 - static int __devinit ican3_msg_connect(struct ican3_dev *mod) 634 + static int ican3_msg_connect(struct ican3_dev *mod) 635 635 { 636 636 struct ican3_msg msg; 637 637 ··· 642 642 return ican3_send_msg(mod, &msg); 643 643 } 644 644 645 - static int __devexit ican3_msg_disconnect(struct ican3_dev *mod) 645 + static int ican3_msg_disconnect(struct ican3_dev *mod) 646 646 { 647 647 struct ican3_msg msg; 648 648 ··· 653 653 return ican3_send_msg(mod, &msg); 654 654 } 655 655 656 - static int __devinit ican3_msg_newhostif(struct ican3_dev *mod) 656 + static int ican3_msg_newhostif(struct ican3_dev *mod) 657 657 { 658 658 struct ican3_msg msg; 659 659 int ret; ··· 674 674 return 0; 675 675 } 676 676 677 - static int __devinit ican3_msg_fasthostif(struct ican3_dev *mod) 677 + static int ican3_msg_fasthostif(struct ican3_dev *mod) 678 678 { 679 679 struct ican3_msg msg; 680 680 unsigned int addr; ··· 707 707 * Setup the CAN filter to either accept or reject all 708 708 * messages from the CAN bus. 709 709 */ 710 - static int __devinit ican3_set_id_filter(struct ican3_dev *mod, bool accept) 710 + static int ican3_set_id_filter(struct ican3_dev *mod, bool accept) 711 711 { 712 712 struct ican3_msg msg; 713 713 int ret; ··· 1421 1421 return -ETIMEDOUT; 1422 1422 } 1423 1423 1424 - static void __devexit ican3_shutdown_module(struct ican3_dev *mod) 1424 + static void ican3_shutdown_module(struct ican3_dev *mod) 1425 1425 { 1426 1426 ican3_msg_disconnect(mod); 1427 1427 ican3_reset_module(mod); ··· 1430 1430 /* 1431 1431 * Startup an ICAN module, bringing it into fast mode 1432 1432 */ 1433 - static int __devinit ican3_startup_module(struct ican3_dev *mod) 1433 + static int ican3_startup_module(struct ican3_dev *mod) 1434 1434 { 1435 1435 int ret; 1436 1436 ··· 1760 1760 * PCI Subsystem 1761 1761 */ 1762 1762 1763 - static int __devinit ican3_probe(struct platform_device *pdev) 1763 + static int ican3_probe(struct platform_device *pdev) 1764 1764 { 1765 1765 struct janz_platform_data *pdata; 1766 1766 struct net_device *ndev; ··· 1898 1898 return ret; 1899 1899 } 1900 1900 1901 - static int __devexit ican3_remove(struct platform_device *pdev) 1901 + static int ican3_remove(struct platform_device *pdev) 1902 1902 { 1903 1903 struct net_device *ndev = platform_get_drvdata(pdev); 1904 1904 struct ican3_dev *mod = netdev_priv(ndev); ··· 1927 1927 .owner = THIS_MODULE, 1928 1928 }, 1929 1929 .probe = ican3_probe, 1930 - .remove = __devexit_p(ican3_remove), 1930 + .remove = ican3_remove, 1931 1931 }; 1932 1932 1933 1933 module_platform_driver(ican3_driver);
+3 -3
drivers/net/can/mcp251x.c
··· 981 981 .ndo_start_xmit = mcp251x_hard_start_xmit, 982 982 }; 983 983 984 - static int __devinit mcp251x_can_probe(struct spi_device *spi) 984 + static int mcp251x_can_probe(struct spi_device *spi) 985 985 { 986 986 struct net_device *net; 987 987 struct mcp251x_priv *priv; ··· 1100 1100 return ret; 1101 1101 } 1102 1102 1103 - static int __devexit mcp251x_can_remove(struct spi_device *spi) 1103 + static int mcp251x_can_remove(struct spi_device *spi) 1104 1104 { 1105 1105 struct mcp251x_platform_data *pdata = spi->dev.platform_data; 1106 1106 struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev); ··· 1198 1198 1199 1199 .id_table = mcp251x_id_table, 1200 1200 .probe = mcp251x_can_probe, 1201 - .remove = __devexit_p(mcp251x_can_remove), 1201 + .remove = mcp251x_can_remove, 1202 1202 .suspend = mcp251x_can_suspend, 1203 1203 .resume = mcp251x_can_resume, 1204 1204 };
+12 -12
drivers/net/can/mscan/mpc5xxx_can.c
··· 43 43 }; 44 44 45 45 #ifdef CONFIG_PPC_MPC52xx 46 - static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = { 46 + static struct of_device_id mpc52xx_cdm_ids[] = { 47 47 { .compatible = "fsl,mpc5200-cdm", }, 48 48 {} 49 49 }; 50 50 51 - static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev, 51 + static u32 mpc52xx_can_get_clock(struct platform_device *ofdev, 52 52 const char *clock_name, 53 53 int *mscan_clksrc) 54 54 { ··· 101 101 return freq; 102 102 } 103 103 #else /* !CONFIG_PPC_MPC52xx */ 104 - static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev, 104 + static u32 mpc52xx_can_get_clock(struct platform_device *ofdev, 105 105 const char *clock_name, 106 106 int *mscan_clksrc) 107 107 { ··· 124 124 u32 mccr[4]; /* MSCAN Clk Ctrl Reg 1-3 */ 125 125 }; 126 126 127 - static struct of_device_id __devinitdata mpc512x_clock_ids[] = { 127 + static struct of_device_id mpc512x_clock_ids[] = { 128 128 { .compatible = "fsl,mpc5121-clock", }, 129 129 {} 130 130 }; 131 131 132 - static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev, 132 + static u32 mpc512x_can_get_clock(struct platform_device *ofdev, 133 133 const char *clock_name, 134 134 int *mscan_clksrc) 135 135 { ··· 239 239 return freq; 240 240 } 241 241 #else /* !CONFIG_PPC_MPC512x */ 242 - static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev, 242 + static u32 mpc512x_can_get_clock(struct platform_device *ofdev, 243 243 const char *clock_name, 244 244 int *mscan_clksrc) 245 245 { ··· 248 248 #endif /* CONFIG_PPC_MPC512x */ 249 249 250 250 static const struct of_device_id mpc5xxx_can_table[]; 251 - static int __devinit mpc5xxx_can_probe(struct platform_device *ofdev) 251 + static int mpc5xxx_can_probe(struct platform_device *ofdev) 252 252 { 253 253 const struct of_device_id *match; 254 254 const struct mpc5xxx_can_data *data; ··· 323 323 return err; 324 324 } 325 325 326 - static int __devexit mpc5xxx_can_remove(struct platform_device *ofdev) 326 + static int mpc5xxx_can_remove(struct platform_device *ofdev) 327 327 { 328 328 struct net_device *dev = dev_get_drvdata(&ofdev->dev); 329 329 struct mscan_priv *priv = netdev_priv(dev); ··· 380 380 } 381 381 #endif 382 382 383 - static const struct mpc5xxx_can_data __devinitconst mpc5200_can_data = { 383 + static const struct mpc5xxx_can_data mpc5200_can_data = { 384 384 .type = MSCAN_TYPE_MPC5200, 385 385 .get_clock = mpc52xx_can_get_clock, 386 386 }; 387 387 388 - static const struct mpc5xxx_can_data __devinitconst mpc5121_can_data = { 388 + static const struct mpc5xxx_can_data mpc5121_can_data = { 389 389 .type = MSCAN_TYPE_MPC5121, 390 390 .get_clock = mpc512x_can_get_clock, 391 391 }; 392 392 393 - static const struct of_device_id __devinitconst mpc5xxx_can_table[] = { 393 + static const struct of_device_id mpc5xxx_can_table[] = { 394 394 { .compatible = "fsl,mpc5200-mscan", .data = &mpc5200_can_data, }, 395 395 /* Note that only MPC5121 Rev. 2 (and later) is supported */ 396 396 { .compatible = "fsl,mpc5121-mscan", .data = &mpc5121_can_data, }, ··· 405 405 .of_match_table = mpc5xxx_can_table, 406 406 }, 407 407 .probe = mpc5xxx_can_probe, 408 - .remove = __devexit_p(mpc5xxx_can_remove), 408 + .remove = mpc5xxx_can_remove, 409 409 #ifdef CONFIG_PM 410 410 .suspend = mpc5xxx_can_suspend, 411 411 .resume = mpc5xxx_can_resume,
+3 -3
drivers/net/can/pch_can.c
··· 954 954 .ndo_start_xmit = pch_xmit, 955 955 }; 956 956 957 - static void __devexit pch_can_remove(struct pci_dev *pdev) 957 + static void pch_can_remove(struct pci_dev *pdev) 958 958 { 959 959 struct net_device *ndev = pci_get_drvdata(pdev); 960 960 struct pch_can_priv *priv = netdev_priv(ndev); ··· 1178 1178 return 0; 1179 1179 } 1180 1180 1181 - static int __devinit pch_can_probe(struct pci_dev *pdev, 1181 + static int pch_can_probe(struct pci_dev *pdev, 1182 1182 const struct pci_device_id *id) 1183 1183 { 1184 1184 struct net_device *ndev; ··· 1269 1269 .name = "pch_can", 1270 1270 .id_table = pch_pci_tbl, 1271 1271 .probe = pch_can_probe, 1272 - .remove = __devexit_p(pch_can_remove), 1272 + .remove = pch_can_remove, 1273 1273 .suspend = pch_can_suspend, 1274 1274 .resume = pch_can_resume, 1275 1275 };
+1 -1
drivers/net/can/sja1000/ems_pci.c
··· 220 220 * Probe PCI device for EMS CAN signature and register each available 221 221 * CAN channel to SJA1000 Socket-CAN subsystem. 222 222 */ 223 - static int __devinit ems_pci_add_card(struct pci_dev *pdev, 223 + static int ems_pci_add_card(struct pci_dev *pdev, 224 224 const struct pci_device_id *ent) 225 225 { 226 226 struct sja1000_priv *priv;
+2 -2
drivers/net/can/sja1000/ems_pcmcia.c
··· 166 166 * Probe PCI device for EMS CAN signature and register each available 167 167 * CAN channel to SJA1000 Socket-CAN subsystem. 168 168 */ 169 - static int __devinit ems_pcmcia_add_card(struct pcmcia_device *pdev, 169 + static int ems_pcmcia_add_card(struct pcmcia_device *pdev, 170 170 unsigned long base) 171 171 { 172 172 struct sja1000_priv *priv; ··· 256 256 /* 257 257 * Setup PCMCIA socket and probe for EMS CPC-CARD 258 258 */ 259 - static int __devinit ems_pcmcia_probe(struct pcmcia_device *dev) 259 + static int ems_pcmcia_probe(struct pcmcia_device *dev) 260 260 { 261 261 int csval; 262 262
+3 -3
drivers/net/can/sja1000/kvaser_pci.c
··· 290 290 return err; 291 291 } 292 292 293 - static int __devinit kvaser_pci_init_one(struct pci_dev *pdev, 293 + static int kvaser_pci_init_one(struct pci_dev *pdev, 294 294 const struct pci_device_id *ent) 295 295 { 296 296 int err; ··· 379 379 380 380 } 381 381 382 - static void __devexit kvaser_pci_remove_one(struct pci_dev *pdev) 382 + static void kvaser_pci_remove_one(struct pci_dev *pdev) 383 383 { 384 384 struct net_device *dev = pci_get_drvdata(pdev); 385 385 ··· 394 394 .name = DRV_NAME, 395 395 .id_table = kvaser_pci_tbl, 396 396 .probe = kvaser_pci_init_one, 397 - .remove = __devexit_p(kvaser_pci_remove_one), 397 + .remove = kvaser_pci_remove_one, 398 398 }; 399 399 400 400 module_pci_driver(kvaser_pci_driver);
+3 -3
drivers/net/can/sja1000/peak_pci.c
··· 551 551 writew(chan->icr_mask, chan->cfg_base + PITA_ICR); 552 552 } 553 553 554 - static int __devinit peak_pci_probe(struct pci_dev *pdev, 554 + static int peak_pci_probe(struct pci_dev *pdev, 555 555 const struct pci_device_id *ent) 556 556 { 557 557 struct sja1000_priv *priv; ··· 717 717 return err; 718 718 } 719 719 720 - static void __devexit peak_pci_remove(struct pci_dev *pdev) 720 + static void peak_pci_remove(struct pci_dev *pdev) 721 721 { 722 722 struct net_device *dev = pci_get_drvdata(pdev); /* Last device */ 723 723 struct sja1000_priv *priv = netdev_priv(dev); ··· 757 757 .name = DRV_NAME, 758 758 .id_table = peak_pci_tbl, 759 759 .probe = peak_pci_probe, 760 - .remove = __devexit_p(peak_pci_remove), 760 + .remove = peak_pci_remove, 761 761 }; 762 762 763 763 module_pci_driver(peak_pci_driver);
+1 -1
drivers/net/can/sja1000/peak_pcmcia.c
··· 632 632 /* 633 633 * setup PCMCIA socket and probe for PEAK-System PC-CARD 634 634 */ 635 - static int __devinit pcan_probe(struct pcmcia_device *pdev) 635 + static int pcan_probe(struct pcmcia_device *pdev) 636 636 { 637 637 struct pcan_pccard *card; 638 638 int err;
+10 -10
drivers/net/can/sja1000/plx_pci.c
··· 162 162 void (*reset_func)(struct pci_dev *pdev); 163 163 }; 164 164 165 - static struct plx_pci_card_info plx_pci_card_info_adlink __devinitdata = { 165 + static struct plx_pci_card_info plx_pci_card_info_adlink = { 166 166 "Adlink PCI-7841/cPCI-7841", 2, 167 167 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 168 168 {1, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} }, ··· 170 170 /* based on PLX9052 */ 171 171 }; 172 172 173 - static struct plx_pci_card_info plx_pci_card_info_adlink_se __devinitdata = { 173 + static struct plx_pci_card_info plx_pci_card_info_adlink_se = { 174 174 "Adlink PCI-7841/cPCI-7841 SE", 2, 175 175 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 176 176 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} }, ··· 178 178 /* based on PLX9052 */ 179 179 }; 180 180 181 - static struct plx_pci_card_info plx_pci_card_info_esd200 __devinitdata = { 181 + static struct plx_pci_card_info plx_pci_card_info_esd200 = { 182 182 "esd CAN-PCI/CPCI/PCI104/200", 2, 183 183 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 184 184 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} }, ··· 186 186 /* based on PLX9030/9050 */ 187 187 }; 188 188 189 - static struct plx_pci_card_info plx_pci_card_info_esd266 __devinitdata = { 189 + static struct plx_pci_card_info plx_pci_card_info_esd266 = { 190 190 "esd CAN-PCI/PMC/266", 2, 191 191 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 192 192 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} }, ··· 194 194 /* based on PLX9056 */ 195 195 }; 196 196 197 - static struct plx_pci_card_info plx_pci_card_info_esd2000 __devinitdata = { 197 + static struct plx_pci_card_info plx_pci_card_info_esd2000 = { 198 198 "esd CAN-PCIe/2000", 2, 199 199 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 200 200 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} }, ··· 202 202 /* based on PEX8311 */ 203 203 }; 204 204 205 - static struct plx_pci_card_info plx_pci_card_info_ixxat __devinitdata = { 205 + static struct plx_pci_card_info plx_pci_card_info_ixxat = { 206 206 "IXXAT PC-I 04/PCI", 2, 207 207 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 208 208 {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x200, 0x80} }, ··· 210 210 /* based on PLX9050 */ 211 211 }; 212 212 213 - static struct plx_pci_card_info plx_pci_card_info_marathon __devinitdata = { 213 + static struct plx_pci_card_info plx_pci_card_info_marathon = { 214 214 "Marathon CAN-bus-PCI", 2, 215 215 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 216 216 {0, 0x00, 0x00}, { {2, 0x00, 0x00}, {4, 0x00, 0x00} }, ··· 218 218 /* based on PLX9052 */ 219 219 }; 220 220 221 - static struct plx_pci_card_info plx_pci_card_info_tews __devinitdata = { 221 + static struct plx_pci_card_info plx_pci_card_info_tews = { 222 222 "TEWS TECHNOLOGIES TPMC810", 2, 223 223 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 224 224 {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} }, ··· 226 226 /* based on PLX9030 */ 227 227 }; 228 228 229 - static struct plx_pci_card_info plx_pci_card_info_cti __devinitdata = { 229 + static struct plx_pci_card_info plx_pci_card_info_cti = { 230 230 "Connect Tech Inc. CANpro/104-Plus Opto (CRG001)", 2, 231 231 PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR, 232 232 {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} }, ··· 484 484 * Probe PLX90xx based device for the SJA1000 chips and register each 485 485 * available CAN channel to SJA1000 Socket-CAN subsystem. 486 486 */ 487 - static int __devinit plx_pci_add_card(struct pci_dev *pdev, 487 + static int plx_pci_add_card(struct pci_dev *pdev, 488 488 const struct pci_device_id *ent) 489 489 { 490 490 struct sja1000_priv *priv;
+8 -8
drivers/net/can/sja1000/sja1000_isa.c
··· 42 42 43 43 static unsigned long port[MAXDEV]; 44 44 static unsigned long mem[MAXDEV]; 45 - static int __devinitdata irq[MAXDEV]; 46 - static int __devinitdata clk[MAXDEV]; 47 - static unsigned char __devinitdata cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 48 - static unsigned char __devinitdata ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 49 - static int __devinitdata indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1}; 45 + static int irq[MAXDEV]; 46 + static int clk[MAXDEV]; 47 + static unsigned char cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 48 + static unsigned char ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff}; 49 + static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1}; 50 50 51 51 module_param_array(port, ulong, NULL, S_IRUGO); 52 52 MODULE_PARM_DESC(port, "I/O port number"); ··· 117 117 outb(val, base + 1); 118 118 } 119 119 120 - static int __devinit sja1000_isa_probe(struct platform_device *pdev) 120 + static int sja1000_isa_probe(struct platform_device *pdev) 121 121 { 122 122 struct net_device *dev; 123 123 struct sja1000_priv *priv; ··· 223 223 return err; 224 224 } 225 225 226 - static int __devexit sja1000_isa_remove(struct platform_device *pdev) 226 + static int sja1000_isa_remove(struct platform_device *pdev) 227 227 { 228 228 struct net_device *dev = dev_get_drvdata(&pdev->dev); 229 229 struct sja1000_priv *priv = netdev_priv(dev); ··· 248 248 249 249 static struct platform_driver sja1000_isa_driver = { 250 250 .probe = sja1000_isa_probe, 251 - .remove = __devexit_p(sja1000_isa_remove), 251 + .remove = sja1000_isa_remove, 252 252 .driver = { 253 253 .name = DRV_NAME, 254 254 .owner = THIS_MODULE,
+4 -4
drivers/net/can/sja1000/sja1000_of_platform.c
··· 70 70 iowrite8(val, priv->reg_base + reg); 71 71 } 72 72 73 - static int __devexit sja1000_ofp_remove(struct platform_device *ofdev) 73 + static int sja1000_ofp_remove(struct platform_device *ofdev) 74 74 { 75 75 struct net_device *dev = dev_get_drvdata(&ofdev->dev); 76 76 struct sja1000_priv *priv = netdev_priv(dev); ··· 90 90 return 0; 91 91 } 92 92 93 - static int __devinit sja1000_ofp_probe(struct platform_device *ofdev) 93 + static int sja1000_ofp_probe(struct platform_device *ofdev) 94 94 { 95 95 struct device_node *np = ofdev->dev.of_node; 96 96 struct net_device *dev; ··· 206 206 return err; 207 207 } 208 208 209 - static struct of_device_id __devinitdata sja1000_ofp_table[] = { 209 + static struct of_device_id sja1000_ofp_table[] = { 210 210 {.compatible = "nxp,sja1000"}, 211 211 {}, 212 212 }; ··· 219 219 .of_match_table = sja1000_ofp_table, 220 220 }, 221 221 .probe = sja1000_ofp_probe, 222 - .remove = __devexit_p(sja1000_ofp_remove), 222 + .remove = sja1000_ofp_remove, 223 223 }; 224 224 225 225 module_platform_driver(sja1000_ofp_driver);
+4 -4
drivers/net/can/sja1000/tscan1.c
··· 71 71 #define TSCAN1_SJA1000_XTAL 16000000 72 72 73 73 /* SJA1000 IO base addresses */ 74 - static const unsigned short tscan1_sja1000_addresses[] __devinitconst = { 74 + static const unsigned short tscan1_sja1000_addresses[] = { 75 75 0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320 76 76 }; 77 77 ··· 88 88 } 89 89 90 90 /* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */ 91 - static int __devinit tscan1_probe(struct device *dev, unsigned id) 91 + static int tscan1_probe(struct device *dev, unsigned id) 92 92 { 93 93 struct net_device *netdev; 94 94 struct sja1000_priv *priv; ··· 171 171 return -ENXIO; 172 172 } 173 173 174 - static int __devexit tscan1_remove(struct device *dev, unsigned id /*unused*/) 174 + static int tscan1_remove(struct device *dev, unsigned id /*unused*/) 175 175 { 176 176 struct net_device *netdev; 177 177 struct sja1000_priv *priv; ··· 197 197 198 198 static struct isa_driver tscan1_isa_driver = { 199 199 .probe = tscan1_probe, 200 - .remove = __devexit_p(tscan1_remove), 200 + .remove = tscan1_remove, 201 201 .driver = { 202 202 .name = "tscan1", 203 203 },
+5 -5
drivers/net/can/softing/softing_cs.c
··· 159 159 MODULE_FIRMWARE(fw_dir "ldcard2.bin"); 160 160 MODULE_FIRMWARE(fw_dir "cancrd2.bin"); 161 161 162 - static __devinit const struct softing_platform_data 162 + static const struct softing_platform_data 163 163 *softingcs_find_platform_data(unsigned int manf, unsigned int prod) 164 164 { 165 165 const struct softing_platform_data *lp; ··· 193 193 /* 194 194 * pcmcia check 195 195 */ 196 - static __devinit int softingcs_probe_config(struct pcmcia_device *pcmcia, 196 + static int softingcs_probe_config(struct pcmcia_device *pcmcia, 197 197 void *priv_data) 198 198 { 199 199 struct softing_platform_data *pdat = priv_data; ··· 215 215 return pcmcia_request_window(pcmcia, pres, memspeed); 216 216 } 217 217 218 - static __devexit void softingcs_remove(struct pcmcia_device *pcmcia) 218 + static void softingcs_remove(struct pcmcia_device *pcmcia) 219 219 { 220 220 struct platform_device *pdev = pcmcia->priv; 221 221 ··· 235 235 kfree(pdev); 236 236 } 237 237 238 - static __devinit int softingcs_probe(struct pcmcia_device *pcmcia) 238 + static int softingcs_probe(struct pcmcia_device *pcmcia) 239 239 { 240 240 int ret; 241 241 struct platform_device *pdev; ··· 338 338 .name = "softingcs", 339 339 .id_table = softingcs_ids, 340 340 .probe = softingcs_probe, 341 - .remove = __devexit_p(softingcs_remove), 341 + .remove = softingcs_remove, 342 342 }; 343 343 344 344 static int __init softingcs_start(void)
+6 -6
drivers/net/can/softing/softing_main.c
··· 478 478 mutex_unlock(&card->fw.lock); 479 479 } 480 480 481 - static __devinit int softing_card_boot(struct softing *card) 481 + static int softing_card_boot(struct softing *card) 482 482 { 483 483 int ret, j; 484 484 static const uint8_t stream[] = { ··· 645 645 }; 646 646 647 647 648 - static __devinit struct net_device *softing_netdev_create(struct softing *card, 648 + static struct net_device *softing_netdev_create(struct softing *card, 649 649 uint16_t chip_id) 650 650 { 651 651 struct net_device *netdev; ··· 676 676 return netdev; 677 677 } 678 678 679 - static __devinit int softing_netdev_register(struct net_device *netdev) 679 + static int softing_netdev_register(struct net_device *netdev) 680 680 { 681 681 int ret; 682 682 ··· 745 745 /* 746 746 * platform driver 747 747 */ 748 - static __devexit int softing_pdev_remove(struct platform_device *pdev) 748 + static int softing_pdev_remove(struct platform_device *pdev) 749 749 { 750 750 struct softing *card = platform_get_drvdata(pdev); 751 751 int j; ··· 766 766 return 0; 767 767 } 768 768 769 - static __devinit int softing_pdev_probe(struct platform_device *pdev) 769 + static int softing_pdev_probe(struct platform_device *pdev) 770 770 { 771 771 const struct softing_platform_data *pdat = pdev->dev.platform_data; 772 772 struct softing *card; ··· 871 871 .owner = THIS_MODULE, 872 872 }, 873 873 .probe = softing_pdev_probe, 874 - .remove = __devexit_p(softing_pdev_remove), 874 + .remove = softing_pdev_remove, 875 875 }; 876 876 877 877 module_platform_driver(softing_driver);
+2 -2
drivers/net/can/ti_hecc.c
··· 978 978 return err; 979 979 } 980 980 981 - static int __devexit ti_hecc_remove(struct platform_device *pdev) 981 + static int ti_hecc_remove(struct platform_device *pdev) 982 982 { 983 983 struct resource *res; 984 984 struct net_device *ndev = platform_get_drvdata(pdev); ··· 1045 1045 .owner = THIS_MODULE, 1046 1046 }, 1047 1047 .probe = ti_hecc_probe, 1048 - .remove = __devexit_p(ti_hecc_remove), 1048 + .remove = ti_hecc_remove, 1049 1049 .suspend = ti_hecc_suspend, 1050 1050 .resume = ti_hecc_resume, 1051 1051 };