et131x_init_send(adapter);
        et131x_hwaddr_init(adapter);
-       ether_addr_copy(netdev->dev_addr, adapter->addr);
+       eth_hw_addr_set(netdev, adapter->addr);
 
        /* Init the device with the new settings */
        et131x_adapter_setup(adapter);
 
        netif_napi_add(netdev, &adapter->napi, et131x_poll, 64);
 
-       ether_addr_copy(netdev->dev_addr, adapter->addr);
+       eth_hw_addr_set(netdev, adapter->addr);
 
        rc = -ENOMEM;
 
 
                goto free_eeprom;
        }
        /* set mac address */
-       ether_addr_copy(sdev->netdev->dev_addr, mac[devfn]);
+       eth_hw_addr_set(sdev->netdev, mac[devfn]);
 free_eeprom:
        dma_free_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE, eeprom, paddr);
 
 
                ether_addr_copy(adapter->mac_addr, netdev->dev_addr);
        } else {
                ether_addr_copy(adapter->mac_addr, feat->dev_attr.mac_addr);
-               ether_addr_copy(netdev->dev_addr, adapter->mac_addr);
+               eth_hw_addr_set(netdev, adapter->mac_addr);
        }
 
        /* Set offload features */
 
        {
                static u8 mac_addr_permanent[] = AQ_CFG_MAC_ADDR_PERMANENT;
 
-               ether_addr_copy(self->ndev->dev_addr, mac_addr_permanent);
+               eth_hw_addr_set(self->ndev, mac_addr_permanent);
        }
 #endif
 
 
                        err = -ENOTSUPP;
                        goto err;
                }
-               ether_addr_copy(bgmac->net_dev->dev_addr, mac);
+               eth_hw_addr_set(bgmac->net_dev, mac);
        }
 
        /* On BCM4706 we need common core to access PHY */
 
        if (ret < 0)
                return ret;
 
-       ether_addr_copy(net_dev->dev_addr, sa->sa_data);
+       eth_hw_addr_set(net_dev, sa->sa_data);
        bgmac_write_mac_address(bgmac, net_dev->dev_addr);
 
        eth_commit_mac_addr_change(net_dev, addr);
 
        dev->features |= pf_dev->features;
        bnxt_vf_rep_eth_addr_gen(bp->pf.mac_addr, vf_rep->vf_idx,
                                 dev->perm_addr);
-       ether_addr_copy(dev->dev_addr, dev->perm_addr);
+       eth_hw_addr_set(dev, dev->perm_addr);
        /* Set VF-Rep's max-mtu to the corresponding VF's max-mtu */
        if (!bnxt_hwrm_vfr_qcfg(bp, vf_rep, &max_mtu))
                dev->max_mtu = max_mtu;
 
        if (netif_running(dev))
                return -EBUSY;
 
-       ether_addr_copy(dev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        return 0;
 }
                bcmgenet_power_up(priv, GENET_POWER_PASSIVE);
 
        if (pd && !IS_ERR_OR_NULL(pd->mac_address))
-               ether_addr_copy(dev->dev_addr, pd->mac_address);
+               eth_hw_addr_set(dev, pd->mac_address);
        else
                if (!device_get_mac_address(&pdev->dev, dev->dev_addr, ETH_ALEN))
                        if (has_acpi_companion(&pdev->dev))
 
 
        ether_addr_copy(netdev->perm_addr, bnad->perm_addr);
        if (is_zero_ether_addr(netdev->dev_addr))
-               ether_addr_copy(netdev->dev_addr, bnad->perm_addr);
+               eth_hw_addr_set(netdev, bnad->perm_addr);
 }
 
 /* Control Path Handlers */
 
        err = bnad_mac_addr_set_locked(bnad, sa->sa_data);
        if (!err)
-               ether_addr_copy(netdev->dev_addr, sa->sa_data);
+               eth_hw_addr_set(netdev, sa->sa_data);
 
        spin_unlock_irqrestore(&bnad->bna_lock, flags);
 
 
 
        if (!ether_addr_equal(netdev->dev_addr, mac)) {
                macaddr_changed = true;
-               ether_addr_copy(netdev->dev_addr, mac);
+               eth_hw_addr_set(netdev, mac);
                ether_addr_copy(((u8 *)&lio->linfo.hw_addr) + 2, mac);
                call_netdevice_notifiers(NETDEV_CHANGEADDR, netdev);
        }
 
 
                /* Copy MAC Address to OS network device structure */
 
