dev->ethtool_ops = &ne2k_pci_ethtool_ops;
        NS8390_init(dev, 0);
 
-       memcpy(dev->dev_addr, SA_prom, dev->addr_len);
+       eth_hw_addr_set(dev, SA_prom);
 
        i = register_netdev(dev);
        if (i)
 
        if (netif_running(netdev))
                return -EBUSY;
 
-       memcpy(netdev->dev_addr, skaddr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, skaddr->sa_data);
        owl_emac_set_hw_mac_addr(netdev);
 
        return owl_emac_setup_frame_xmit(netdev_priv(netdev));
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        GRETH_REGSAVE(regs->esa_msb, dev->dev_addr[0] << 8 | dev->dev_addr[1]);
        GRETH_REGSAVE(regs->esa_lsb, dev->dev_addr[2] << 24 | dev->dev_addr[3] << 16 |
                      dev->dev_addr[4] << 8 | dev->dev_addr[5]);
 
        if(netif_running(dev))
                return -EBUSY;
 
-       memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        da = (u8 *)dev->dev_addr;
 
 
        int i;
        struct sockaddr *addr = p;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        spin_lock_irq(&lp->lock);
        /* Setting the MAC address to the device */
        for (i = 0; i < ETH_ALEN; i++)
 
                return -EIO;
        }
 
-       memcpy( dev->dev_addr, saddr->sa_data, dev->addr_len );
+       eth_hw_addr_set(dev, saddr->sa_data);
        for( i = 0; i < 6; i++ )
                MEM->init.hwaddr[i] = dev->dev_addr[i^1]; /* <- 16 bit swap! */
        lp->memcpy_f( RIEBL_HWADDR_ADDR, dev->dev_addr, 6 );
 
        if (!is_valid_ether_addr(saddr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, saddr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, saddr->sa_data);
 
        hw_if->set_mac_address(pdata, netdev->dev_addr);
 
 
 
        netdev->irq = pdata->dev_irq;
        netdev->base_addr = (unsigned long)pdata->xgmac_regs;
-       memcpy(netdev->dev_addr, pdata->mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, pdata->mac_addr);
 
        /* Initialize ECC timestamps */
        pdata->tx_sec_period = jiffies;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, addr->sa_data);
 
        arc_emac_set_address_internal(ndev);
 
 
        if (netdev->addr_assign_type & NET_ADDR_RANDOM)
                netdev->addr_assign_type ^= NET_ADDR_RANDOM;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
        alx_set_macaddr(hw, hw->mac_addr);
 
 
        if (netif_running(netdev))
                return -EBUSY;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
 
        atl1c_hw_set_mac_addr(&adapter->hw, adapter->hw.mac_addr);
                /* got a random MAC address, set NET_ADDR_RANDOM to netdev */
                netdev->addr_assign_type = NET_ADDR_RANDOM;
        }
-       memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, adapter->hw.mac_addr);
        if (netif_msg_probe(adapter))
                dev_dbg(&pdev->dev, "mac address : %pM\n",
                        adapter->hw.mac_addr);
 
        if (netif_running(netdev))
                return -EBUSY;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
 
        atl1e_hw_set_mac_addr(&adapter->hw);
                goto err_eeprom;
        }
 
-       memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, adapter->hw.mac_addr);
        netdev_dbg(netdev, "mac address : %pM\n", adapter->hw.mac_addr);
 
        INIT_WORK(&adapter->reset_task, atl1e_reset_task);
 
                /* mark random mac */
                netdev->addr_assign_type = NET_ADDR_RANDOM;
        }
-       memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, adapter->hw.mac_addr);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                err = -EIO;
 
        if (netif_running(netdev))
                return -EBUSY;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
 
        atl2_set_mac_addr(&adapter->hw);
 
        /* copy the MAC address out of the EEPROM */
        atl2_read_mac_addr(&adapter->hw);
