memcpy(bp->dev->dev_addr, addr, sizeof(addr));
        } else {
                netdev_info(bp->dev, "invalid hw address, using random\n");
-               random_ether_addr(bp->dev->dev_addr);
+               eth_hw_addr_random(bp->dev);
        }
 }
 
 
        ep->mdc_divisor = 40;   /* Max HCLK 100 MHz, min MDIO clk 2.5 MHz.  */
 
        if (is_zero_ether_addr(dev->dev_addr))
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
 
        err = register_netdev(dev);
        if (err) {
 
                dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
                         "set using ifconfig\n", ndev->name);
 
-               random_ether_addr(ndev->dev_addr);
+               eth_hw_addr_random(ndev);
                mac_src = "random";
        }
 
 
 
        if (!is_valid_ether_addr(dev->dev_addr)) {
                /* choose a random ethernet address */
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
                __dnet_set_hwaddr(bp);
        }
 
 
        netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
-               random_ether_addr(netdev->dev_addr);
+               eth_hw_addr_random(netdev);
                netdev_info(netdev, "generated random MAC address %pM\n",
                            netdev->dev_addr);
        }
 
        netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
 
        if (!is_valid_ether_addr(netdev->dev_addr)) {
-               random_ether_addr(netdev->dev_addr);
+               eth_hw_addr_random(netdev);
                netdev_info(netdev, "generated random MAC address %pM\n",
                            netdev->dev_addr);
        }
 
         * Lacking any better mechanism to allocate a MAC address we use a
         * random one ...
         */
-       random_ether_addr(netdev->dev_addr);
+       eth_hw_addr_random(netdev);
 
        err = register_netdev(netdev);
        if (err) {
 
 
        printk(KERN_WARNING "macsonic: MAC address in CAM entry 15 "
                            "seems invalid, will use a random MAC\n");
-       random_ether_addr(dev->dev_addr);
+       eth_hw_addr_random(dev);
 }
 
 static int __devinit mac_onboard_sonic_probe(struct net_device *dev)
 
        if (!(adrp[0] || adrp[1] || adrp[2])) {
                netdev_warn(dev, "MAC address not initialized, "
                                        "generating random\n");
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
        }
 
        /* Link new device into r6040_root_dev */
 
                ret = sis900_get_mac_addr(pci_dev, net_dev);
 
        if (!ret || !is_valid_ether_addr(net_dev->dev_addr)) {
-               random_ether_addr(net_dev->dev_addr);
+               eth_hw_addr_random(net_dev);
                printk(KERN_WARNING "%s: Unreadable or invalid MAC address,"
                                "using random generated one\n", dev_name);
        }
 
                        smsc_dbg(PROBE, "Mac Address is read from EEPROM");
                } else {
                        /* eeprom values are invalid, generate random MAC */
-                       random_ether_addr(dev->dev_addr);
+                       eth_hw_addr_random(dev);
                        smsc9420_set_mac_address(dev);
-                       smsc_dbg(PROBE,
-                               "MAC Address is set to random_ether_addr");
+                       smsc_dbg(PROBE, "MAC Address is set to random");
                }
        }
 }
 
                                             priv->dev->base_addr,
                                             priv->dev->dev_addr, 0);
                if  (!is_valid_ether_addr(priv->dev->dev_addr))
-                       random_ether_addr(priv->dev->dev_addr);
+                       eth_hw_addr_random(priv->dev);
        }
        pr_warning("%s: device MAC address %pM\n", priv->dev->name,
                                                   priv->dev->dev_addr);
 
        /* Retrieve the ethernet address. */
        if (tc35815_init_dev_addr(dev)) {
                dev_warn(&pdev->dev, "not valid ether addr\n");
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
        }
 
        rc = register_netdev(dev);
 
        if (!is_valid_ether_addr(dev->dev_addr)) {
                /* Report it and use a random ethernet address instead */
                netdev_err(dev, "Invalid MAC address: %pM\n", dev->dev_addr);
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
                netdev_info(dev, "Using random MAC address: %pM\n",
                            dev->dev_addr);
        }
 
        dev->flags |= IFF_NOARP;
        dev->flags &= ~IFF_MULTICAST;
        dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
-       random_ether_addr(dev->dev_addr);
+       eth_hw_addr_random(dev);
 }
 
 static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)
 
                ether_setup(dev);
                dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
 
                dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */
                break;
 
        }
 
        /* no eeprom, or eeprom values are invalid. generate random MAC */
-       random_ether_addr(dev->net->dev_addr);
+       eth_hw_addr_random(dev->net);
        netif_dbg(dev, ifup, dev->net, "MAC address set to random_ether_addr");
 }
 
 
        }
 
        /* no eeprom, or eeprom values are invalid. generate random MAC */
-       random_ether_addr(dev->net->dev_addr);
+       eth_hw_addr_random(dev->net);
        netif_dbg(dev, ifup, dev->net, "MAC address set to random_ether_addr\n");
 }
 
 
        }
 
        if (tbp[IFLA_ADDRESS] == NULL)
-               random_ether_addr(peer->dev_addr);
+               eth_hw_addr_random(peer);
 
        err = register_netdevice(peer);
        put_net(net);
         */
 
        if (tb[IFLA_ADDRESS] == NULL)
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
 
        if (tb[IFLA_IFNAME])
                nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ);
 
        if (virtio_config_val_len(vdev, VIRTIO_NET_F_MAC,
                                  offsetof(struct virtio_net_config, mac),
                                  dev->dev_addr, dev->addr_len) < 0)
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
 
        /* Set up our device-specific information */
        vi = netdev_priv(dev);
 
        }
 
        if (type == ARPHRD_ETHER)
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
        else {
                *(__be16*)dev->dev_addr = htons(dlci);
                dlci_to_q922(dev->broadcast, dlci);
 
                old_qlen = dev->tx_queue_len;
                ether_setup(dev);
                dev->tx_queue_len = old_qlen;
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
                netif_dormant_off(dev);
                return 0;
        }
 
                return -EEXIST;
 
        if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
-               random_ether_addr(dev->dev_addr);
+               eth_hw_addr_random(dev);
 
        mtu = ipgre_tunnel_bind_dev(dev);
        if (!tb[IFLA_MTU])
 
        struct l2tp_eth *priv = netdev_priv(dev);
 
        priv->dev = dev;
-       random_ether_addr(dev->dev_addr);
+       eth_hw_addr_random(dev);
        memset(&dev->broadcast[0], 0xff, 6);
 
        return 0;