-               ether_addr_copy(netdev->dev_addr, mac);
+               eth_hw_addr_set(netdev, mac);
 
                /* By default all interfaces on a single Octeon uses the same
                 * tx and rx queues
 
                        mac[j] = *((u8 *)(((u8 *)&lio->linfo.hw_addr) + 2 + j));
 
                /* Copy MAC Address to OS network device structure */
-               ether_addr_copy(netdev->dev_addr, mac);
+               eth_hw_addr_set(netdev, mac);
 
                if (liquidio_setup_io_queues(octeon_dev, i,
                                             lio->linfo.num_txpciq,
 
                nic->tns_mode = mbx.nic_cfg.tns_mode & 0x7F;
                nic->node = mbx.nic_cfg.node_id;
                if (!nic->set_mac_pending)
-                       ether_addr_copy(nic->netdev->dev_addr,
-                                       mbx.nic_cfg.mac_addr);
+                       eth_hw_addr_set(nic->netdev, mbx.nic_cfg.mac_addr);
                nic->sqs_mode = mbx.nic_cfg.sqs_mode;
                nic->loopback_supported = mbx.nic_cfg.loopback_supported;
                nic->link_up = false;
 
        /* Remember currently programmed MAC */
        ether_addr_copy(adapter->dev_mac, addr->sa_data);
 done:
-       ether_addr_copy(netdev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(netdev, addr->sa_data);
        dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);
        return 0;
 err:
 
 
        /* Allow the platform setup code to pass in a MAC address. */
        if (pdata) {
-               ether_addr_copy(netdev->dev_addr, pdata->hwaddr);
+               eth_hw_addr_set(netdev, pdata->hwaddr);
                priv->phy_id = pdata->phy_id;
        } else {
                of_get_mac_address(pdev->dev.of_node, netdev->dev_addr);
 
 
        res = eth_mac_addr(ndev, p);
        if (!res) {
-               ether_addr_copy(ndev->dev_addr, addr->sa_data);
+               eth_hw_addr_set(ndev, addr->sa_data);
                nps_enet_set_hw_mac_address(ndev);
        }
 
 
 
        addr = device_get_mac_address(priv->dev, mac, ETH_ALEN);
        if (addr) {
-               ether_addr_copy(priv->netdev->dev_addr, mac);
+               eth_hw_addr_set(priv->netdev, mac);
                dev_info(priv->dev, "Read MAC address %pM from device tree\n",
                         mac);
                return;
        mac[5] = l & 0xff;
 
        if (is_valid_ether_addr(mac)) {
-               ether_addr_copy(priv->netdev->dev_addr, mac);
+               eth_hw_addr_set(priv->netdev, mac);
                dev_info(priv->dev, "Read MAC address %pM from chip\n", mac);
        } else {
                eth_hw_addr_random(priv->netdev);
 
        }
        priv->dev->max_mtu = mtu;
        priv->num_event_counters = be16_to_cpu(descriptor->counters);
-       ether_addr_copy(priv->dev->dev_addr, descriptor->mac);
+       eth_hw_addr_set(priv->dev, descriptor->mac);
        mac = descriptor->mac;
        dev_info(&priv->pdev->dev, "MAC addr: %pM\n", mac);
        priv->tx_pages_per_qpl = be16_to_cpu(descriptor->tx_pages_per_qpl);
 
                return ret;
        }
 
-       ether_addr_copy(netdev->dev_addr, mac_addr->sa_data);
+       eth_hw_addr_set(netdev, mac_addr->sa_data);
 
        return 0;
 }
                dev_warn(priv->dev, "using random MAC address %pM\n",
                         netdev->dev_addr);
        } else if (!ether_addr_equal(netdev->dev_addr, mac_addr_temp)) {
-               ether_addr_copy(netdev->dev_addr, mac_addr_temp);
+               eth_hw_addr_set(netdev, mac_addr_temp);
                ether_addr_copy(netdev->perm_addr, mac_addr_temp);
        } else {
                return 0;
 
                return rc;
        }
 
-       ether_addr_copy(dev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        return 0;
 }
 
        /* crq->change_mac_addr.mac_addr is the requested one
         * crq->change_mac_addr_rsp.mac_addr is the returned valid one.
         */
-       ether_addr_copy(netdev->dev_addr,
-                       &crq->change_mac_addr_rsp.mac_addr[0]);
+       eth_hw_addr_set(netdev, &crq->change_mac_addr_rsp.mac_addr[0]);
        ether_addr_copy(adapter->mac_addr,
                        &crq->change_mac_addr_rsp.mac_addr[0]);
 out:
        bitmap_set(adapter->map_ids, 0, 1);
 
        ether_addr_copy(adapter->mac_addr, mac_addr_p);
-       ether_addr_copy(netdev->dev_addr, adapter->mac_addr);
+       eth_hw_addr_set(netdev, adapter->mac_addr);
        netdev->irq = dev->irq;
        netdev->netdev_ops = &ibmvnic_netdev_ops;
        netdev->ethtool_ops = &ibmvnic_ethtool_ops;
 
        }
 
        if (!err) {
-               ether_addr_copy(dev->dev_addr, addr->sa_data);
+               eth_hw_addr_set(dev, addr->sa_data);
                ether_addr_copy(hw->mac.addr, addr->sa_data);
                dev->addr_assign_type &= ~NET_ADDR_RANDOM;
        }
 
                if (is_valid_ether_addr(hw->mac.perm_addr)) {
                        ether_addr_copy(hw->mac.addr, hw->mac.perm_addr);
                        ether_addr_copy(netdev->perm_addr, hw->mac.perm_addr);
-                       ether_addr_copy(netdev->dev_addr, hw->mac.perm_addr);
+                       eth_hw_addr_set(netdev, hw->mac.perm_addr);
                        netdev->addr_assign_type &= ~NET_ADDR_RANDOM;
                }
 
                netdev->addr_assign_type |= NET_ADDR_RANDOM;
        }
 
