#define DRV_MODULE_VERSION     "1.1"
 #define DRV_MODULE_RELDATE     "Apr 22, 2010"
 
-static char version[] __devinitdata =
+static char version[] =
        DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 
 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
        return 0;
 }
 
-static int __devinit niu_pci_eeprom_read(struct niu *np, u32 addr)
+static int niu_pci_eeprom_read(struct niu *np, u32 addr)
 {
        u64 frame, frame_base = (ESPC_PIO_STAT_READ_START |
                                 (addr << ESPC_PIO_STAT_ADDR_SHIFT));
        return (frame & ESPC_PIO_STAT_DATA) >> ESPC_PIO_STAT_DATA_SHIFT;
 }
 
-static int __devinit niu_pci_eeprom_read16(struct niu *np, u32 off)
+static int niu_pci_eeprom_read16(struct niu *np, u32 off)
 {
        int err = niu_pci_eeprom_read(np, off);
        u16 val;
        return val;
 }
 
-static int __devinit niu_pci_eeprom_read16_swp(struct niu *np, u32 off)
+static int niu_pci_eeprom_read16_swp(struct niu *np, u32 off)
 {
        int err = niu_pci_eeprom_read(np, off);
        u16 val;
        return val;
 }
 
-static int __devinit niu_pci_vpd_get_propname(struct niu *np,
+static int niu_pci_vpd_get_propname(struct niu *np,
                                              u32 off,
                                              char *namebuf,
                                              int namebuf_len)
        return i + 1;
 }
 
-static void __devinit niu_vpd_parse_version(struct niu *np)
+static void niu_vpd_parse_version(struct niu *np)
 {
        struct niu_vpd *vpd = &np->vpd;
        int len = strlen(vpd->version) + 1;
 }
 
 /* ESPC_PIO_EN_ENABLE must be set */