-       memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, adapter->hw.mac_addr);
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                err = -EIO;
                goto err_eeprom;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
 
        atlx_set_mac_addr(&adapter->hw);
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EINVAL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        spin_lock_irq(&bp->lock);
 
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EINVAL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        /* interface is disabled, changes to MAC will be reflected on next
         * open call
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        if (netif_running(dev))
                bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
 
 
                        return rc;
        }
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        if (netif_running(dev))
                rc = bnx2x_set_eth_mac(bp, true);
 
        if (rc)
                return rc;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        if (netif_running(dev)) {
                bnxt_close_nic(bp, false, false);
                rc = bnxt_open_nic(bp, false, false);
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        if (!netif_running(dev))
                return 0;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        xgmac_set_mac_addr(ioaddr, dev->dev_addr, 0);
 
 
                return -EIO;
        }
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(((u8 *)&lio->linfo.hw_addr) + 2, addr->sa_data, ETH_ALEN);
 
        return 0;
 
                return -EPERM;
        }
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        ether_addr_copy(((u8 *)&lio->linfo.hw_addr) + 2, addr->sa_data);
 
        return 0;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
 
        if (nic->pdev->msix_enabled) {
                if (nicvf_hw_set_mac_addr(nic, netdev))
 
        if (!mac->ops->macaddress_set)
                return -EOPNOTSUPP;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        mac->ops->macaddress_set(mac, dev->dev_addr);
        return 0;
 }
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        t3_mac_set_address(&pi->mac, LAN_MAC_IDX, dev->dev_addr);
        if (offload_running(adapter))
                write_smt_entry(adapter, pi->port_id);
 
        if (ret < 0)
                return ret;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        return 0;
 }
 
 
        if (ret < 0)
                return ret;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        return 0;
 }
 
 
        if (netif_running(dev))
                return -EBUSY;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
                 dev->name, dev->dev_addr);
 
                        return -EADDRNOTAVAIL;
        }
 
-       memcpy(netdev->dev_addr, addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr);
 
        return 0;
 }
 
 
        if (is_valid_ether_addr(mac_addr)) {
                memcpy(net_dev->perm_addr, mac_addr, net_dev->addr_len);
-               memcpy(net_dev->dev_addr, mac_addr, net_dev->addr_len);
+               eth_hw_addr_set(net_dev, mac_addr);
        } else {
                eth_hw_addr_random(net_dev);
                err = priv->mac_dev->change_addr(priv->mac_dev->fman_mac,
 
                                return err;
                        }
                }
-               memcpy(net_dev->dev_addr, mac_addr, net_dev->addr_len);
+               eth_hw_addr_set(net_dev, mac_addr);
        } else if (is_zero_ether_addr(dpni_mac_addr)) {
                /* No MAC address configured, fill in net_dev->dev_addr
                 * with a random one
                /* NET_ADDR_PERM is default, all we have to do is
                 * fill in the device addr.
                 */
-               memcpy(net_dev->dev_addr, dpni_mac_addr, net_dev->addr_len);
+               eth_hw_addr_set(net_dev, dpni_mac_addr);
        }
 
        return 0;
 
 
        /* First check if firmware has any address configured by bootloader */
        if (!is_zero_ether_addr(mac_addr)) {
-               memcpy(net_dev->dev_addr, mac_addr, net_dev->addr_len);
+               eth_hw_addr_set(net_dev, mac_addr);
        } else {
                /* No MAC address configured, fill in net_dev->dev_addr
                 * with a random one
 
        if (!is_valid_ether_addr(saddr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(ndev->dev_addr, saddr->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, saddr->sa_data);
        enetc_pf_set_primary_mac_addr(&priv->si->hw, 0, saddr->sa_data);
 
        return 0;
 
        if (addr) {
                if (!is_valid_ether_addr(addr->sa_data))
                        return -EADDRNOTAVAIL;
-               memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+               eth_hw_addr_set(ndev, addr->sa_data);
        }
 
        /* Add netif status check here to avoid system hang in below case:
 
 {
        struct sockaddr *sock = addr;
 
-       memcpy(dev->dev_addr, sock->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, sock->sa_data);
 
        mpc52xx_fec_set_paddr(dev, sock->sa_data);
        return 0;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        /*
         * If device is not running, we will set mac addr register
 
        if (!is_valid_ether_addr(skaddr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, skaddr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, skaddr->sa_data);
        dev->addr_assign_type &= ~NET_ADDR_RANDOM;
 
        hisi_femac_set_hw_mac_addr(priv, dev->dev_addr);
 
                return ret;
        }
 
-       memcpy(ndev->dev_addr, mac_addr->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, mac_addr->sa_data);
 
        return 0;
 }
 
                goto out_free;
        }
 
-       memcpy(dev->dev_addr, mac_addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, mac_addr->sa_data);
 
        /* Deregister old MAC in pHYP */
        if (port->state == EHEA_PORT_UP) {
 
 
        mutex_lock(&dev->link_lock);
 
-       memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, addr->sa_data);
 
        emac_rx_disable(dev);
        emac_tx_disable(dev);
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        e100_exec_cb(nic, NULL, e100_setup_iaaddr);
 
        return 0;
 
                        e_err(probe, "EEPROM Read Error\n");
        }
        /* don't block initialization here due to bad MAC address */