-       ether_addr_copy(netdev->dev_addr, hw->mac.addr);
+       eth_hw_addr_set(netdev, hw->mac.addr);
        ether_addr_copy(netdev->perm_addr, hw->mac.addr);
 
        if (!is_valid_ether_addr(netdev->perm_addr)) {
 
         */
        spin_lock_bh(&vsi->mac_filter_hash_lock);
        i40e_del_mac_filter(vsi, netdev->dev_addr);
-       ether_addr_copy(netdev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(netdev, addr->sa_data);
        i40e_add_mac_filter(vsi, netdev->dev_addr);
        spin_unlock_bh(&vsi->mac_filter_hash_lock);
 
        i40e_add_mac_filter(vsi, broadcast);
        spin_unlock_bh(&vsi->mac_filter_hash_lock);
 
-       ether_addr_copy(netdev->dev_addr, mac_addr);
+       eth_hw_addr_set(netdev, mac_addr);
        ether_addr_copy(netdev->perm_addr, mac_addr);
 
        /* i40iw_net_event() reads 16 bytes from neigh->primary_key */
 
                eth_hw_addr_random(netdev);
                ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr);
        } else {
-               ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
+               eth_hw_addr_set(netdev, adapter->hw.mac.addr);
                ether_addr_copy(netdev->perm_addr, adapter->hw.mac.addr);
        }
 
 
                if (!v_retval)
                        iavf_mac_add_ok(adapter);
                if (!ether_addr_equal(netdev->dev_addr, adapter->hw.mac.addr))
-                       ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
+                       eth_hw_addr_set(netdev, adapter->hw.mac.addr);
                break;
        case VIRTCHNL_OP_GET_STATS: {
                struct iavf_eth_stats *stats =
                        ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr);
                } else {
                        /* refresh current mac address if changed */
-                       ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
+                       eth_hw_addr_set(netdev, adapter->hw.mac.addr);
                        ether_addr_copy(netdev->perm_addr,
                                        adapter->hw.mac.addr);
                }
 
        if (vsi->type == ICE_VSI_PF) {
                SET_NETDEV_DEV(netdev, ice_pf_to_dev(vsi->back));
                ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr);
