canid_t mb0_id;
 };
 
-static const struct at91_devtype_data at91_devtype_data[] __devinitconst = {
+static const struct at91_devtype_data at91_devtype_data[] = {
        [AT91_DEVTYPE_SAM9263] = {
                .rx_first = 1,
                .rx_split = 8,
        .attrs = at91_sysfs_attrs,
 };
 
-static int __devinit at91_can_probe(struct platform_device *pdev)
+static int at91_can_probe(struct platform_device *pdev)
 {
        const struct at91_devtype_data *devtype_data;
        enum at91_devtype devtype;
        return err;
 }
 
-static int __devexit at91_can_remove(struct platform_device *pdev)
+static int at91_can_remove(struct platform_device *pdev)
 {
        struct net_device *dev = platform_get_drvdata(pdev);
        struct at91_priv *priv = netdev_priv(dev);
 
 static struct platform_driver at91_can_driver = {
        .probe = at91_can_probe,
-       .remove = __devexit_p(at91_can_remove),
+       .remove = at91_can_remove,
        .driver = {
                .name = KBUILD_MODNAME,
                .owner = THIS_MODULE,
 
        .ndo_start_xmit         = bfin_can_start_xmit,
 };
 
-static int __devinit bfin_can_probe(struct platform_device *pdev)
+static int bfin_can_probe(struct platform_device *pdev)
 {
        int err;
        struct net_device *dev;
        return err;
 }
 
-static int __devexit bfin_can_remove(struct platform_device *pdev)
+static int bfin_can_remove(struct platform_device *pdev)
 {
        struct net_device *dev = dev_get_drvdata(&pdev->dev);
        struct bfin_can_priv *priv = netdev_priv(dev);
 
 static struct platform_driver bfin_can_driver = {
        .probe = bfin_can_probe,
-       .remove = __devexit_p(bfin_can_remove),
+       .remove = bfin_can_remove,
        .suspend = bfin_can_suspend,
        .resume = bfin_can_resume,
        .driver = {
 
        writew(val, priv->base + 2 * priv->regs[index]);
 }
 
-static int __devinit c_can_pci_probe(struct pci_dev *pdev,
+static int c_can_pci_probe(struct pci_dev *pdev,
                                     const struct pci_device_id *ent)
 {
        struct c_can_pci_data *c_can_pci_data = (void *)ent->driver_data;
        return ret;
 }
 
-static void __devexit c_can_pci_remove(struct pci_dev *pdev)
+static void c_can_pci_remove(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
        struct c_can_priv *priv = netdev_priv(dev);
        .name = KBUILD_MODNAME,
        .id_table = c_can_pci_tbl,
        .probe = c_can_pci_probe,
-       .remove = __devexit_p(c_can_pci_remove),
+       .remove = c_can_pci_remove,
 };
 
 module_pci_driver(c_can_pci_driver);
 
 };
 MODULE_DEVICE_TABLE(of, c_can_of_table);
 
-static int __devinit c_can_plat_probe(struct platform_device *pdev)
+static int c_can_plat_probe(struct platform_device *pdev)
 {
        int ret;
        void __iomem *addr;
        return ret;
 }
 
-static int __devexit c_can_plat_remove(struct platform_device *pdev)
+static int c_can_plat_remove(struct platform_device *pdev)
 {
        struct net_device *dev = platform_get_drvdata(pdev);
        struct c_can_priv *priv = netdev_priv(dev);
                .of_match_table = of_match_ptr(c_can_of_table),
        },
        .probe = c_can_plat_probe,
-       .remove = __devexit_p(c_can_plat_remove),
+       .remove = c_can_plat_remove,
        .suspend = c_can_suspend,
        .resume = c_can_resume,
        .id_table = c_can_id_table,
 
 
 static unsigned long port[MAXDEV];
 static unsigned long mem[MAXDEV];
-static int __devinitdata irq[MAXDEV];
-static int __devinitdata clk[MAXDEV];
-static u8 __devinitdata cir[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
-static u8 __devinitdata cor[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
-static u8 __devinitdata bcr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
-static int __devinitdata indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
+static int irq[MAXDEV];
+static int clk[MAXDEV];
+static u8 cir[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
+static u8 cor[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
+static u8 bcr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
+static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
 
 module_param_array(port, ulong, NULL, S_IRUGO);
 MODULE_PARM_DESC(port, "I/O port number");
        spin_unlock_irqrestore(&cc770_isa_port_lock, flags);
 }
 
-static int __devinit cc770_isa_probe(struct platform_device *pdev)
+static int cc770_isa_probe(struct platform_device *pdev)
 {
        struct net_device *dev;
        struct cc770_priv *priv;
        return err;
 }
 
-static int __devexit cc770_isa_remove(struct platform_device *pdev)
+static int cc770_isa_remove(struct platform_device *pdev)
 {
        struct net_device *dev = dev_get_drvdata(&pdev->dev);
        struct cc770_priv *priv = netdev_priv(dev);
 
 static struct platform_driver cc770_isa_driver = {
        .probe = cc770_isa_probe,
-       .remove = __devexit_p(cc770_isa_remove),
+       .remove = cc770_isa_remove,
        .driver = {
                .name = KBUILD_MODNAME,
                .owner = THIS_MODULE,
 
        iowrite8(val, priv->reg_base + reg);
 }
 
-static int __devinit cc770_get_of_node_data(struct platform_device *pdev,
+static int cc770_get_of_node_data(struct platform_device *pdev,
                                            struct cc770_priv *priv)
 {
        struct device_node *np = pdev->dev.of_node;
        return 0;
 }
 
-static int __devinit cc770_get_platform_data(struct platform_device *pdev,
+static int cc770_get_platform_data(struct platform_device *pdev,
                                             struct cc770_priv *priv)
 {
 
        return 0;
 }
 
-static int __devinit cc770_platform_probe(struct platform_device *pdev)
+static int cc770_platform_probe(struct platform_device *pdev)
 {
        struct net_device *dev;
        struct cc770_priv *priv;
        return err;
 }
 
-static int __devexit cc770_platform_remove(struct platform_device *pdev)
+static int cc770_platform_remove(struct platform_device *pdev)
 {
        struct net_device *dev = dev_get_drvdata(&pdev->dev);
        struct cc770_priv *priv = netdev_priv(dev);
        return 0;
 }
 
-static struct of_device_id __devinitdata cc770_platform_table[] = {
+static struct of_device_id cc770_platform_table[] = {
        {.compatible = "bosch,cc770"}, /* CC770 from Bosch */
        {.compatible = "intc,82527"},  /* AN82527 from Intel CP */
        {},
                .of_match_table = cc770_platform_table,
        },
        .probe = cc770_platform_probe,
-       .remove = __devexit_p(cc770_platform_remove),
+       .remove = cc770_platform_remove,
 };
 
 module_platform_driver(cc770_platform_driver);
 
        .ndo_start_xmit = flexcan_start_xmit,
 };
 
-static int __devinit register_flexcandev(struct net_device *dev)
+static int register_flexcandev(struct net_device *dev)
 {
        struct flexcan_priv *priv = netdev_priv(dev);
        struct flexcan_regs __iomem *regs = priv->base;
        return err;
 }
 
-static void __devexit unregister_flexcandev(struct net_device *dev)
+static void unregister_flexcandev(struct net_device *dev)
 {
        unregister_candev(dev);
 }
 };
 MODULE_DEVICE_TABLE(platform, flexcan_id_table);
 
-static int __devinit flexcan_probe(struct platform_device *pdev)
+static int flexcan_probe(struct platform_device *pdev)
 {
        const struct of_device_id *of_id;
        const struct flexcan_devtype_data *devtype_data;
        return err;
 }
 
-static int __devexit flexcan_remove(struct platform_device *pdev)
+static int flexcan_remove(struct platform_device *pdev)
 {
        struct net_device *dev = platform_get_drvdata(pdev);
        struct flexcan_priv *priv = netdev_priv(dev);
                .of_match_table = flexcan_of_match,
        },
        .probe = flexcan_probe,
-       .remove = __devexit_p(flexcan_remove),
+       .remove = flexcan_remove,
        .suspend = flexcan_suspend,
        .resume = flexcan_resume,
        .id_table = flexcan_id_table,
 
        return err;
 }
 
-static int __devinit grcan_probe(struct platform_device *ofdev)
+static int grcan_probe(struct platform_device *ofdev)
 {
        struct device_node *np = ofdev->dev.of_node;
        struct resource *res;
        return err;
 }
 
-static int __devexit grcan_remove(struct platform_device *ofdev)
+static int grcan_remove(struct platform_device *ofdev)
 {
        struct net_device *dev = dev_get_drvdata(&ofdev->dev);
        struct grcan_priv *priv = netdev_priv(dev);
        return 0;
 }
 
-static struct of_device_id grcan_match[] __devinitconst = {
+static struct of_device_id grcan_match[] = {
        {.name = "GAISLER_GRCAN"},
        {.name = "01_03d"},
        {.name = "GAISLER_GRHCAN"},
                .of_match_table = grcan_match,
        },
        .probe = grcan_probe,
-       .remove = __devexit_p(grcan_remove),
+       .remove = grcan_remove,
 };
 
 module_platform_driver(grcan_driver);
 
  * ICAN3 "new-style" Host Interface Setup
  */
 
-static void __devinit ican3_init_new_host_interface(struct ican3_dev *mod)
+static void ican3_init_new_host_interface(struct ican3_dev *mod)
 {
        struct ican3_new_desc desc;
        unsigned long flags;
  * ICAN3 Fast Host Interface Setup
  */
 
-static void __devinit ican3_init_fast_host_interface(struct ican3_dev *mod)
+static void ican3_init_fast_host_interface(struct ican3_dev *mod)
 {
        struct ican3_fast_desc desc;
        unsigned long flags;
  * Quick Pre-constructed Messages
  */
 
-static int __devinit ican3_msg_connect(struct ican3_dev *mod)
+static int ican3_msg_connect(struct ican3_dev *mod)
 {
        struct ican3_msg msg;
 
        return ican3_send_msg(mod, &msg);
 }
 
-static int __devexit ican3_msg_disconnect(struct ican3_dev *mod)
+static int ican3_msg_disconnect(struct ican3_dev *mod)
 {
        struct ican3_msg msg;
 
        return ican3_send_msg(mod, &msg);
 }
 
-static int __devinit ican3_msg_newhostif(struct ican3_dev *mod)
+static int ican3_msg_newhostif(struct ican3_dev *mod)
 {
        struct ican3_msg msg;
        int ret;
        return 0;
 }
 
-static int __devinit ican3_msg_fasthostif(struct ican3_dev *mod)
+static int ican3_msg_fasthostif(struct ican3_dev *mod)
 {
        struct ican3_msg msg;
        unsigned int addr;
  * Setup the CAN filter to either accept or reject all
  * messages from the CAN bus.
  */
-static int __devinit ican3_set_id_filter(struct ican3_dev *mod, bool accept)
+static int ican3_set_id_filter(struct ican3_dev *mod, bool accept)
 {
        struct ican3_msg msg;
        int ret;
        return -ETIMEDOUT;
 }
 
-static void __devexit ican3_shutdown_module(struct ican3_dev *mod)
+static void ican3_shutdown_module(struct ican3_dev *mod)
 {
        ican3_msg_disconnect(mod);
        ican3_reset_module(mod);
 /*
  * Startup an ICAN module, bringing it into fast mode
  */
-static int __devinit ican3_startup_module(struct ican3_dev *mod)
+static int ican3_startup_module(struct ican3_dev *mod)
 {
        int ret;
 
  * PCI Subsystem
  */
 
-static int __devinit ican3_probe(struct platform_device *pdev)
+static int ican3_probe(struct platform_device *pdev)
 {
        struct janz_platform_data *pdata;
        struct net_device *ndev;
        return ret;
 }
 
-static int __devexit ican3_remove(struct platform_device *pdev)
+static int ican3_remove(struct platform_device *pdev)
 {
        struct net_device *ndev = platform_get_drvdata(pdev);
        struct ican3_dev *mod = netdev_priv(ndev);
                .owner  = THIS_MODULE,
        },
        .probe          = ican3_probe,
-       .remove         = __devexit_p(ican3_remove),
+       .remove         = ican3_remove,
 };
 
 module_platform_driver(ican3_driver);
 
        .ndo_start_xmit = mcp251x_hard_start_xmit,
 };
 
-static int __devinit mcp251x_can_probe(struct spi_device *spi)
+static int mcp251x_can_probe(struct spi_device *spi)
 {
        struct net_device *net;
        struct mcp251x_priv *priv;
        return ret;
 }
 
-static int __devexit mcp251x_can_remove(struct spi_device *spi)
+static int mcp251x_can_remove(struct spi_device *spi)
 {
        struct mcp251x_platform_data *pdata = spi->dev.platform_data;
        struct mcp251x_priv *priv = dev_get_drvdata(&spi->dev);
 
        .id_table = mcp251x_id_table,
        .probe = mcp251x_can_probe,
-       .remove = __devexit_p(mcp251x_can_remove),
+       .remove = mcp251x_can_remove,
        .suspend = mcp251x_can_suspend,
        .resume = mcp251x_can_resume,
 };
 
 };
 
 #ifdef CONFIG_PPC_MPC52xx
-static struct of_device_id __devinitdata mpc52xx_cdm_ids[] = {
+static struct of_device_id mpc52xx_cdm_ids[] = {
        { .compatible = "fsl,mpc5200-cdm", },
        {}
 };
 
-static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
+static u32 mpc52xx_can_get_clock(struct platform_device *ofdev,
                                           const char *clock_name,
                                           int *mscan_clksrc)
 {
        return freq;
 }
 #else /* !CONFIG_PPC_MPC52xx */
-static u32 __devinit mpc52xx_can_get_clock(struct platform_device *ofdev,
+static u32 mpc52xx_can_get_clock(struct platform_device *ofdev,
                                           const char *clock_name,
                                           int *mscan_clksrc)
 {
        u32 mccr[4];            /* MSCAN Clk Ctrl Reg 1-3 */
 };
 
-static struct of_device_id __devinitdata mpc512x_clock_ids[] = {
+static struct of_device_id mpc512x_clock_ids[] = {
        { .compatible = "fsl,mpc5121-clock", },
        {}
 };
 
-static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
+static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
                                           const char *clock_name,
                                           int *mscan_clksrc)
 {
        return freq;
 }
 #else /* !CONFIG_PPC_MPC512x */
-static u32 __devinit mpc512x_can_get_clock(struct platform_device *ofdev,
+static u32 mpc512x_can_get_clock(struct platform_device *ofdev,
                                           const char *clock_name,
                                           int *mscan_clksrc)
 {
 #endif /* CONFIG_PPC_MPC512x */
 
 static const struct of_device_id mpc5xxx_can_table[];
-static int __devinit mpc5xxx_can_probe(struct platform_device *ofdev)
+static int mpc5xxx_can_probe(struct platform_device *ofdev)
 {
        const struct of_device_id *match;
        const struct mpc5xxx_can_data *data;
        return err;
 }
 
-static int __devexit mpc5xxx_can_remove(struct platform_device *ofdev)
+static int mpc5xxx_can_remove(struct platform_device *ofdev)
 {
        struct net_device *dev = dev_get_drvdata(&ofdev->dev);
        struct mscan_priv *priv = netdev_priv(dev);
 }
 #endif
 
-static const struct mpc5xxx_can_data __devinitconst mpc5200_can_data = {
+static const struct mpc5xxx_can_data mpc5200_can_data = {
        .type = MSCAN_TYPE_MPC5200,
        .get_clock = mpc52xx_can_get_clock,
 };
 
-static const struct mpc5xxx_can_data __devinitconst mpc5121_can_data = {
+static const struct mpc5xxx_can_data mpc5121_can_data = {
        .type = MSCAN_TYPE_MPC5121,
        .get_clock = mpc512x_can_get_clock,
 };
 
-static const struct of_device_id __devinitconst mpc5xxx_can_table[] = {
+static const struct of_device_id mpc5xxx_can_table[] = {
        { .compatible = "fsl,mpc5200-mscan", .data = &mpc5200_can_data, },
        /* Note that only MPC5121 Rev. 2 (and later) is supported */
        { .compatible = "fsl,mpc5121-mscan", .data = &mpc5121_can_data, },
                .of_match_table = mpc5xxx_can_table,
        },
        .probe = mpc5xxx_can_probe,
-       .remove = __devexit_p(mpc5xxx_can_remove),
+       .remove = mpc5xxx_can_remove,
 #ifdef CONFIG_PM
        .suspend = mpc5xxx_can_suspend,
        .resume = mpc5xxx_can_resume,
 
        .ndo_start_xmit         = pch_xmit,
 };
 
-static void __devexit pch_can_remove(struct pci_dev *pdev)
+static void pch_can_remove(struct pci_dev *pdev)
 {
        struct net_device *ndev = pci_get_drvdata(pdev);
        struct pch_can_priv *priv = netdev_priv(ndev);
        return 0;
 }
 
-static int __devinit pch_can_probe(struct pci_dev *pdev,
+static int pch_can_probe(struct pci_dev *pdev,
                                   const struct pci_device_id *id)
 {
        struct net_device *ndev;
        .name = "pch_can",
        .id_table = pch_pci_tbl,
        .probe = pch_can_probe,
-       .remove = __devexit_p(pch_can_remove),
+       .remove = pch_can_remove,
        .suspend = pch_can_suspend,
        .resume = pch_can_resume,
 };
 
  * Probe PCI device for EMS CAN signature and register each available
  * CAN channel to SJA1000 Socket-CAN subsystem.
  */
-static int __devinit ems_pci_add_card(struct pci_dev *pdev,
+static int ems_pci_add_card(struct pci_dev *pdev,
                                        const struct pci_device_id *ent)
 {
        struct sja1000_priv *priv;
 
  * Probe PCI device for EMS CAN signature and register each available
  * CAN channel to SJA1000 Socket-CAN subsystem.
  */
-static int __devinit ems_pcmcia_add_card(struct pcmcia_device *pdev,
+static int ems_pcmcia_add_card(struct pcmcia_device *pdev,
                                         unsigned long base)
 {
        struct sja1000_priv *priv;
 /*
  * Setup PCMCIA socket and probe for EMS CPC-CARD
  */
-static int __devinit ems_pcmcia_probe(struct pcmcia_device *dev)
+static int ems_pcmcia_probe(struct pcmcia_device *dev)
 {
        int csval;
 
 
        return err;
 }
 
-static int __devinit kvaser_pci_init_one(struct pci_dev *pdev,
+static int kvaser_pci_init_one(struct pci_dev *pdev,
                                         const struct pci_device_id *ent)
 {
        int err;
 
 }
 
-static void __devexit kvaser_pci_remove_one(struct pci_dev *pdev)
+static void kvaser_pci_remove_one(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
 
        .name = DRV_NAME,
        .id_table = kvaser_pci_tbl,
        .probe = kvaser_pci_init_one,
-       .remove = __devexit_p(kvaser_pci_remove_one),
+       .remove = kvaser_pci_remove_one,
 };
 
 module_pci_driver(kvaser_pci_driver);
 
                writew(chan->icr_mask, chan->cfg_base + PITA_ICR);
 }
 
-static int __devinit peak_pci_probe(struct pci_dev *pdev,
+static int peak_pci_probe(struct pci_dev *pdev,
                                    const struct pci_device_id *ent)
 {
        struct sja1000_priv *priv;
        return err;
 }
 
-static void __devexit peak_pci_remove(struct pci_dev *pdev)
+static void peak_pci_remove(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev); /* Last device */
        struct sja1000_priv *priv = netdev_priv(dev);
        .name = DRV_NAME,
        .id_table = peak_pci_tbl,
        .probe = peak_pci_probe,
-       .remove = __devexit_p(peak_pci_remove),
+       .remove = peak_pci_remove,
 };
 
 module_pci_driver(peak_pci_driver);
 
 /*
  * setup PCMCIA socket and probe for PEAK-System PC-CARD
  */
-static int __devinit pcan_probe(struct pcmcia_device *pdev)
+static int pcan_probe(struct pcmcia_device *pdev)
 {
        struct pcan_pccard *card;
        int err;
 
        void (*reset_func)(struct pci_dev *pdev);
 };
 
-static struct plx_pci_card_info plx_pci_card_info_adlink __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_adlink = {
        "Adlink PCI-7841/cPCI-7841", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {1, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} },
        /* based on PLX9052 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_adlink_se __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_adlink_se = {
        "Adlink PCI-7841/cPCI-7841 SE", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x80, 0x80} },
        /* based on PLX9052 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_esd200 __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_esd200 = {
        "esd CAN-PCI/CPCI/PCI104/200", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} },
        /* based on PLX9030/9050 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_esd266 __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_esd266 = {
        "esd CAN-PCI/PMC/266", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} },
        /* based on PLX9056 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_esd2000 __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_esd2000 = {
        "esd CAN-PCIe/2000", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x100, 0x80} },
        /* based on PEX8311 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_ixxat __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_ixxat = {
        "IXXAT PC-I 04/PCI", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x00, 0x80}, {2, 0x200, 0x80} },
        /* based on PLX9050 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_marathon __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_marathon = {
        "Marathon CAN-bus-PCI", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x00, 0x00}, {4, 0x00, 0x00} },
        /* based on PLX9052 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_tews __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_tews = {
        "TEWS TECHNOLOGIES TPMC810", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} },
        /* based on PLX9030 */
 };
 
-static struct plx_pci_card_info plx_pci_card_info_cti __devinitdata = {
+static struct plx_pci_card_info plx_pci_card_info_cti = {
        "Connect Tech Inc. CANpro/104-Plus Opto (CRG001)", 2,
        PLX_PCI_CAN_CLOCK, PLX_PCI_OCR, PLX_PCI_CDR,
        {0, 0x00, 0x00}, { {2, 0x000, 0x80}, {2, 0x100, 0x80} },
  * Probe PLX90xx based device for the SJA1000 chips and register each
  * available CAN channel to SJA1000 Socket-CAN subsystem.
  */
-static int __devinit plx_pci_add_card(struct pci_dev *pdev,
+static int plx_pci_add_card(struct pci_dev *pdev,
                                      const struct pci_device_id *ent)
 {
        struct sja1000_priv *priv;
 
 
 static unsigned long port[MAXDEV];
 static unsigned long mem[MAXDEV];
-static int __devinitdata irq[MAXDEV];
-static int __devinitdata clk[MAXDEV];
-static unsigned char __devinitdata cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
-static unsigned char __devinitdata ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
-static int __devinitdata indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
+static int irq[MAXDEV];
+static int clk[MAXDEV];
+static unsigned char cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
+static unsigned char ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
+static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
 
 module_param_array(port, ulong, NULL, S_IRUGO);
 MODULE_PARM_DESC(port, "I/O port number");
        outb(val, base + 1);
 }
 
-static int __devinit sja1000_isa_probe(struct platform_device *pdev)
+static int sja1000_isa_probe(struct platform_device *pdev)
 {
        struct net_device *dev;
        struct sja1000_priv *priv;
        return err;
 }
 
-static int __devexit sja1000_isa_remove(struct platform_device *pdev)
+static int sja1000_isa_remove(struct platform_device *pdev)
 {
        struct net_device *dev = dev_get_drvdata(&pdev->dev);
        struct sja1000_priv *priv = netdev_priv(dev);
 
 static struct platform_driver sja1000_isa_driver = {
        .probe = sja1000_isa_probe,
-       .remove = __devexit_p(sja1000_isa_remove),
+       .remove = sja1000_isa_remove,
        .driver = {
                .name = DRV_NAME,
                .owner = THIS_MODULE,
 
        iowrite8(val, priv->reg_base + reg);
 }
 
-static int __devexit sja1000_ofp_remove(struct platform_device *ofdev)
+static int sja1000_ofp_remove(struct platform_device *ofdev)
 {
        struct net_device *dev = dev_get_drvdata(&ofdev->dev);
        struct sja1000_priv *priv = netdev_priv(dev);
        return 0;
 }
 
-static int __devinit sja1000_ofp_probe(struct platform_device *ofdev)
+static int sja1000_ofp_probe(struct platform_device *ofdev)
 {
        struct device_node *np = ofdev->dev.of_node;
        struct net_device *dev;
        return err;
 }
 
-static struct of_device_id __devinitdata sja1000_ofp_table[] = {
+static struct of_device_id sja1000_ofp_table[] = {
        {.compatible = "nxp,sja1000"},
        {},
 };
                .of_match_table = sja1000_ofp_table,
        },
        .probe = sja1000_ofp_probe,
-       .remove = __devexit_p(sja1000_ofp_remove),
+       .remove = sja1000_ofp_remove,
 };
 
 module_platform_driver(sja1000_ofp_driver);
 
 #define TSCAN1_SJA1000_XTAL 16000000
 
 /* SJA1000 IO base addresses */
-static const unsigned short tscan1_sja1000_addresses[] __devinitconst = {
+static const unsigned short tscan1_sja1000_addresses[] = {
        0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320
 };
 
 }
 
 /* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */
-static int __devinit tscan1_probe(struct device *dev, unsigned id)
+static int tscan1_probe(struct device *dev, unsigned id)
 {
        struct net_device *netdev;
        struct sja1000_priv *priv;
        return -ENXIO;
 }
 
-static int __devexit tscan1_remove(struct device *dev, unsigned id /*unused*/)
+static int tscan1_remove(struct device *dev, unsigned id /*unused*/)
 {
        struct net_device *netdev;
        struct sja1000_priv *priv;
 
 static struct isa_driver tscan1_isa_driver = {
        .probe = tscan1_probe,
-       .remove = __devexit_p(tscan1_remove),
+       .remove = tscan1_remove,
        .driver = {
                .name = "tscan1",
        },
 
 MODULE_FIRMWARE(fw_dir "ldcard2.bin");
 MODULE_FIRMWARE(fw_dir "cancrd2.bin");
 
-static __devinit const struct softing_platform_data
+static const struct softing_platform_data
 *softingcs_find_platform_data(unsigned int manf, unsigned int prod)
 {
        const struct softing_platform_data *lp;
 /*
  * pcmcia check
  */
-static __devinit int softingcs_probe_config(struct pcmcia_device *pcmcia,
+static int softingcs_probe_config(struct pcmcia_device *pcmcia,
                void *priv_data)
 {
        struct softing_platform_data *pdat = priv_data;
        return pcmcia_request_window(pcmcia, pres, memspeed);
 }
 
-static __devexit void softingcs_remove(struct pcmcia_device *pcmcia)
+static void softingcs_remove(struct pcmcia_device *pcmcia)
 {
        struct platform_device *pdev = pcmcia->priv;
 
        kfree(pdev);
 }
 
-static __devinit int softingcs_probe(struct pcmcia_device *pcmcia)
+static int softingcs_probe(struct pcmcia_device *pcmcia)
 {
        int ret;
        struct platform_device *pdev;
        .name           = "softingcs",
        .id_table       = softingcs_ids,
        .probe          = softingcs_probe,
-       .remove         = __devexit_p(softingcs_remove),
+       .remove         = softingcs_remove,
 };
 
 static int __init softingcs_start(void)
 
        mutex_unlock(&card->fw.lock);
 }
 
-static __devinit int softing_card_boot(struct softing *card)
+static int softing_card_boot(struct softing *card)
 {
        int ret, j;
        static const uint8_t stream[] = {
 };
 
 
-static __devinit struct net_device *softing_netdev_create(struct softing *card,
+static struct net_device *softing_netdev_create(struct softing *card,
                uint16_t chip_id)
 {
        struct net_device *netdev;
        return netdev;
 }
 
-static __devinit int softing_netdev_register(struct net_device *netdev)
+static int softing_netdev_register(struct net_device *netdev)
 {
        int ret;
 
 /*
  * platform driver
  */
-static __devexit int softing_pdev_remove(struct platform_device *pdev)
+static int softing_pdev_remove(struct platform_device *pdev)
 {
        struct softing *card = platform_get_drvdata(pdev);
        int j;
        return 0;
 }
 
-static __devinit int softing_pdev_probe(struct platform_device *pdev)
+static int softing_pdev_probe(struct platform_device *pdev)
 {
        const struct softing_platform_data *pdat = pdev->dev.platform_data;
        struct softing *card;
                .owner = THIS_MODULE,
        },
        .probe = softing_pdev_probe,
-       .remove = __devexit_p(softing_pdev_remove),
+       .remove = softing_pdev_remove,
 };
 
 module_platform_driver(softing_driver);
 
        return err;
 }
 
-static int __devexit ti_hecc_remove(struct platform_device *pdev)
+static int ti_hecc_remove(struct platform_device *pdev)
 {
        struct resource *res;
        struct net_device *ndev = platform_get_drvdata(pdev);
                .owner   = THIS_MODULE,
        },
        .probe = ti_hecc_probe,
-       .remove = __devexit_p(ti_hecc_remove),
+       .remove = ti_hecc_remove,
        .suspend = ti_hecc_suspend,
        .resume = ti_hecc_resume,
 };