-       memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, hw->mac_addr);
 
        if (!is_valid_ether_addr(netdev->dev_addr))
                e_err(probe, "Invalid MAC Address\n");
        if (hw->mac_type == e1000_82542_rev2_0)
                e1000_enter_82542_rst(adapter);
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
 
        e1000_rar_set(hw, hw->mac_addr, 0);
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(adapter->hw.mac.addr, addr->sa_data, netdev->addr_len);
 
        hw->mac.ops.rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
                dev_err(&pdev->dev,
                        "NVM Read Error while reading MAC address\n");
 
-       memcpy(netdev->dev_addr, adapter->hw.mac.addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, adapter->hw.mac.addr);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                dev_err(&pdev->dev, "Invalid MAC Address: %pM\n",
 
        netif_addr_lock_bh(netdev);
        ether_addr_copy(old_mac, netdev->dev_addr);
        /* change the netdev's MAC address */
-       memcpy(netdev->dev_addr, mac, netdev->addr_len);
+       eth_hw_addr_set(netdev, mac);
        netif_addr_unlock_bh(netdev);
 
        /* Clean up old MAC filter. Not an error if old filter doesn't exist */
 
                        dev_err(&pdev->dev, "NVM Read Error\n");
        }
 
-       memcpy(netdev->dev_addr, hw->mac.addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, hw->mac.addr);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                dev_err(&pdev->dev, "Invalid MAC Address\n");
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);
 
        /* set the correct pool for the new PF MAC address in entry 0 */
 
        spin_unlock_bh(&hw->mbx_lock);
 
        if (is_valid_ether_addr(adapter->hw.mac.addr)) {
-               memcpy(netdev->dev_addr, adapter->hw.mac.addr,
-                      netdev->addr_len);
+               eth_hw_addr_set(netdev, adapter->hw.mac.addr);
                memcpy(netdev->perm_addr, adapter->hw.mac.addr,
                       netdev->addr_len);
        }
        if (!ether_addr_equal(addr->sa_data, hw->mac.addr))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
 
        return 0;
 }
                else if (is_zero_ether_addr(adapter->hw.mac.addr))
                        dev_info(&pdev->dev,
                                 "MAC address not assigned by administrator.\n");
-               memcpy(netdev->dev_addr, adapter->hw.mac.addr,
-                      netdev->addr_len);
+               eth_hw_addr_set(netdev, adapter->hw.mac.addr);
        }
 
        spin_unlock_bh(&hw->mbx_lock);
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);
 
        /* set the correct pool for the new PF MAC address in entry 0 */
                        dev_err(&pdev->dev, "NVM Read Error\n");
        }
 
-       memcpy(netdev->dev_addr, hw->mac.addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, hw->mac.addr);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                dev_err(&pdev->dev, "Invalid MAC Address\n");
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
 
        ixgb_rar_set(&adapter->hw, addr->sa_data, 0);
 
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);
 
        ixgbe_mac_set_default_filter(adapter);
        eth_platform_get_mac_address(&adapter->pdev->dev,
                                     adapter->hw.mac.perm_addr);
 
-       memcpy(netdev->dev_addr, hw->mac.perm_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, hw->mac.perm_addr);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                e_dev_err("invalid MAC address\n");
 
                return -EBUSY;
 
        spin_lock_bh(&jme->macaddr_lock);
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        jme_set_unicastaddr(netdev);
        spin_unlock_bh(&jme->macaddr_lock);
 
 
                return -EADDRNOTAVAIL;
 
        if (!otx2_hw_set_mac_addr(pfvf, addr->sa_data)) {
-               memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+               eth_hw_addr_set(netdev, addr->sa_data);
                /* update dmac field in vlan offload rule */
                if (netif_running(netdev) &&
                    pfvf->flags & OTX2_FLAG_RX_VLAN_SUPPORT)
 
        err = mlxsw_sp_port_dev_addr_set(mlxsw_sp_port, addr->sa_data);
        if (err)
                return err;
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        return 0;
 }
 
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, mac, netdev->addr_len);
+       eth_hw_addr_set(netdev, mac);
 
        ks8842_write_mac_addr(adapter, mac);
        return 0;
 
                if (i < netdev->addr_len)
                        /* an address was passed, use it */