-               ether_addr_copy(netdev->dev_addr, mac_addr);
+               eth_hw_addr_set(netdev, mac_addr);
                ether_addr_copy(netdev->perm_addr, mac_addr);
        }
 
                netdev_err(netdev, "can't set MAC %pM. filter update failed\n",
                           mac);
                netif_addr_lock_bh(netdev);
-               ether_addr_copy(netdev->dev_addr, old_mac);
+               eth_hw_addr_set(netdev, old_mac);
                netif_addr_unlock_bh(netdev);
                return err;
        }
 
        }
 
        if (is_valid_ether_addr(adapter->hw.mac.addr)) {
-               ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
+               eth_hw_addr_set(netdev, adapter->hw.mac.addr);
                ether_addr_copy(netdev->perm_addr, adapter->hw.mac.addr);
        }
 
                else if (is_zero_ether_addr(adapter->hw.mac.addr))
                        dev_info(&pdev->dev,
                                 "MAC address not assigned by administrator.\n");
-               ether_addr_copy(netdev->dev_addr, hw->mac.addr);
+               eth_hw_addr_set(netdev, hw->mac.addr);
        }
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
 
        ether_addr_copy(hw->mac.addr, addr->sa_data);
        ether_addr_copy(hw->mac.perm_addr, addr->sa_data);
-       ether_addr_copy(netdev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(netdev, addr->sa_data);
 
        return 0;
 }
 
        lp = netdev_priv(dev);
 
        if (mac_addr)
-               ether_addr_copy(dev->dev_addr, mac_addr);
+               eth_hw_addr_set(dev, mac_addr);
        else if (of_get_mac_address(pdev->dev.of_node, dev->dev_addr) < 0)
                eth_hw_addr_random(dev);
 
 
 
        if (fwnode_get_mac_address(fwnode, fw_mac_addr, ETH_ALEN)) {
                *mac_from = "firmware node";
-               ether_addr_copy(dev->dev_addr, fw_mac_addr);
+               eth_hw_addr_set(dev, fw_mac_addr);
                return;
        }
 
                mvpp21_get_mac_address(port, hw_mac_addr);
                if (is_valid_ether_addr(hw_mac_addr)) {
                        *mac_from = "hardware";
-                       ether_addr_copy(dev->dev_addr, hw_mac_addr);
+                       eth_hw_addr_set(dev, hw_mac_addr);
                        return;
                }
        }
 
                return err;
 
        /* Set addr in the device */
-       ether_addr_copy(dev->dev_addr, da);
+       eth_hw_addr_set(dev, da);
 
        return 0;
 }
 
                return PTR_ERR(msghdr);
        }
        rsp = (struct nix_get_mac_addr_rsp *)msghdr;
-       ether_addr_copy(netdev->dev_addr, rsp->mac_addr);
+       eth_hw_addr_set(netdev, rsp->mac_addr);
        mutex_unlock(&pfvf->mbox.lock);
 
        return 0;
 
        if (err)
                return err;
 
-       ether_addr_copy(dev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        return 0;
 }
 
                return -EADDRNOTAVAIL;
 
        netif_addr_lock_bh(netdev);