-static int __devinit niu_pci_vpd_scan_props(struct niu *np,
+static int niu_pci_vpd_scan_props(struct niu *np,
                                            u32 start, u32 end)
 {
        unsigned int found_mask = 0;
 }
 
 /* ESPC_PIO_EN_ENABLE must be set */
-static void __devinit niu_pci_vpd_fetch(struct niu *np, u32 start)
+static void niu_pci_vpd_fetch(struct niu *np, u32 start)
 {
        u32 offset;
        int err;
 }
 
 /* ESPC_PIO_EN_ENABLE must be set */
-static u32 __devinit niu_pci_vpd_offset(struct niu *np)
+static u32 niu_pci_vpd_offset(struct niu *np)
 {
        u32 start = 0, end = ESPC_EEPROM_SIZE, ret;
        int err;
        return 0;
 }
 
-static int __devinit niu_phy_type_prop_decode(struct niu *np,
+static int niu_phy_type_prop_decode(struct niu *np,
                                              const char *phy_prop)
 {
        if (!strcmp(phy_prop, "mif")) {
        return ports;
 }
 
-static void __devinit niu_pci_vpd_validate(struct niu *np)
+static void niu_pci_vpd_validate(struct niu *np)
 {
        struct net_device *dev = np->dev;
        struct niu_vpd *vpd = &np->vpd;
        memcpy(dev->dev_addr, dev->perm_addr, dev->addr_len);
 }
 
-static int __devinit niu_pci_probe_sprom(struct niu *np)
+static int niu_pci_probe_sprom(struct niu *np)
 {
        struct net_device *dev = np->dev;
        int len, i;
        return 0;
 }
 
-static int __devinit niu_get_and_validate_port(struct niu *np)
+static int niu_get_and_validate_port(struct niu *np)
 {
        struct niu_parent *parent = np->parent;
 
        return 0;
 }
 
-static int __devinit phy_record(struct niu_parent *parent,
+static int phy_record(struct niu_parent *parent,
                                struct phy_probe_info *p,
                                int dev_id_1, int dev_id_2, u8 phy_port,
                                int type)
        return 0;
 }
 
-static int __devinit port_has_10g(struct phy_probe_info *p, int port)
+static int port_has_10g(struct phy_probe_info *p, int port)
 {
        int i;
 
        return 0;
 }
 
-static int __devinit count_10g_ports(struct phy_probe_info *p, int *lowest)
+static int count_10g_ports(struct phy_probe_info *p, int *lowest)
 {
        int port, cnt;
 
        return cnt;
 }
 
-static int __devinit count_1g_ports(struct phy_probe_info *p, int *lowest)
+static int count_1g_ports(struct phy_probe_info *p, int *lowest)
 {
        *lowest = 32;
        if (p->cur[PHY_TYPE_MII])
        return p->cur[PHY_TYPE_MII];
 }
 
-static void __devinit niu_n2_divide_channels(struct niu_parent *parent)
+static void niu_n2_divide_channels(struct niu_parent *parent)
 {
        int num_ports = parent->num_ports;
        int i;
        }
 }
 
-static void __devinit niu_divide_channels(struct niu_parent *parent,
+static void niu_divide_channels(struct niu_parent *parent,
                                          int num_10g, int num_1g)
 {
        int num_ports = parent->num_ports;
        }
 }
 
-static void __devinit niu_divide_rdc_groups(struct niu_parent *parent,
+static void niu_divide_rdc_groups(struct niu_parent *parent,
                                            int num_10g, int num_1g)
 {
        int i, num_ports = parent->num_ports;
        }
 }
 
-static int __devinit fill_phy_probe_info(struct niu *np,
+static int fill_phy_probe_info(struct niu *np,
                                         struct niu_parent *parent,
                                         struct phy_probe_info *info)
 {
        return err;
 }
 
-static int __devinit walk_phys(struct niu *np, struct niu_parent *parent)
+static int walk_phys(struct niu *np, struct niu_parent *parent)
 {
        struct phy_probe_info *info = &parent->phy_probe_info;
        int lowest_10g, lowest_1g;
        return -EINVAL;
 }
 
-static int __devinit niu_probe_ports(struct niu *np)
+static int niu_probe_ports(struct niu *np)
 {
        struct niu_parent *parent = np->parent;
        int err, i;
        return 0;
 }
 
-static int __devinit niu_classifier_swstate_init(struct niu *np)
+static int niu_classifier_swstate_init(struct niu *np)
 {
        struct niu_classifier *cp = &np->clas;
 
        return fflp_early_init(np);
 }
 
-static void __devinit niu_link_config_init(struct niu *np)
+static void niu_link_config_init(struct niu *np)
 {
        struct niu_link_config *lp = &np->link_config;
 
 #endif
 }
 
-static int __devinit niu_init_mac_ipp_pcs_base(struct niu *np)
+static int niu_init_mac_ipp_pcs_base(struct niu *np)
 {
        switch (np->port) {
        case 0:
        return 0;
 }
 
-static void __devinit niu_try_msix(struct niu *np, u8 *ldg_num_map)
+static void niu_try_msix(struct niu *np, u8 *ldg_num_map)
 {
        struct msix_entry msi_vec[NIU_NUM_LDG];
        struct niu_parent *parent = np->parent;
        np->num_ldg = num_irqs;
 }
 
-static int __devinit niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
+static int niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
 {
 #ifdef CONFIG_SPARC64
        struct platform_device *op = np->op;
 #endif
 }
 
-static int __devinit niu_ldg_init(struct niu *np)
+static int niu_ldg_init(struct niu *np)
 {
        struct niu_parent *parent = np->parent;
        u8 ldg_num_map[NIU_NUM_LDG];
        return 0;
 }
 
-static void __devexit niu_ldg_free(struct niu *np)
+static void niu_ldg_free(struct niu *np)
 {
        if (np->flags & NIU_FLAGS_MSIX)
                pci_disable_msix(np->pdev);
 }
 
-static int __devinit niu_get_of_props(struct niu *np)
+static int niu_get_of_props(struct niu *np)
 {
 #ifdef CONFIG_SPARC64
        struct net_device *dev = np->dev;
 #endif
 }
 
-static int __devinit niu_get_invariants(struct niu *np)
+static int niu_get_invariants(struct niu *np)
 {
        int err, have_props;
        u32 offset;
        {}
 };
 
-static struct niu_parent * __devinit niu_new_parent(struct niu *np,
+static struct niu_parent *niu_new_parent(struct niu *np,
                                                    union niu_parent_id *id,
                                                    u8 ptype)
 {
        return NULL;
 }
 
-static struct niu_parent * __devinit niu_get_parent(struct niu *np,
+static struct niu_parent *niu_get_parent(struct niu *np,
                                                    union niu_parent_id *id,
                                                    u8 ptype)
 {
        .unmap_single   = niu_pci_unmap_single,
 };
 
-static void __devinit niu_driver_version(void)
+static void niu_driver_version(void)
 {
        static int niu_version_printed;
 
                pr_info("%s", version);
 }
 
-static struct net_device * __devinit niu_alloc_and_init(
+static struct net_device *niu_alloc_and_init(
        struct device *gen_dev, struct pci_dev *pdev,
        struct platform_device *op, const struct niu_ops *ops,
        u8 port)
        .ndo_change_mtu         = niu_change_mtu,
 };
 
-static void __devinit niu_assign_netdev_ops(struct net_device *dev)
+static void niu_assign_netdev_ops(struct net_device *dev)
 {
        dev->netdev_ops = &niu_netdev_ops;
        dev->ethtool_ops = &niu_ethtool_ops;
        dev->watchdog_timeo = NIU_TX_TIMEOUT;
 }
 
-static void __devinit niu_device_announce(struct niu *np)
+static void niu_device_announce(struct niu *np)
 {
        struct net_device *dev = np->dev;
 
        }
 }
 
-static void __devinit niu_set_basic_features(struct net_device *dev)
+static void niu_set_basic_features(struct net_device *dev)
 {
        dev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXHASH;
        dev->features |= dev->hw_features | NETIF_F_RXCSUM;
 }
 
-static int __devinit niu_pci_init_one(struct pci_dev *pdev,
+static int niu_pci_init_one(struct pci_dev *pdev,
                                      const struct pci_device_id *ent)
 {
        union niu_parent_id parent_id;
        return err;
 }
 
-static void __devexit niu_pci_remove_one(struct pci_dev *pdev)
+static void niu_pci_remove_one(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
 
        .name           = DRV_MODULE_NAME,
        .id_table       = niu_pci_tbl,
        .probe          = niu_pci_init_one,
-       .remove         = __devexit_p(niu_pci_remove_one),
+       .remove         = niu_pci_remove_one,
        .suspend        = niu_suspend,
        .resume         = niu_resume,
 };
        .unmap_single   = niu_phys_unmap_single,
 };
 
-static int __devinit niu_of_probe(struct platform_device *op)
+static int niu_of_probe(struct platform_device *op)
 {
        union niu_parent_id parent_id;
        struct net_device *dev;
        return err;
 }
 
-static int __devexit niu_of_remove(struct platform_device *op)
+static int niu_of_remove(struct platform_device *op)
 {
        struct net_device *dev = dev_get_drvdata(&op->dev);
 
                .of_match_table = niu_match,
        },
        .probe          = niu_of_probe,
-       .remove         = __devexit_p(niu_of_remove),
+       .remove         = niu_of_remove,
 };
 
 #endif /* CONFIG_SPARC64 */
 
  *
  * Return NULL on failure.
  */
-static struct quattro * __devinit quattro_sbus_find(struct platform_device *child)
+static struct quattro *quattro_sbus_find(struct platform_device *child)
 {
        struct device *parent = child->dev.parent;
        struct platform_device *op;
 #endif /* CONFIG_SBUS */
 
 #ifdef CONFIG_PCI
-static struct quattro * __devinit quattro_pci_find(struct pci_dev *pdev)
+static struct quattro *quattro_pci_find(struct pci_dev *pdev)
 {
        struct pci_dev *bdev = pdev->bus->self;
        struct quattro *qp;
 };
 
 #ifdef CONFIG_SBUS
-static int __devinit happy_meal_sbus_probe_one(struct platform_device *op, int is_qfe)
+static int happy_meal_sbus_probe_one(struct platform_device *op, int is_qfe)
 {
        struct device_node *dp = op->dev.of_node, *sbus_dp;
        struct quattro *qp = NULL;
 }
 #endif /* !(CONFIG_SPARC) */
 
-static int __devinit happy_meal_pci_probe(struct pci_dev *pdev,
+static int happy_meal_pci_probe(struct pci_dev *pdev,
                                          const struct pci_device_id *ent)
 {
        struct quattro *qp = NULL;
        return err;
 }
 
-static void __devexit happy_meal_pci_remove(struct pci_dev *pdev)
+static void happy_meal_pci_remove(struct pci_dev *pdev)
 {
        struct happy_meal *hp = dev_get_drvdata(&pdev->dev);
        struct net_device *net_dev = hp->dev;
        .name           = "hme",
        .id_table       = happymeal_pci_ids,
        .probe          = happy_meal_pci_probe,
-       .remove         = __devexit_p(happy_meal_pci_remove),
+       .remove         = happy_meal_pci_remove,
 };
 
 static int __init happy_meal_pci_init(void)
 
 #ifdef CONFIG_SBUS
 static const struct of_device_id hme_sbus_match[];
-static int __devinit hme_sbus_probe(struct platform_device *op)
+static int hme_sbus_probe(struct platform_device *op)
 {
        const struct of_device_id *match;
        struct device_node *dp = op->dev.of_node;
        return happy_meal_sbus_probe_one(op, is_qfe);
 }
 
-static int __devexit hme_sbus_remove(struct platform_device *op)
+static int hme_sbus_remove(struct platform_device *op)
 {
        struct happy_meal *hp = dev_get_drvdata(&op->dev);
        struct net_device *net_dev = hp->dev;
                .of_match_table = hme_sbus_match,
        },
        .probe          = hme_sbus_probe,
-       .remove         = __devexit_p(hme_sbus_remove),
+       .remove         = hme_sbus_remove,
 };
 
 static int __init happy_meal_sbus_init(void)