-                       memcpy(netdev->dev_addr, pdata->macaddr,
-                               netdev->addr_len);
+                       eth_hw_addr_set(netdev, pdata->macaddr);
        }
 
        if (i == netdev->addr_len) {
 
        if (!is_valid_ether_addr(address->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, address->sa_data);
        return encx24j600_set_hw_macaddr(dev);
 }
 
 
        if (!is_valid_ether_addr(address->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(ndev->dev_addr, address->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, address->sa_data);
        moxart_update_mac_address(ndev);
 
        return 0;
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        /* store the MAC address in CAM */
        return do_s2io_prog_unicast(dev, dev->dev_addr);
 
        }
 
        if (unlikely(!is_vxge_card_up(vdev))) {
-               memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+               eth_hw_addr_set(dev, addr->sa_data);
                return VXGE_HW_OK;
        }
 
                        return -EINVAL;
        }
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        return status;
 }
 
        if (!is_valid_ether_addr(skaddr->sa_data)) {
                ret_val = -EADDRNOTAVAIL;
        } else {
-               memcpy(netdev->dev_addr, skaddr->sa_data, netdev->addr_len);
+               eth_hw_addr_set(netdev, skaddr->sa_data);
                memcpy(adapter->hw.mac.addr, skaddr->sa_data, netdev->addr_len);
                pch_gbe_mac_mar_set(&adapter->hw, adapter->hw.mac.addr, 0);
                ret_val = 0;
                goto err_free_adapter;
        }
 
-       memcpy(netdev->dev_addr, adapter->hw.mac.addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, adapter->hw.mac.addr);
        if (!is_valid_ether_addr(netdev->dev_addr)) {
                /*
                 * If the MAC is invalid (or just missing), display a warning
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        adr0 = dev->dev_addr[2] << 24 |
               dev->dev_addr[3] << 16 |
 
        }
 
        memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        adapter->macaddr_set(adapter, addr->sa_data);
 
        if (netif_running(netdev)) {
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, addr->sa_data);
 
        spin_lock_irqsave(&qdev->hw_lock, hw_flags);
        /* Program lower 32 bits of the MAC address */
 
 
        qlcnic_delete_adapter_mac(adapter);
        memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, addr->sa_data);
        qlcnic_set_multi(adapter->netdev);
 
        if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        spin_lock_irq(&cp->lock);
 
 
        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        spin_lock_irq(&tp->lock);
 
 
        err = rocker_cmd_set_port_settings_macaddr(rocker_port, addr->sa_data);
        if (err)
                return err;
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        return 0;
 }
 
 
        struct sgiseeq_private *sp = netdev_priv(dev);
        struct sockaddr *sa = addr;
 
-       memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, sa->sa_data);
 
        spin_lock_irq(&sp->tx_lock);
        __sgiseeq_set_mac_address(dev);
 
        struct ioc3_private *ip = netdev_priv(dev);
        struct sockaddr *sa = addr;
 
-       memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, sa->sa_data);
 
        spin_lock_irq(&ip->ioc3_lock);
        __ioc3_set_mac_address(dev);
 
                netdev_err(dev, "%pOF: OF MAC address prop len (%d) is wrong\n",
                           dp, prop_len);
        }
-       memcpy(dev->dev_addr, mac_addr, dev->addr_len);
+       eth_hw_addr_set(dev, mac_addr);
        if (!is_valid_ether_addr(&dev->dev_addr[0])) {
                netdev_err(dev, "%pOF: OF MAC address is invalid\n", dp);
                netdev_err(dev, "%pOF: [ %pM ]\n", dp, dev->dev_addr);
 
        if (!is_valid_ether_addr(macaddr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(dev->dev_addr, macaddr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, macaddr->sa_data);
 
        /* We'll just catch it later when the device is up'd or resumed */
        if (!netif_running(dev) || !netif_device_present(dev))
 
        netdev->irq = pdata->dev_irq;
        netdev->base_addr = (unsigned long)pdata->mac_regs;
        xlgmac_read_mac_addr(pdata);
-       memcpy(netdev->dev_addr, pdata->mac_addr, netdev->addr_len);
+       eth_hw_addr_set(netdev, pdata->mac_addr);
 
        /* Set all the function pointers */
        xlgmac_init_all_ops(pdata);
 
        if (!is_valid_ether_addr(saddr->sa_data))
                return -EADDRNOTAVAIL;
 
-       memcpy(netdev->dev_addr, saddr->sa_data, netdev->addr_len);
+       eth_hw_addr_set(netdev, saddr->sa_data);
 
        hw_ops->set_mac_address(pdata, netdev->dev_addr);
 
 
           if (netif_running(dev))
           return -EBUSY
         */
-       memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, addr->sa_data);
        bdx_restore_mac(ndev, priv);
        RET(0);
 }
 
 
        /* Store mac addr in priv and rx channel and set it in EMAC hw */
        memcpy(priv->mac_addr, sa->sa_data, ndev->addr_len);
-       memcpy(ndev->dev_addr, sa->sa_data, ndev->addr_len);
+       eth_hw_addr_set(ndev, sa->sa_data);
 
        /* MAC address is configured only after the interface is enabled. */
        if (netif_running(ndev)) {
 
        if (netif_running(dev))
                return -EBUSY;
 
-       memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
+       eth_hw_addr_set(dev, addr->sa_data);
        xemaclite_update_address(lp, dev->dev_addr);
        return 0;
 }