-       ether_addr_copy(netdev->dev_addr, saddr->sa_data);
+       eth_hw_addr_set(netdev, saddr->sa_data);
        netif_addr_unlock_bh(netdev);
 
        mlx5e_nic_set_rx_mode(priv);
 
        u64_to_ether_addr(local_mac, mac);
 
        if (is_valid_ether_addr(mac)) {
-               ether_addr_copy(priv->netdev->dev_addr, mac);
+               eth_hw_addr_set(priv->netdev, mac);
        } else {
                /* Provide a random MAC if for some reason the device has
                 * not been configured with a valid MAC address already.
 
        if (!is_valid_ether_addr(address->sa_data))
                return -EADDRNOTAVAIL;
 
-       ether_addr_copy(dev->dev_addr, address->sa_data);
+       eth_hw_addr_set(dev, address->sa_data);
        return enc28j60_set_hw_macaddr(dev);
 }
 
        }
 
        if (device_get_mac_address(&spi->dev, macaddr, sizeof(macaddr)))
-               ether_addr_copy(dev->dev_addr, macaddr);
+               eth_hw_addr_set(dev, macaddr);
        else
                eth_hw_addr_random(dev);
        enc28j60_set_hw_macaddr(dev);
 
                        eth_random_addr(adapter->mac_address);
        }
        lan743x_mac_set_address(adapter, adapter->mac_address);
-       ether_addr_copy(netdev->dev_addr, adapter->mac_address);
+       eth_hw_addr_set(netdev, adapter->mac_address);
 
        return 0;
 }
        ret = eth_prepare_mac_addr_change(netdev, sock_addr);
        if (ret)
                return ret;
-       ether_addr_copy(netdev->dev_addr, sock_addr->sa_data);
+       eth_hw_addr_set(netdev, sock_addr->sa_data);
        lan743x_mac_set_address(adapter, sock_addr->sa_data);
        lan743x_rfe_update_mac_address(adapter);
        return 0;
 
        sparx5_mact_learn(sparx5, PGID_CPU, addr->sa_data, port->pvid);
 
        /* Record the address */
-       ether_addr_copy(dev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(dev, addr->sa_data);
 
        return 0;
 }
 
        if (apc->num_queues > apc->max_queues)
                apc->num_queues = apc->max_queues;
 
-       ether_addr_copy(ndev->dev_addr, apc->mac_addr);
+       eth_hw_addr_set(ndev, apc->mac_addr);
 
        return 0;
 
 
        /* Then forget the previous one. */
        ocelot_mact_forget(ocelot, dev->dev_addr, ocelot_port->pvid_vlan.vid);
 
-       ether_addr_copy(dev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(dev, addr->sa_data);
        return 0;
 }
 
 
                return;
        }
 
-       ether_addr_copy(nn->dp.netdev->dev_addr, mac_addr);
+       eth_hw_addr_set(nn->dp.netdev, mac_addr);
        ether_addr_copy(nn->dp.netdev->perm_addr, mac_addr);
 }
 
 
                return;
        }
 
-       ether_addr_copy(netdev->dev_addr, eth_port->mac_addr);
+       eth_hw_addr_set(netdev, eth_port->mac_addr);
        ether_addr_copy(netdev->perm_addr, eth_port->mac_addr);
 }
 
 
                return;
        }
 
-       ether_addr_copy(nn->dp.netdev->dev_addr, mac_addr);
+       eth_hw_addr_set(nn->dp.netdev, mac_addr);
        ether_addr_copy(nn->dp.netdev->perm_addr, mac_addr);
 }
 
 
 
        mac_addr = nixge_get_nvmem_address(&pdev->dev);
        if (mac_addr && is_valid_ether_addr(mac_addr)) {
-               ether_addr_copy(ndev->dev_addr, mac_addr);
+               eth_hw_addr_set(ndev, mac_addr);
                kfree(mac_addr);
        } else {
                eth_hw_addr_random(ndev);
 
                return;
        }
 
-       ether_addr_copy(edev->ndev->dev_addr, mac);
+       eth_hw_addr_set(edev->ndev, mac);
        __qede_unlock(edev);
 }
 
                        goto out;
        }
 
-       ether_addr_copy(ndev->dev_addr, addr->sa_data);
+       eth_hw_addr_set(ndev, addr->sa_data);
        DP_INFO(edev, "Setting device MAC to %pM\n", addr->sa_data);
 
        if (edev->state != QEDE_STATE_OPEN) {
 
        ndev->max_mtu = QEDE_MAX_JUMBO_PACKET_SIZE;
 
        /* Set network device HW mac */
-       ether_addr_copy(edev->ndev->dev_addr, edev->dev_info.common.hw_mac);
+       eth_hw_addr_set(edev->ndev, edev->dev_info.common.hw_mac);
 
        ndev->mtu = edev->dev_info.common.mtu;
 }
 
 
        /* get mac address */
        if (device_get_mac_address(&pdev->dev, maddr, ETH_ALEN))
-               ether_addr_copy(netdev->dev_addr, maddr);
+               eth_hw_addr_set(netdev, maddr);
        else
                eth_hw_addr_random(netdev);
 
 
                        goto fail;
 
                if (vf->efx)
-                       ether_addr_copy(vf->efx->net_dev->dev_addr, mac);
+                       eth_hw_addr_set(vf->efx->net_dev, mac);
        }
 
        ether_addr_copy(vf->mac, mac);
 
                return rc;
 
        /* Initialise MAC address to permanent address */
