err = atl1c_get_permanent_address(hw);
        if (err)
-               random_ether_addr(hw->perm_mac_addr);
+               eth_random_addr(hw->perm_mac_addr);
 
        memcpy(hw->mac_addr, hw->perm_mac_addr, sizeof(hw->perm_mac_addr));
        return err;
 
        u16 i;
 
        if (atl1_get_permanent_address(hw)) {
-               random_ether_addr(hw->perm_mac_addr);
+               eth_random_addr(hw->perm_mac_addr);
                ret = 1;
        }
 
 
 {
        if (get_permanent_address(hw)) {
                /* for test */
-               /* FIXME: shouldn't we use random_ether_addr() here? */
+               /* FIXME: shouldn't we use eth_random_addr() here? */
                hw->perm_mac_addr[0] = 0x00;
                hw->perm_mac_addr[1] = 0x13;
                hw->perm_mac_addr[2] = 0x74;
 
        /* Check the MAC again for validity, if it still isn't choose and
         * program a random one. */
        if (!is_valid_ether_addr(netdev->dev_addr)) {
-               random_ether_addr(netdev->dev_addr);
+               eth_random_addr(netdev->dev_addr);
                random_mac = true;
        }
 
 
        unsigned int device_id;
        u16 thisvf_devfn;
 
-       random_ether_addr(mac_addr);
+       eth_random_addr(mac_addr);
        igb_set_vf_mac(adapter, vf, mac_addr);
 
        switch (adapter->hw.mac.type) {
 
        /* generate a new mac address as we were hotplug removed/added */
        if (!(adapter->vf_data[vf].flags & IGB_VF_FLAG_PF_SET_MAC))
-               random_ether_addr(vf_mac);
+               eth_random_addr(vf_mac);
 
        /* process remaining reset events */
        igb_vf_reset(adapter, vf);
 
        bool enable = ((event_mask & 0x10000000U) != 0);
 
        if (enable) {
-               random_ether_addr(vf_mac_addr);
+               eth_random_addr(vf_mac_addr);
                e_info(probe, "IOV: VF %d is enabled MAC %pM\n",
                       vfn, vf_mac_addr);
                /*
 
        memcpy(&mac, &priv->pldata->mac, sizeof(struct sockaddr));
        if (!is_valid_ether_addr(mac.sa_data)) {
                pr_warn("etop: invalid MAC, using random\n");
-               random_ether_addr(mac.sa_data);
+               eth_random_addr(mac.sa_data);
                random_mac = true;
        }
 
 
  *
  * Get or create the initial mac address for the device and then set that
  * into the station address register. If there is an EEPROM present, then
- * we try that. If no valid mac address is found we use random_ether_addr()
+ * we try that. If no valid mac address is found we use eth_random_addr()
  * to create a new one.
  */
 static void ks8851_init_mac(struct ks8851_net *ks)
 
        memcpy(ks->mac_addr, pdata->mac_addr, 6);
        if (!is_valid_ether_addr(ks->mac_addr)) {
                /* Use random MAC address if none passed */
-               random_ether_addr(ks->mac_addr);
+               eth_random_addr(ks->mac_addr);
                netdev_info(netdev, "Using random mac address\n");
        }
        netdev_info(netdev, "Mac address is: %pM\n", ks->mac_addr);
 
                        eth_hw_addr_random(dev);
                        smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
                        SMSC_TRACE(pdata, probe,
-                                  "MAC Address is set to random_ether_addr");
+                                  "MAC Address is set to eth_random_addr");
                }
        }
 
 
                memcpy(priv->mac_addr, data->slave_data[0].mac_addr, ETH_ALEN);
                pr_info("Detected MACID = %pM", priv->mac_addr);
        } else {
-               random_ether_addr(priv->mac_addr);
+               eth_random_addr(priv->mac_addr);
                pr_info("Random MACID = %pM", priv->mac_addr);
        }
 
 
                memcpy(dev->dev_addr, mac, 6);
                dev->addr_len = 6;
        } else {
-               random_ether_addr(dev->dev_addr);
+               eth_random_addr(dev->dev_addr);
        }
 
        /* Register the network device. */
 
        if (data && is_valid_ether_addr(data->mac_addr)) {
                memcpy(ndev->dev_addr, data->mac_addr, ETH_ALEN);
        } else {
-               random_ether_addr(ndev->dev_addr);
+               eth_random_addr(ndev->dev_addr);
                ndev->addr_assign_type |= NET_ADDR_RANDOM;
        }
 
 
        if (data && is_valid_ether_addr(data->mac_addr)) {
                memcpy(ndev->dev_addr, data->mac_addr, ETH_ALEN);
        } else {
-               random_ether_addr(ndev->dev_addr);
+               eth_random_addr(ndev->dev_addr);
                ndev->addr_assign_type |= NET_ADDR_RANDOM;
        }
 
 
        if (address)
                memcpy(ndev->dev_addr, address, ETH_ALEN);
        if (!is_valid_ether_addr(ndev->dev_addr))
-               random_ether_addr(ndev->dev_addr);
+               eth_random_addr(ndev->dev_addr);
 
        /* Set up unicast MAC address filter set its mac address */
        axienet_iow(lp, XAE_UAW0_OFFSET,