void __init cellvision_mac_setup(void)
{
u8 mac_base[6];
int err;
err = admboot_get_mac_base(CELLVISION_CONFIG_OFFSET,
CELLVISION_CONFIG_SIZE, mac_base);
if ((err) || !is_valid_ether_addr(mac_base))
random_ether_addr(mac_base);
adm5120_setup_eth_macs(mac_base);
}
static __init void pmugw_setup_mac(void)
{
u8 mac_base[6];
int err;
err = admboot_get_mac_base(PMUGW_CONFIG_OFFSET,
PMUGW_CONFIG_SIZE, mac_base);
if ((err) || !is_valid_ether_addr(mac_base))
random_ether_addr(mac_base);
adm5120_setup_eth_macs(mac_base);
}
static void __init rmnet_setup(struct net_device *dev)
{
/* Using Ethernet mode by default */
dev->netdev_ops = &rmnet_ops_ether;
ether_setup(dev);
/* set this after calling ether_setup */
dev->mtu = RMNET_DATA_LEN;
random_ether_addr(dev->dev_addr);
dev->watchdog_timeo = 1000; /* 10 seconds? */
}
static void __init rmnet_setup(struct net_device *dev)
{
dev->netdev_ops = &rmnet_ops;
/* dev->watchdog_timeo = 20; ??? */
dev->watchdog_timeo = (2 * HZ);
ether_setup(dev);
//dev->change_mtu = 0; /* ??? */
random_ether_addr(dev->dev_addr);
}
static void __init rmnet_setup(struct net_device *dev)
{
dev->netdev_ops = &rmnet_ops_ether;
ether_setup(dev);
dev->mtu = RMNET_DATA_LEN;
dev->needed_headroom = HEADROOM_FOR_SDIO + HEADROOM_FOR_QOS ;
dev->needed_tailroom = TAILROOM;
random_ether_addr(dev->dev_addr);
dev->watchdog_timeo = 1000;
}
static void __init cpmac_get_mac(int instance, unsigned char *dev_addr)
{
char name[5], *mac;
sprintf(name, "mac%c", 'a' + instance);
mac = prom_getenv(name);
if (!mac && instance) {
sprintf(name, "mac%c", 'a');
mac = prom_getenv(name);
}
if (mac) {
if (sscanf(mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
&dev_addr[0], &dev_addr[1],
&dev_addr[2], &dev_addr[3],
&dev_addr[4], &dev_addr[5]) != 6) {
pr_warning("cannot parse mac address, "
"using random address\n");
random_ether_addr(dev_addr);
}
} else
random_ether_addr(dev_addr);
}
static void __init rmnet_setup(struct net_device *dev)
{
/* Using Ethernet mode by default */
dev->netdev_ops = &rmnet_ops_ether;
ether_setup(dev);
/* set this after calling ether_setup */
dev->mtu = RMNET_DATA_LEN;
dev->needed_headroom = HEADROOM_FOR_BAM + HEADROOM_FOR_QOS ;
dev->needed_tailroom = TAILROOM;
random_ether_addr(dev->dev_addr);
dev->watchdog_timeo = 1000; /* 10 seconds? */
}
static void niit_dev_setup(struct net_device *dev) {
ether_setup(dev);
memset(netdev_priv(dev), 0, sizeof(struct niit_tunnel));
//#ifdef HAVE_NET_DEVICE_OPS
#if !(defined CONFIG_COMPAT_NET_DEV_OPS) && LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)
dev->netdev_ops = &niit_netdev_ops;
#endif
dev->destructor = free_netdev;
dev->type = ARPHRD_ETHER;
dev->mtu = ETH_DATA_LEN - sizeof(struct ipv6hdr);
dev->flags = IFF_NOARP;
random_ether_addr(dev->dev_addr);
}
static void dummy_setup(struct net_device *dev)
{
ether_setup(dev);
dev->netdev_ops = &dummy_netdev_ops;
dev->destructor = free_netdev;
dev->tx_queue_len = 0;
dev->flags |= IFF_NOARP;
dev->flags &= ~IFF_MULTICAST;
random_ether_addr(dev->dev_addr);
}
static void rmnet_usb_setup(struct net_device *dev)
{
/* Using Ethernet mode by default */
dev->netdev_ops = &rmnet_usb_ops_ether;
/* set this after calling ether_setup */
dev->mtu = RMNET_DATA_LEN;
/* for QOS header */
dev->needed_headroom = RMNET_HEADROOM;
random_ether_addr(dev->dev_addr);
dev->watchdog_timeo = 1000; /* 10 seconds? */
}
static void dummy_setup(struct net_device *dev)
{
ether_setup(dev);
/* Initialize the device structure. */
dev->netdev_ops = &dummy_netdev_ops;
dev->destructor = free_netdev;
/* Fill in device structure with ethernet-generic values. */
dev->tx_queue_len = 0;
dev->flags |= IFF_NOARP;
dev->flags &= ~IFF_MULTICAST;
random_ether_addr(dev->dev_addr);
}
static void setup_etheraddr(char *str, unsigned char *addr, char *name)
{
char *end;
int i;
if(str == NULL)
goto random;
for(i=0;i<6;i++){
addr[i] = simple_strtoul(str, &end, 16);
if((end == str) ||
((*end != ':') && (*end != ',') && (*end != '\0'))){
printk(KERN_ERR
"setup_etheraddr: failed to parse '%s' "
"as an ethernet address\n", str);
goto random;
}
str = end + 1;
}
if (is_multicast_ether_addr(addr)) {
printk(KERN_ERR
"Attempt to assign a multicast ethernet address to a "
"device disallowed\n");
goto random;
}
if (!is_valid_ether_addr(addr)) {
printk(KERN_ERR
"Attempt to assign an invalid ethernet address to a "
"device disallowed\n");
goto random;
}
if (!is_local_ether_addr(addr)) {
printk(KERN_WARNING
"Warning: attempt to assign a globally valid ethernet "
"address to a device\n");
printk(KERN_WARNING "You should better enable the 2nd "
"rightmost bit in the first byte of the MAC,\n");
printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n",
addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
addr[5]);
goto random;
}
return;
random:
printk(KERN_INFO
"Choosing a random ethernet address for device %s\n", name);
random_ether_addr(addr);
}
static void __init eb214a_mac_setup(void)
{
u8 mac_base[6];
u8 *cfg;
int i;
cfg = (u8 *) KSEG1ADDR(ADM5120_SRAM0_BASE + EB214A_CONFIG_OFFSET);
for (i = 0; i < 6; i++)
mac_base[i] = cfg[i];
if (!is_valid_ether_addr(mac_base))
random_ether_addr(mac_base);
adm5120_setup_eth_macs(mac_base);
}
static void ifb_setup(struct net_device *dev)
{
/* Initialize the device structure. */
dev->destructor = free_netdev;
dev->netdev_ops = &ifb_netdev_ops;
/* Fill in device structure with ethernet-generic values. */
ether_setup(dev);
dev->tx_queue_len = TX_Q_LIMIT;
dev->flags |= IFF_NOARP;
dev->flags &= ~IFF_MULTICAST;
dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
random_ether_addr(dev->dev_addr);
}
static void virtnet_setup(struct net_device *dev)
{
ether_setup(dev);//设置ether设备
/* Initialize the device structure. */
dev->netdev_ops = &dummy_netdev_ops;
//dev->destructor = dummy_dev_free;
/* Fill in device structure with ethernet-generic values. */
//dev->tx_queue_len = 0;
dev->flags |= IFF_NOARP;//不支持ARP协议
//dev->flags &= ~IFF_MULTICAST;
dev->features |= NETIF_F_NO_CSUM ;
random_ether_addr(dev->dev_addr);
}
void br_dev_setup(struct net_device *dev)
{
random_ether_addr(dev->dev_addr);
ether_setup(dev);
dev->netdev_ops = &br_netdev_ops;
dev->destructor = free_netdev;
SET_ETHTOOL_OPS(dev, &br_ethtool_ops);
dev->tx_queue_len = 0;
dev->priv_flags = IFF_EBRIDGE;
dev->features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
NETIF_F_GSO_MASK | NETIF_F_NO_CSUM | NETIF_F_LLTX |
NETIF_F_NETNS_LOCAL | NETIF_F_GSO;
}
static struct vport *patch_create(const struct vport_parms *parms)
{
struct vport *vport;
struct patch_vport *patch_vport;
const char *peer_name;
struct patch_config *patchconf;
struct net *net = ovs_dp_get_net(parms->dp);
int err;
vport = ovs_vport_alloc(sizeof(struct patch_vport),
&ovs_patch_vport_ops, parms);
if (IS_ERR(vport)) {
err = PTR_ERR(vport);
goto error;
}
patch_vport = patch_vport_priv(vport);
strcpy(patch_vport->name, parms->name);
patchconf = kmalloc(sizeof(struct patch_config), GFP_KERNEL);
if (!patchconf) {
err = -ENOMEM;
goto error_free_vport;
}
err = patch_set_config(vport, parms->options, patchconf);
if (err)
goto error_free_patchconf;
random_ether_addr(patchconf->eth_addr);
rcu_assign_pointer(patch_vport->patchconf, patchconf);
peer_name = patchconf->peer_name;
hlist_add_head(&patch_vport->hash_node, hash_bucket(net, peer_name));
rcu_assign_pointer(patch_vport->peer, ovs_vport_locate(net, peer_name));
update_peers(net, patch_vport->name, vport);
return vport;
error_free_patchconf:
kfree(patchconf);
error_free_vport:
ovs_vport_free(vport);
error:
return ERR_PTR(err);
}
int wrn_endpoint_probe(struct net_device *dev)
{
struct wrn_ep *ep = netdev_priv(dev);
int epnum, err;
u32 val;
epnum = ep->ep_number;
/* Check whether the ep has been sinthetized or not */
val = readl(&ep->ep_regs->IDCODE);
if (val != WRN_EP_MAGIC) {
pr_info(DRV_NAME "EP%i (%s) has not been sintethized\n",
ep->ep_number, dev->name);
return -ENODEV;
}
/* Errors different from -ENODEV are fatal to insmod */
dev_alloc_name(dev, "wr%d");
wrn_netops_init(dev); /* function in ./nic-core.c */
wrn_ethtool_init(dev); /* function in ./ethtool.c */
/* Napi is not supported on this device */
ep->mii.dev = dev; /* Support for ethtool */
ep->mii.mdio_read = wrn_phy_read;
ep->mii.mdio_write = wrn_phy_write;
ep->mii.phy_id = 0;
ep->mii.phy_id_mask = 0x1f;
ep->mii.reg_num_mask = 0x1f;
ep->mii.force_media = 0;
ep->mii.advertising = ADVERTISE_1000XFULL;
ep->mii.full_duplex = 1;
/* Finally, register and succeed, or fail and undo */
err = register_netdev(dev);
if (err) {
printk(KERN_ERR DRV_NAME "Can't register dev %s\n",
dev->name);
__wrn_endpoint_shutdown(ep);
/* ENODEV means "no more" for the caller, so avoid it */
return err == -ENODEV ? -EIO : err;
}
/* randomize a MAC address, so lazy users can avoid ifconfig */
random_ether_addr(dev->dev_addr);
return 0;
}
/* Called by kernel whenever a new rmnet<n> device is created. Sets MTU,
* flags, ARP type, needed headroom, etc...
*/
void rmnet_vnd_setup(struct net_device *rmnet_dev)
{
rmnet_dev->netdev_ops = &rmnet_vnd_ops;
rmnet_dev->mtu = RMNET_DFLT_PACKET_SIZE;
rmnet_dev->needed_headroom = RMNET_NEEDED_HEADROOM;
random_ether_addr(rmnet_dev->dev_addr);
rmnet_dev->tx_queue_len = RMNET_TX_QUEUE_LEN;
/* Raw IP mode */
rmnet_dev->header_ops = NULL; /* No header */
rmnet_dev->type = ARPHRD_RAWIP;
rmnet_dev->hard_header_len = 0;
rmnet_dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
rmnet_dev->needs_free_netdev = true;
}
static void __init dummy_setup(struct net_device *dev)
{
/* Initialize the device structure. */
dev->get_stats = dummy_get_stats;
dev->hard_start_xmit = dummy_xmit;
dev->set_multicast_list = set_multicast_list;
dev->set_mac_address = dummy_set_address;
/* Fill in device structure with ethernet-generic values. */
ether_setup(dev);
dev->tx_queue_len = 0;
dev->change_mtu = NULL;
dev->flags |= IFF_NOARP;
dev->flags &= ~IFF_MULTICAST;
random_ether_addr(dev->dev_addr);
}
static void __init rmnet_setup(struct net_device *dev)
{
dev->open = rmnet_open;
dev->stop = rmnet_stop;
dev->hard_start_xmit = rmnet_xmit;
dev->get_stats = rmnet_get_stats;
dev->set_multicast_list = rmnet_set_multicast_list;
dev->tx_timeout = rmnet_tx_timeout;
dev->watchdog_timeo = 1000; /* 10 seconds? */
ether_setup(dev);
dev->change_mtu = 0; /* ??? */
random_ether_addr(dev->dev_addr);
}
static void __init ifb_setup(struct net_device *dev)
{
/* Initialize the device structure. */
dev->get_stats = ifb_get_stats;
dev->hard_start_xmit = ifb_xmit;
dev->open = &ifb_open;
dev->stop = &ifb_close;
/* Fill in device structure with ethernet-generic values. */
ether_setup(dev);
dev->tx_queue_len = TX_Q_LIMIT;
dev->change_mtu = NULL;
dev->flags |= IFF_NOARP;
dev->flags &= ~IFF_MULTICAST;
SET_MODULE_OWNER(dev);
random_ether_addr(dev->dev_addr);
}
static int __devinit seth_dev_create(unsigned int device_count)
{
struct net_device* netdev;
SEth* seth;
int ret;
netdev = alloc_netdev(sizeof(SEth), "veth%d", ether_setup);
if (!netdev) {
SETH_ERR ("alloc_netdev() failed.\n");
return -ENOMEM;
}
seth = netdev_priv (netdev);
seth->netdev = netdev;
seth->tty_index = TTY_INDEX_BASE + device_count;
#ifdef HAVE_NET_DEVICE_OPS
netdev->netdev_ops = &seth_ops;
#else
netdev->open = seth_open;
netdev->stop = seth_close;
netdev->hard_start_xmit = seth_start_xmit;
netdev->get_stats = seth_get_stats;
netdev->set_multicast_list = seth_set_multicast_list;
netdev->tx_timeout = seth_tx_timeout;
#endif
netdev->watchdog_timeo = 3*HZ;
netdev->irq = 0;
netdev->dma = 0;
netdev->flags &= ~IFF_MULTICAST;
netdev->flags &= ~IFF_BROADCAST;
netdev->flags |= IFF_NOARP;
random_ether_addr(netdev->dev_addr);
/* register new Ethernet interface */
if ((ret = register_netdev (netdev))) {
SETH_ERR ("register_netdev() failed (%d)\n", ret);
free_netdev(netdev);
return ret;
}
seth_devices[seth_devices_num++] = seth;
return 0;
}
static void __init rmnet_setup(struct net_device *dev)
{
pr_info("msm_rmnet: %s\n", __func__);
/* Using Ethernet mode by default */
dev->netdev_ops = &rmnet_ops_ether;
ether_setup(dev);
/* set this after calling ether_setup */
dev->mtu = RMNET_DATA_LEN;
dev->needed_headroom = HEADROOM_FOR_QOS;
random_ether_addr(dev->dev_addr);
dev->watchdog_timeo = 1000; /* 10 seconds? */
pr_info("msm_rmnet: %s complete\n", __func__);
}
static void do_setup(struct net_device *netdev)
{
ether_setup(netdev);
netdev->netdev_ops = &internal_dev_netdev_ops;
netdev->priv_flags &= ~IFF_TX_SKB_SHARING;
netdev->destructor = internal_dev_destructor;
SET_ETHTOOL_OPS(netdev, &internal_dev_ethtool_ops);
netdev->tx_queue_len = 0;
netdev->features = NETIF_F_LLTX | NETIF_F_SG | NETIF_F_FRAGLIST |
NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | NETIF_F_TSO;
netdev->vlan_features = netdev->features;
netdev->features |= NETIF_F_HW_VLAN_TX;
random_ether_addr(netdev->dev_addr);
}
static void __init rmnet_setup(struct net_device *dev)
{
dev->open = rmnet_open;
dev->stop = rmnet_stop;
dev->hard_start_xmit = rmnet_xmit;
dev->get_stats = rmnet_get_stats;
dev->set_multicast_list = rmnet_set_multicast_list;
dev->tx_timeout = rmnet_tx_timeout;
dev->watchdog_timeo = 20; /* ??? */
ether_setup(dev);
/*fixme : this is a workaround way to avoid mms cannot be sent normally in shenzhen */
dev->mtu = MMS_DATA_LEN;
dev->change_mtu = 0; /* ??? */
random_ether_addr(dev->dev_addr);
}
int vmm_netport_register(struct vmm_netport *port)
{
struct vmm_classdev *cd;
int rc;
if (port == NULL)
return VMM_EFAIL;
/* If port has invalid mac, assign a random one */
if (!is_valid_ether_addr(port->macaddr)) {
random_ether_addr(port->macaddr);
}
cd = vmm_malloc(sizeof(struct vmm_classdev));
if (!cd) {
rc = VMM_EFAIL;
goto ret;
}
INIT_LIST_HEAD(&cd->head);
strcpy(cd->name, port->name);
cd->dev = port->dev;
cd->priv = port;
rc = vmm_devdrv_register_classdev(VMM_NETPORT_CLASS_NAME, cd);
if (rc != VMM_OK) {
vmm_printf("%s: Failed to register %s %s (error %d)\n",
__func__, VMM_NETPORT_CLASS_NAME, port->name, rc);
goto fail_port_reg;
}
#ifdef CONFIG_VERBOSE_MODE
vmm_printf("%s: Registered netport %s\n", __func__, port->name);
#endif
return rc;
fail_port_reg:
cd->dev = NULL;
cd->priv = NULL;
vmm_free(cd);
ret:
return rc;
}
/* --------------------------------------------------------------------------
* The initialization function: it is used to assign fields in the structure
* Initializes the operation table and also the slave device to transmit the data
*/
void vni_init(struct net_device *dev)
{
struct net_device *slave;
struct vni_private *priv;
ether_setup(dev); /* assign some of the fields as "generic ethernet" */
memset(netdev_priv(dev), 0, sizeof(struct vni_private));
dev->netdev_ops = &vni_net_device_ops;
/* Assign random MAC address */
random_ether_addr(dev->dev_addr);
/* Hardcode the transmitting module to USB2 */
/* interface name */
priv = netdev_priv(dev);
slave = __dev_get_by_name(&init_net, "usb2");
if (!slave)
{
printk(" Slave Interface Doesn't exists , Returning\n");
return;
}
if (slave->type != ARPHRD_ETHER && slave->type != ARPHRD_LOOPBACK)
{
printk("This is not compatible interface");
return;
}
/* The interface is good, get hold of it */
priv->priv_device = slave;
if (slave->header_ops)
dev->header_ops = &vni_header_ops;
else
dev->header_ops = NULL;
/* also, and clone its IP, MAC and other information */
memcpy(dev->dev_addr, slave->dev_addr, ETH_ALEN);
memcpy(dev->broadcast, slave->broadcast, sizeof(slave->broadcast));
/* Assign default value (no checks here) */
priv->priv_mode = VNI_PASS;
}
static void __init dummy_setup(struct net_device *dev)
{
/* Initialize the device structure. */
dev->get_stats = dummy_get_stats;
dev->hard_start_xmit = dummy_xmit;
dev->set_multicast_list = set_multicast_list;
dev->set_mac_address = dummy_set_address;
#ifdef CONFIG_NET_FASTROUTE
dev->accept_fastpath = dummy_accept_fastpath;
#endif
/* Fill in device structure with ethernet-generic values. */
ether_setup(dev);
dev->tx_queue_len = 0;
dev->flags |= IFF_NOARP;
dev->flags &= ~IFF_MULTICAST;
SET_MODULE_OWNER(dev);
random_ether_addr(dev->dev_addr);
}
/*
* Open and close
*/
static int
kni_net_open(struct net_device *dev)
{
int ret;
struct rte_kni_request req;
struct kni_dev *kni = netdev_priv(dev);
if (kni->lad_dev)
memcpy(dev->dev_addr, kni->lad_dev->dev_addr, ETH_ALEN);
#ifdef RTE_LIBRW_PIOT
else if (kni->dev_addr)
memcpy(dev->dev_addr, kni->dev_addr, ETH_ALEN);
#endif
else
/*
* Generate random mac address. eth_random_addr() is the newer
* version of generating mac address in linux kernel.
*/
random_ether_addr(dev->dev_addr);
netif_start_queue(dev);
memset(&req, 0, sizeof(req));
req.req_id = RTE_KNI_REQ_CFG_NETWORK_IF;
/* Setting if_up to non-zero means up */
req.if_up = 1;
ret = kni_net_process_request(kni, &req);
#ifdef RTE_LIBRW_PIOT
kni->rx_treat_as_tx=0;
kni->rx_treat_as_tx_delivered=0;
kni->rx_treat_as_tx_filtered=0;
kni->rx_only=0;
kni->rx_filtered=0;
kni->rx_delivered=0;
kni->tx_no_txq=0;
kni->tx_no_allocq=0;
kni->tx_enq_fail=0;
kni->tx_deq_fail=0;
#endif
return (ret == 0 ? req.result : ret);
}