-       ether_addr_copy(efx->net_dev->dev_addr, efx->net_dev->perm_addr);
+       eth_hw_addr_set(efx->net_dev, efx->net_dev->perm_addr);
 
        return 0;
 }
 
 
        /* save old address */
        ether_addr_copy(old_addr, net_dev->dev_addr);
-       ether_addr_copy(net_dev->dev_addr, new_addr);
+       eth_hw_addr_set(net_dev, new_addr);
        if (efx->type->set_mac_address) {
                rc = efx->type->set_mac_address(efx);
                if (rc) {
-                       ether_addr_copy(net_dev->dev_addr, old_addr);
+                       eth_hw_addr_set(net_dev, old_addr);
                        return rc;
                }
        }
 
                return rc;
 
        /* Initialise MAC address to permanent address */
-       ether_addr_copy(efx->net_dev->dev_addr, efx->net_dev->perm_addr);
+       eth_hw_addr_set(efx->net_dev, efx->net_dev->perm_addr);
 
        return 0;
 }
 
        /* save old address */
        ether_addr_copy(old_addr, net_dev->dev_addr);
-       ether_addr_copy(net_dev->dev_addr, new_addr);
+       eth_hw_addr_set(net_dev, new_addr);
        if (efx->type->set_mac_address) {
                rc = efx->type->set_mac_address(efx);
                if (rc) {
-                       ether_addr_copy(net_dev->dev_addr, old_addr);
+                       eth_hw_addr_set(net_dev, old_addr);
                        return rc;
                }
        }
 
 
        mac = device_get_mac_address(&pdev->dev, macbuf, sizeof(macbuf));
        if (mac)
-               ether_addr_copy(ndev->dev_addr, mac);
+               eth_hw_addr_set(ndev, mac);
 
        if (priv->eeprom_base &&
            (!mac || !is_valid_ether_addr(ndev->dev_addr))) {
 
        ndev_priv->msg_enable = AM65_CPSW_DEBUG;
        SET_NETDEV_DEV(port->ndev, dev);
 
-       ether_addr_copy(port->ndev->dev_addr, port->slave.mac_addr);
+       eth_hw_addr_set(port->ndev, port->slave.mac_addr);
 
        port->ndev->min_mtu = AM65_CPSW_MIN_PACKET_SIZE;
        port->ndev->max_mtu = AM65_CPSW_MAX_PACKET_SIZE;
 
                           flags, vid);
 
        ether_addr_copy(priv->mac_addr, addr->sa_data);
-       ether_addr_copy(ndev->dev_addr, priv->mac_addr);
+       eth_hw_addr_set(ndev, priv->mac_addr);
        cpsw_set_slave_mac(&cpsw->slaves[slave_no], priv);
 
        pm_runtime_put(cpsw->dev);
                        dev_info(cpsw->dev, "Random MACID = %pM\n",
                                 priv->mac_addr);
                }
-               ether_addr_copy(ndev->dev_addr, slave_data->mac_addr);
+               eth_hw_addr_set(ndev, slave_data->mac_addr);
                ether_addr_copy(priv->mac_addr, slave_data->mac_addr);
 
                cpsw->slaves[i].ndev = ndev;
 
 
        rc = davinci_emac_try_get_mac(pdev, res_ctrl ? 0 : 1, priv->mac_addr);
        if (!rc)
-               ether_addr_copy(ndev->dev_addr, priv->mac_addr);
+               eth_hw_addr_set(ndev, priv->mac_addr);
 
        if (!is_valid_ether_addr(priv->mac_addr)) {
                /* Use random MAC if still none obtained. */
 
 
                emac_arch_get_mac_addr(efuse_mac_addr, efuse, efuse_mac);
                if (is_valid_ether_addr(efuse_mac_addr))
-                       ether_addr_copy(ndev->dev_addr, efuse_mac_addr);
+                       eth_hw_addr_set(ndev, efuse_mac_addr);
                else
                        eth_random_addr(ndev->dev_addr);
 
 
                                       struct net_device *src)
 {
        dst->addr_assign_type = src->addr_assign_type;
-       ether_addr_copy(dst->dev_addr, src->dev_addr);
+       eth_hw_addr_set(dst, src->dev_addr);
 }
 
 /**