static int __init gannet_init(void) { int ret; struct net_device *dev; dev = alloc_netdev_mq(sizeof(struct gannet_private), "gannet%d", gannet_setup, 1); if (NULL == dev) return -ENOMEM; ret = register_netdev(dev); if (ret) { printk(KERN_ERR "gannet failed to register netdev\n"); free_netdev(dev); return ret; } gdev = dev; firstsetup = 1; printk(KERN_INFO "gannet initialized OK\n"); return 0; }
void *iwm_if_alloc(int sizeof_bus, struct device *dev, struct iwm_if_ops *if_ops) { struct net_device *ndev; struct wireless_dev *wdev; struct iwm_priv *iwm; int ret = 0; wdev = iwm_wdev_alloc(sizeof_bus, dev); if (IS_ERR(wdev)) return wdev; iwm = wdev_to_iwm(wdev); iwm->bus_ops = if_ops; iwm->wdev = wdev; ret = iwm_priv_init(iwm); if (ret) { dev_err(dev, "failed to init iwm_priv\n"); goto out_wdev; } wdev->iftype = iwm_mode_to_nl80211_iftype(iwm->conf.mode); ndev = alloc_netdev_mq(0, "wlan%d", ether_setup, IWM_TX_QUEUES); if (!ndev) { dev_err(dev, "no memory for network device instance\n"); ret = -ENOMEM; goto out_priv; } ndev->netdev_ops = &iwm_netdev_ops; ndev->ieee80211_ptr = wdev; SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy)); wdev->netdev = ndev; iwm->umac_profile = kmalloc(sizeof(struct iwm_umac_profile), GFP_KERNEL); if (!iwm->umac_profile) { dev_err(dev, "Couldn't alloc memory for profile\n"); ret = -ENOMEM; goto out_profile; } iwm_init_default_profile(iwm, iwm->umac_profile); return iwm; out_profile: free_netdev(ndev); out_priv: iwm_priv_deinit(iwm); out_wdev: iwm_wdev_free(iwm); return ERR_PTR(ret); }
static int __init imq_init_one(int index) { struct net_device *dev; int ret; dev = alloc_netdev_mq(0, "imq%d", imq_setup, numqueues); if (!dev) return -ENOMEM; ret = dev_alloc_name(dev, dev->name); if (ret < 0) goto fail; dev->rtnl_link_ops = &imq_link_ops; ret = register_netdevice(dev); if (ret < 0) goto fail; return 0; fail: free_netdev(dev); return ret; }
/* * create a new virtual interface with the given name */ struct net_device *mwifiex_add_virtual_intf(struct wiphy *wiphy, char *name, enum nl80211_iftype type, u32 *flags, struct vif_params *params) { struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy); struct mwifiex_private *priv; struct net_device *dev; void *mdev_priv; struct wireless_dev *wdev; if (!adapter) return ERR_PTR(-EFAULT); switch (type) { case NL80211_IFTYPE_UNSPECIFIED: case NL80211_IFTYPE_STATION: case NL80211_IFTYPE_ADHOC: priv = adapter->priv[MWIFIEX_BSS_TYPE_STA]; if (priv->bss_mode) { wiphy_err(wiphy, "cannot create multiple sta/adhoc ifaces\n"); return ERR_PTR(-EINVAL); } wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL); if (!wdev) return ERR_PTR(-ENOMEM); wdev->wiphy = wiphy; priv->wdev = wdev; wdev->iftype = NL80211_IFTYPE_STATION; if (type == NL80211_IFTYPE_UNSPECIFIED) priv->bss_mode = NL80211_IFTYPE_STATION; else priv->bss_mode = type; priv->bss_type = MWIFIEX_BSS_TYPE_STA; priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II; priv->bss_priority = MWIFIEX_BSS_ROLE_STA; priv->bss_role = MWIFIEX_BSS_ROLE_STA; priv->bss_num = 0; break; case NL80211_IFTYPE_AP: priv = adapter->priv[MWIFIEX_BSS_TYPE_UAP]; if (priv->bss_mode) { wiphy_err(wiphy, "Can't create multiple AP interfaces"); return ERR_PTR(-EINVAL); } wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL); if (!wdev) return ERR_PTR(-ENOMEM); priv->wdev = wdev; wdev->wiphy = wiphy; wdev->iftype = NL80211_IFTYPE_AP; priv->bss_type = MWIFIEX_BSS_TYPE_UAP; priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II; priv->bss_priority = MWIFIEX_BSS_ROLE_UAP; priv->bss_role = MWIFIEX_BSS_ROLE_UAP; priv->bss_started = 0; priv->bss_num = 0; priv->bss_mode = type; break; default: wiphy_err(wiphy, "type not supported\n"); return ERR_PTR(-EINVAL); } dev = alloc_netdev_mq(sizeof(struct mwifiex_private *), name, ether_setup, 1); if (!dev) { wiphy_err(wiphy, "no memory available for netdevice\n"); priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED; return ERR_PTR(-ENOMEM); } mwifiex_init_priv_params(priv, dev); priv->netdev = dev; mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv); if (adapter->config_bands & BAND_A) mwifiex_setup_ht_caps( &wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv); dev_net_set(dev, wiphy_net(wiphy)); dev->ieee80211_ptr = priv->wdev; dev->ieee80211_ptr->iftype = priv->bss_mode; memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN); memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN); SET_NETDEV_DEV(dev, wiphy_dev(wiphy)); dev->flags |= IFF_BROADCAST | IFF_MULTICAST; dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT; dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN; mdev_priv = netdev_priv(dev); *((unsigned long *) mdev_priv) = (unsigned long) priv; SET_NETDEV_DEV(dev, adapter->dev); /* Register network device */ if (register_netdevice(dev)) { wiphy_err(wiphy, "cannot register virtual network device\n"); free_netdev(dev); priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED; return ERR_PTR(-EFAULT); } sema_init(&priv->async_sem, 1); priv->scan_pending_on_block = false; dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter\n", dev->name); #ifdef CONFIG_DEBUG_FS mwifiex_dev_debugfs_init(priv); #endif return dev; }
/* fjes_probe - Device Initialization Routine */ static int fjes_probe(struct platform_device *plat_dev) { struct fjes_adapter *adapter; struct net_device *netdev; struct resource *res; struct fjes_hw *hw; int err; err = -ENOMEM; netdev = alloc_netdev_mq(sizeof(struct fjes_adapter), "es%d", NET_NAME_UNKNOWN, fjes_netdev_setup, FJES_MAX_QUEUES); if (!netdev) goto err_out; SET_NETDEV_DEV(netdev, &plat_dev->dev); dev_set_drvdata(&plat_dev->dev, netdev); adapter = netdev_priv(netdev); adapter->netdev = netdev; adapter->plat_dev = plat_dev; hw = &adapter->hw; hw->back = adapter; /* setup the private structure */ err = fjes_sw_init(adapter); if (err) goto err_free_netdev; INIT_WORK(&adapter->force_close_task, fjes_force_close_task); adapter->force_reset = false; adapter->open_guard = false; adapter->txrx_wq = alloc_workqueue(DRV_NAME "/txrx", WQ_MEM_RECLAIM, 0); adapter->control_wq = alloc_workqueue(DRV_NAME "/control", WQ_MEM_RECLAIM, 0); INIT_WORK(&adapter->tx_stall_task, fjes_tx_stall_task); INIT_WORK(&adapter->raise_intr_rxdata_task, fjes_raise_intr_rxdata_task); INIT_WORK(&adapter->unshare_watch_task, fjes_watch_unshare_task); adapter->unshare_watch_bitmask = 0; INIT_DELAYED_WORK(&adapter->interrupt_watch_task, fjes_irq_watch_task); adapter->interrupt_watch_enable = false; res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0); hw->hw_res.start = res->start; hw->hw_res.size = resource_size(res); hw->hw_res.irq = platform_get_irq(plat_dev, 0); err = fjes_hw_init(&adapter->hw); if (err) goto err_free_netdev; /* setup MAC address (02:00:00:00:00:[epid])*/ netdev->dev_addr[0] = 2; netdev->dev_addr[1] = 0; netdev->dev_addr[2] = 0; netdev->dev_addr[3] = 0; netdev->dev_addr[4] = 0; netdev->dev_addr[5] = hw->my_epid; /* EPID */ err = register_netdev(netdev); if (err) goto err_hw_exit; netif_carrier_off(netdev); fjes_dbg_adapter_init(adapter); return 0; err_hw_exit: fjes_hw_exit(&adapter->hw); err_free_netdev: free_netdev(netdev); err_out: return err; }
struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count) { return alloc_netdev_mq(sizeof_priv, "eth%d", ether_setup, queue_count); }
/* Attach a VLAN device to a mac address (ie Ethernet Card). * Returns 0 if the device was created or a negative error code otherwise. */ static int register_vlan_device(struct net_device *real_dev, u16 vlan_id) { struct net_device *new_dev; struct net *net = dev_net(real_dev); struct vlan_net *vn = net_generic(net, vlan_net_id); char name[IFNAMSIZ]; int err; if (vlan_id >= VLAN_VID_MASK) return -ERANGE; err = vlan_check_real_dev(real_dev, vlan_id); if (err < 0) return err; /* Gotta set up the fields for the device. */ switch (vn->name_type) { case VLAN_NAME_TYPE_RAW_PLUS_VID: /* name will look like: eth1.0005 */ snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id); break; case VLAN_NAME_TYPE_PLUS_VID_NO_PAD: /* Put our vlan.VID in the name. * Name will look like: vlan5 */ snprintf(name, IFNAMSIZ, "vlan%i", vlan_id); break; case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD: /* Put our vlan.VID in the name. * Name will look like: eth0.5 */ snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id); break; case VLAN_NAME_TYPE_PLUS_VID: /* Put our vlan.VID in the name. * Name will look like: vlan0005 */ default: snprintf(name, IFNAMSIZ, "vlan%.4i", vlan_id); } new_dev = alloc_netdev_mq(sizeof(struct vlan_dev_info), name, vlan_setup, real_dev->num_tx_queues); if (new_dev == NULL) return -ENOBUFS; netif_copy_real_num_queues(new_dev, real_dev); dev_net_set(new_dev, net); /* need 4 bytes for extra VLAN header info, * hope the underlying device can handle it. */ new_dev->mtu = real_dev->mtu; vlan_dev_info(new_dev)->vlan_id = vlan_id; vlan_dev_info(new_dev)->real_dev = real_dev; vlan_dev_info(new_dev)->dent = NULL; vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR; new_dev->rtnl_link_ops = &vlan_link_ops; err = register_vlan_dev(new_dev); if (err < 0) goto out_free_newdev; return 0; out_free_newdev: free_netdev(new_dev); return err; }
/* * create a new virtual interface with the given name */ struct net_device *mwifiex_add_virtual_intf(struct wiphy *wiphy, char *name, enum nl80211_iftype type, u32 *flags, struct vif_params *params) { struct mwifiex_private *priv = mwifiex_cfg80211_get_priv(wiphy); struct mwifiex_adapter *adapter; struct net_device *dev; void *mdev_priv; if (!priv) return NULL; adapter = priv->adapter; if (!adapter) return NULL; switch (type) { case NL80211_IFTYPE_UNSPECIFIED: case NL80211_IFTYPE_STATION: case NL80211_IFTYPE_ADHOC: if (priv->bss_mode) { wiphy_err(wiphy, "cannot create multiple" " station/adhoc interfaces\n"); return NULL; } if (type == NL80211_IFTYPE_UNSPECIFIED) priv->bss_mode = NL80211_IFTYPE_STATION; else priv->bss_mode = type; priv->bss_type = MWIFIEX_BSS_TYPE_STA; priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II; priv->bss_priority = 0; priv->bss_role = MWIFIEX_BSS_ROLE_STA; priv->bss_index = 0; priv->bss_num = 0; break; default: wiphy_err(wiphy, "type not supported\n"); return NULL; } dev = alloc_netdev_mq(sizeof(struct mwifiex_private *), name, ether_setup, 1); if (!dev) { wiphy_err(wiphy, "no memory available for netdevice\n"); goto error; } dev_net_set(dev, wiphy_net(wiphy)); dev->ieee80211_ptr = priv->wdev; dev->ieee80211_ptr->iftype = priv->bss_mode; memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN); memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN); SET_NETDEV_DEV(dev, wiphy_dev(wiphy)); dev->flags |= IFF_BROADCAST | IFF_MULTICAST; dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT; dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN; mdev_priv = netdev_priv(dev); *((unsigned long *) mdev_priv) = (unsigned long) priv; priv->netdev = dev; mwifiex_init_priv_params(priv, dev); SET_NETDEV_DEV(dev, adapter->dev); /* Register network device */ if (register_netdevice(dev)) { wiphy_err(wiphy, "cannot register virtual network device\n"); goto error; } sema_init(&priv->async_sem, 1); priv->scan_pending_on_block = false; dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter\n", dev->name); #ifdef CONFIG_DEBUG_FS mwifiex_dev_debugfs_init(priv); #endif return dev; error: if (dev && (dev->reg_state == NETREG_UNREGISTERED)) free_netdev(dev); priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED; return NULL; }
/*----------------------------------------------------------------------------*/ BOOLEAN kalInitBowDevice(IN P_GLUE_INFO_T prGlueInfo, IN const char *prDevName) { P_ADAPTER_T prAdapter; P_GL_HIF_INFO_T prHif; PARAM_MAC_ADDRESS rMacAddr; P_NETDEV_PRIVATE_GLUE_INFO prNetDevPriv = (P_NETDEV_PRIVATE_GLUE_INFO) NULL; ASSERT(prGlueInfo); ASSERT(prGlueInfo->rBowInfo.fgIsRegistered == TRUE); prAdapter = prGlueInfo->prAdapter; ASSERT(prAdapter); prHif = &prGlueInfo->rHifInfo; ASSERT(prHif); if (prGlueInfo->rBowInfo.fgIsNetRegistered == FALSE) { prGlueInfo->rBowInfo.prDevHandler = alloc_netdev_mq(sizeof(P_GLUE_INFO_T), prDevName, ether_setup, CFG_MAX_TXQ_NUM); if (!prGlueInfo->rBowInfo.prDevHandler) { return FALSE; } else { /* 1. setup netdev */ /* 1.1 Point to shared glue structure */ /* *((P_GLUE_INFO_T *) netdev_priv(prGlueInfo->rBowInfo.prDevHandler)) = prGlueInfo; */ prNetDevPriv = (P_NETDEV_PRIVATE_GLUE_INFO) netdev_priv(prGlueInfo->rBowInfo. prDevHandler); prNetDevPriv->prGlueInfo = prGlueInfo; /* 1.2 fill hardware address */ COPY_MAC_ADDR(rMacAddr, prAdapter->rMyMacAddr); rMacAddr[0] |= 0x2; /* change to local administrated address */ memcpy(prGlueInfo->rBowInfo.prDevHandler->dev_addr, rMacAddr, ETH_ALEN); memcpy(prGlueInfo->rBowInfo.prDevHandler->perm_addr, prGlueInfo->rBowInfo.prDevHandler->dev_addr, ETH_ALEN); /* 1.3 register callback functions */ prGlueInfo->rBowInfo.prDevHandler->netdev_ops = &bow_netdev_ops; #if (MTK_WCN_HIF_SDIO == 0) SET_NETDEV_DEV(prGlueInfo->rBowInfo.prDevHandler, &(prHif->func->dev)); #endif register_netdev(prGlueInfo->rBowInfo.prDevHandler); /* 2. net device initialize */ netif_carrier_off(prGlueInfo->rBowInfo.prDevHandler); netif_tx_stop_all_queues(prGlueInfo->rBowInfo.prDevHandler); /* 2.1 bind NetDev pointer to NetDev index */ wlanBindBssIdxToNetInterface(prGlueInfo, bowInit(prAdapter), (PVOID) prGlueInfo->rBowInfo.prDevHandler); prNetDevPriv->ucBssIdx = prAdapter->rWifiVar.rBowFsmInfo.ucBssIndex; /* wlanBindNetInterface(prGlueInfo, NET_DEV_BOW_IDX, (PVOID)prGlueInfo->rBowInfo.prDevHandler); */ /* 3. finish */ prGlueInfo->rBowInfo.fgIsNetRegistered = TRUE; } } return TRUE; }
/** * @brief This function adds a new interface. It will * allocate, initialize and register the device. * * @param handle A pointer to moal_handle structure * @param bss_index BSS index number * @param bss_type BSS type * * @return A pointer to the new priv structure */ moal_private * woal_alloc_virt_interface(moal_handle *handle, t_u8 bss_index, t_u8 bss_type, #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0) const #endif char *name) { struct net_device *dev = NULL; moal_private *priv = NULL; ENTER(); #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 29) #ifndef MAX_WMM_QUEUE #define MAX_WMM_QUEUE 4 #endif /* Allocate an Ethernet device */ dev = alloc_netdev_mq(sizeof(moal_private), name, woal_virt_if_setup, MAX_WMM_QUEUE); #else dev = alloc_netdev(sizeof(moal_private), name, woal_virt_if_setup); #endif if (!dev) { PRINTM(MFATAL, "Init virtual ethernet device failed\n"); goto error; } /* Allocate device name */ if ((dev_alloc_name(dev, name) < 0)) { PRINTM(MERROR, "Could not allocate device name\n"); goto error; } priv = (moal_private *)netdev_priv(dev); /* Save the priv to handle */ handle->priv[bss_index] = priv; /* Use the same handle structure */ priv->phandle = handle; priv->netdev = dev; priv->bss_index = bss_index; priv->bss_type = bss_type; priv->bss_role = MLAN_BSS_ROLE_STA; INIT_LIST_HEAD(&priv->tcp_sess_queue); spin_lock_init(&priv->tcp_sess_lock); spin_lock_init(&priv->tx_stat_lock); spin_lock_init(&priv->scan_req_lock); spin_lock_init(&priv->connect_lock); #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24) SET_MODULE_OWNER(dev); #endif PRINTM(MCMND, "Alloc virtual interface%s\n", dev->name); LEAVE(); return priv; error: if (dev) free_netdev(dev); LEAVE(); return NULL; }