int proc_get_rf_reg_dump4(char *page, char **start, off_t offset, int count, int *eof, void *data) { struct net_device *dev = data; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); int len = 0; int i,j=1,path; u32 value; len += snprintf(page + len, count - len, "\n======= RF REG =======\n"); path = 2; len += snprintf(page + len, count - len, "\nRF_Path(%x)\n",path); for(i=0xC0;i<0x100;i++) { //value = PHY_QueryRFReg(padapter, (RF90_RADIO_PATH_E)path,i, bMaskDWord); value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); if(j%4==1) len += snprintf(page + len, count - len, "0x%02x ",i); len += snprintf(page + len, count - len, " 0x%08x ",value); if((j++)%4==0) len += snprintf(page + len, count - len, "\n"); } *eof = 1; return len; }
ssize_t proc_set_rx_stbc(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data) { struct net_device *dev = data; struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); struct registry_priv *pregpriv = &padapter->registrypriv; char tmp[32]; u32 mode; if (count < 1) return -EFAULT; if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { sscanf(tmp, "%d ", &mode); if (pregpriv && (mode == 0 || mode == 1 || mode == 2 || mode == 3)) { pregpriv->rx_stbc = mode; printk("rx_stbc =%d\n", mode); } } return count; }
int proc_get_trx_info(struct seq_file *m, void *v) { struct net_device *dev = m->private; int i; struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct recv_priv *precvpriv = &padapter->recvpriv; struct hw_xmit *phwxmit; DBG_871X_SEL_NL(m, "free_xmitbuf_cnt =%d, free_xmitframe_cnt =%d\n" , pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt); DBG_871X_SEL_NL(m, "free_ext_xmitbuf_cnt =%d, free_xframe_ext_cnt =%d\n" , pxmitpriv->free_xmit_extbuf_cnt, pxmitpriv->free_xframe_ext_cnt); DBG_871X_SEL_NL(m, "free_recvframe_cnt =%d\n" , precvpriv->free_recvframe_cnt); for (i = 0; i < 4; i++) { phwxmit = pxmitpriv->hwxmits + i; DBG_871X_SEL_NL(m, "%d, hwq.accnt =%d\n", i, phwxmit->accnt); } return 0; }
int proc_get_rf_reg_dump1(char *page, char **start, off_t offset, int count, int *eof, void *data) { struct net_device *dev = data; struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); int len = 0; int i, j = 1, path; u32 value; len += snprintf(page + len, count - len, "\n======= RF REG =======\n"); path = 1; len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path); for (i = 0; i < 0xC0; i++) { value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff); if (j%4 == 1) len += snprintf(page + len, count - len, "0x%02x ", i); len += snprintf(page + len, count - len, " 0x%08x ", value); if ((j++)%4 == 0) len += snprintf(page + len, count - len, "\n"); } *eof = 1; return len; }
int proc_get_rx_signal(char *page, char **start, off_t offset, int count, int *eof, void *data) { struct net_device *dev = data; struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); int len = 0; len = snprintf(page + len, count, "rssi:%d\n" "rxpwdb:%d\n" "signal_strength:%u\n" "signal_qual:%u\n" "noise:%u\n", padapter->recvpriv.rssi, padapter->recvpriv.rxpwdb, padapter->recvpriv.signal_strength, padapter->recvpriv.signal_qual, padapter->recvpriv.noise ); *eof = 1; return len; }
struct proc_dir_entry *rtw_dm_proc_init(struct net_device *dev) { struct proc_dir_entry *dir_dm = NULL; struct proc_dir_entry *entry = NULL; _adapter *adapter = rtw_netdev_priv(dev); ssize_t i; if (adapter->dir_dev == NULL) { rtw_warn_on(1); goto exit; } if (adapter->dir_dm != NULL) { rtw_warn_on(1); goto exit; } dir_dm = rtw_proc_create_dir("dm", adapter->dir_dev, dev); if (dir_dm == NULL) { rtw_warn_on(1); goto exit; } adapter->dir_dm = dir_dm; for (i=0;i<dm_proc_hdls_num;i++) { entry = rtw_proc_create_entry(dm_proc_hdls[i].name, dir_dm, &rtw_dm_proc_fops, (void *)i); if (!entry) { rtw_warn_on(1); goto exit; } } exit: return dir_dm; }
int proc_set_rx_signal(struct file *file, const char *buffer, unsigned long count, void *data) { struct net_device *dev = (struct net_device *)data; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); char tmp[32]; u32 is_signal_dbg, signal_strength; if (count < 1) return -EFAULT; if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength); is_signal_dbg = is_signal_dbg==0?0:1; if(is_signal_dbg && num!=2) return count; signal_strength = signal_strength>100?100:signal_strength; signal_strength = signal_strength<0?0:signal_strength; padapter->recvpriv.is_signal_dbg = is_signal_dbg; padapter->recvpriv.signal_strength_dbg=signal_strength; if(is_signal_dbg) DBG_871X("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength); else DBG_871X("set %s\n", "HW_SIGNAL_STRENGTH"); } return count; }
int proc_set_best_channel(struct file *file, const char *buffer, unsigned long count, void *data) { struct net_device *dev = (struct net_device *)data; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; char tmp[32]; if(count < 1) return -EFAULT; if(buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) { int i; for(i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) { pmlmeext->channel_set[i].rx_count = 0; } DBG_871X("set %s\n", "Clean Best Channel Count"); } return count; }
void netdev_br_init(struct net_device *netdev) { struct adapter *adapter = (struct adapter *)rtw_netdev_priv(netdev); rcu_read_lock(); if (rcu_dereference(adapter->pnetdev->rx_handler_data)) { struct net_device *br_netdev; struct net *devnet = NULL; devnet = dev_net(netdev); br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME); if (br_netdev) { memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN); dev_put(br_netdev); } else { pr_info("%s()-%d: dev_get_by_name(%s) failed!", __func__, __LINE__, CONFIG_BR_EXT_BRNAME); } } adapter->ethBrExtInfo.addPPPoETag = 1; rcu_read_unlock(); }
void rtw_proc_remove_one(struct net_device *dev) { struct proc_dir_entry *dir_dev = NULL; struct adapter *padapter = rtw_netdev_priv(dev); u8 rf_type; dir_dev = padapter->dir_dev; padapter->dir_dev = NULL; if (dir_dev) { remove_proc_entry("write_reg", dir_dev); remove_proc_entry("read_reg", dir_dev); remove_proc_entry("fwstate", dir_dev); remove_proc_entry("sec_info", dir_dev); remove_proc_entry("mlmext_state", dir_dev); remove_proc_entry("qos_option", dir_dev); remove_proc_entry("ht_option", dir_dev); remove_proc_entry("rf_info", dir_dev); remove_proc_entry("ap_info", dir_dev); remove_proc_entry("adapter_state", dir_dev); remove_proc_entry("trx_info", dir_dev); remove_proc_entry("mac_reg_dump1", dir_dev); remove_proc_entry("mac_reg_dump2", dir_dev); remove_proc_entry("mac_reg_dump3", dir_dev); remove_proc_entry("bb_reg_dump1", dir_dev); remove_proc_entry("bb_reg_dump2", dir_dev); remove_proc_entry("bb_reg_dump3", dir_dev); remove_proc_entry("rf_reg_dump1", dir_dev); remove_proc_entry("rf_reg_dump2", dir_dev); rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type)); if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) { remove_proc_entry("rf_reg_dump3", dir_dev); remove_proc_entry("rf_reg_dump4", dir_dev); } #ifdef CONFIG_88EU_AP_MODE remove_proc_entry("all_sta_info", dir_dev); #endif remove_proc_entry("best_channel", dir_dev); remove_proc_entry("rx_signal", dir_dev); remove_proc_entry("cbw40_enable", dir_dev); remove_proc_entry("ht_enable", dir_dev); remove_proc_entry("ampdu_enable", dir_dev); remove_proc_entry("rx_stbc", dir_dev); remove_proc_entry("path_rssi", dir_dev); remove_proc_entry("rssi_disp", dir_dev); remove_proc_entry(dev->name, rtw_proc); dir_dev = NULL; } else { return; } rtw_proc_cnt--; if (rtw_proc_cnt == 0) { if (rtw_proc) { remove_proc_entry("ver_info", rtw_proc); remove_proc_entry(rtw_proc_name, init_net.proc_net); rtw_proc = NULL; } } }
/* dummy routines */ void rtw_proc_remove_one(struct net_device *dev) { } void rtw_proc_init_one(struct net_device *dev) { } #if 0 /* TODO: Convert these to /sys */ void rtw_proc_init_one(struct net_device *dev) { struct proc_dir_entry *dir_dev = NULL; struct proc_dir_entry *entry = NULL; struct adapter *padapter = rtw_netdev_priv(dev); u8 rf_type; if (rtw_proc == NULL) { memcpy(rtw_proc_name, DRV_NAME, sizeof(DRV_NAME)); rtw_proc = create_proc_entry(rtw_proc_name, S_IFDIR, init_net.proc_net); if (rtw_proc == NULL) { DBG_88E(KERN_ERR "Unable to create rtw_proc directory\n"); return; } entry = create_proc_read_entry("ver_info", S_IFREG | S_IRUGO, rtw_proc, proc_get_drv_version, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } } if (padapter->dir_dev == NULL) { padapter->dir_dev = create_proc_entry(dev->name, S_IFDIR | S_IRUGO | S_IXUGO, rtw_proc); dir_dev = padapter->dir_dev; if (dir_dev == NULL) { if (rtw_proc_cnt == 0) { if (rtw_proc) { remove_proc_entry(rtw_proc_name, init_net.proc_net); rtw_proc = NULL; } } pr_info("Unable to create dir_dev directory\n"); return; } } else { return; } rtw_proc_cnt++; entry = create_proc_read_entry("write_reg", S_IFREG | S_IRUGO, dir_dev, proc_get_write_reg, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_write_reg; entry = create_proc_read_entry("read_reg", S_IFREG | S_IRUGO, dir_dev, proc_get_read_reg, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_read_reg; entry = create_proc_read_entry("fwstate", S_IFREG | S_IRUGO, dir_dev, proc_get_fwstate, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("sec_info", S_IFREG | S_IRUGO, dir_dev, proc_get_sec_info, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("mlmext_state", S_IFREG | S_IRUGO, dir_dev, proc_get_mlmext_state, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("qos_option", S_IFREG | S_IRUGO, dir_dev, proc_get_qos_option, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("ht_option", S_IFREG | S_IRUGO, dir_dev, proc_get_ht_option, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rf_info", S_IFREG | S_IRUGO, dir_dev, proc_get_rf_info, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("ap_info", S_IFREG | S_IRUGO, dir_dev, proc_get_ap_info, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("adapter_state", S_IFREG | S_IRUGO, dir_dev, proc_getstruct adapter_state, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("trx_info", S_IFREG | S_IRUGO, dir_dev, proc_get_trx_info, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("mac_reg_dump1", S_IFREG | S_IRUGO, dir_dev, proc_get_mac_reg_dump1, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("mac_reg_dump2", S_IFREG | S_IRUGO, dir_dev, proc_get_mac_reg_dump2, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("mac_reg_dump3", S_IFREG | S_IRUGO, dir_dev, proc_get_mac_reg_dump3, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("bb_reg_dump1", S_IFREG | S_IRUGO, dir_dev, proc_get_bb_reg_dump1, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("bb_reg_dump2", S_IFREG | S_IRUGO, dir_dev, proc_get_bb_reg_dump2, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("bb_reg_dump3", S_IFREG | S_IRUGO, dir_dev, proc_get_bb_reg_dump3, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rf_reg_dump1", S_IFREG | S_IRUGO, dir_dev, proc_get_rf_reg_dump1, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rf_reg_dump2", S_IFREG | S_IRUGO, dir_dev, proc_get_rf_reg_dump2, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type)); if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) { entry = create_proc_read_entry("rf_reg_dump3", S_IFREG | S_IRUGO, dir_dev, proc_get_rf_reg_dump3, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rf_reg_dump4", S_IFREG | S_IRUGO, dir_dev, proc_get_rf_reg_dump4, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } } #ifdef CONFIG_88EU_AP_MODE entry = create_proc_read_entry("all_sta_info", S_IFREG | S_IRUGO, dir_dev, proc_get_all_sta_info, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } #endif entry = create_proc_read_entry("best_channel", S_IFREG | S_IRUGO, dir_dev, proc_get_best_channel, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rx_signal", S_IFREG | S_IRUGO, dir_dev, proc_get_rx_signal, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_rx_signal; entry = create_proc_read_entry("ht_enable", S_IFREG | S_IRUGO, dir_dev, proc_get_ht_enable, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_ht_enable; entry = create_proc_read_entry("cbw40_enable", S_IFREG | S_IRUGO, dir_dev, proc_get_cbw40_enable, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_cbw40_enable; entry = create_proc_read_entry("ampdu_enable", S_IFREG | S_IRUGO, dir_dev, proc_get_ampdu_enable, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_ampdu_enable; entry = create_proc_read_entry("rx_stbc", S_IFREG | S_IRUGO, dir_dev, proc_get_rx_stbc, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_rx_stbc; entry = create_proc_read_entry("path_rssi", S_IFREG | S_IRUGO, dir_dev, proc_get_two_path_rssi, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rssi_disp", S_IFREG | S_IRUGO, dir_dev, proc_get_rssi_disp, dev); if (!entry) { pr_info("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_rssi_disp; }
void rtw_proc_remove_one(struct net_device *dev) { struct proc_dir_entry *dir_dev = NULL; _adapter *padapter = rtw_netdev_priv(dev); dir_dev = padapter->dir_dev; padapter->dir_dev = NULL; if (dir_dev) { remove_proc_entry("write_reg", dir_dev); remove_proc_entry("read_reg", dir_dev); remove_proc_entry("fwstate", dir_dev); remove_proc_entry("sec_info", dir_dev); remove_proc_entry("mlmext_state", dir_dev); remove_proc_entry("qos_option", dir_dev); remove_proc_entry("ht_option", dir_dev); remove_proc_entry("rf_info", dir_dev); remove_proc_entry("ap_info", dir_dev); remove_proc_entry("adapter_state", dir_dev); remove_proc_entry("trx_info", dir_dev); #ifdef CONFIG_AP_MODE remove_proc_entry("all_sta_info", dir_dev); #endif #ifdef DBG_MEMORY_LEAK remove_proc_entry("_malloc_cnt", dir_dev); #endif #ifdef CONFIG_FIND_BEST_CHANNEL remove_proc_entry("best_channel", dir_dev); #endif remove_proc_entry("rx_signal", dir_dev); remove_proc_entry("rssi_disp", dir_dev); remove_proc_entry(dev->name, rtw_proc); dir_dev = NULL; } else { return; } rtw_proc_cnt--; if(rtw_proc_cnt == 0) { if(rtw_proc){ remove_proc_entry("ver_info", rtw_proc); #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) remove_proc_entry(rtw_proc_name, proc_net); #else remove_proc_entry(rtw_proc_name, init_net.proc_net); #endif rtw_proc = NULL; } } }
_adapter *rtw_sdio_if1_init(struct dvobj_priv *dvobj, const struct sdio_device_id *pdid){ int status = _FAIL; struct net_device *pnetdev; PADAPTER padapter = NULL; u8 mac_addr[ETH_ALEN]; u16 fw_ready; u32 i; _func_enter_; if ((padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter))) == NULL) { DBG_871X("%s: vmalloc for padapter failed!\n", __FUNCTION__); goto exit; } padapter->dvobj = dvobj; dvobj->if1 = padapter; padapter->interface_type = RTW_SDIO; // 1. init network device data pnetdev = rtw_init_netdev(padapter); if (!pnetdev) goto free_adapter; SET_NETDEV_DEV(pnetdev, &dvobj->intf_data.func->dev); padapter = rtw_netdev_priv(pnetdev); // 2. init driver special setting, interface, OS and hardware relative rtw_set_hal_ops(padapter); // 3. initialize Chip version padapter->intf_start = &sd_intf_start; padapter->intf_stop = &sd_intf_stop; padapter->intf_init = &sdio_init; padapter->intf_deinit = &sdio_deinit; padapter->intf_alloc_irq = &sdio_alloc_irq; padapter->intf_free_irq = &sdio_free_irq; sdio_set_intf_ops(padapter, &padapter->io_ops); // 4. init driver common data if (rtw_init_drv_sw(padapter) == _FAIL) { goto free_adapter; } // 5. get MAC address mac_addr[0] = 0x00; mac_addr[1] = 0xe0; mac_addr[2] = 0x4c; mac_addr[3] = 0xB7; mac_addr[4] = 0x23; mac_addr[5] = 0x00; _rtw_memcpy(pnetdev->dev_addr, mac_addr, ETH_ALEN); #ifdef CONFIG_FWDL // wait for the device boot code ready for (i=0;i<100;i++) { fw_ready = rtw_read16(padapter, SDIO_REG_HCPWM2); if (fw_ready & SDIO_INIT_DONE) { break; } rtw_msleep_os(10); } if (i==100) { DBG_871X("%s: Wait Device Firmware Ready Timeout!!SDIO_REG_HCPWM2 @ 0x%04x\n", __FUNCTION__, fw_ready); goto free_adapter; } #else // wait for the device firmware ready for (i=0;i<100;i++) { fw_ready = rtw_read8(padapter, SDIO_REG_CPU_IND); if (fw_ready & SDIO_SYSTEM_TRX_RDY_IND) { break; } rtw_msleep_os(10); } if (i==100) { DBG_871X("%s: Wait Device Firmware Ready Timeout!!SDIO_REG_CPU_IND @ 0x%04x\n", __FUNCTION__, fw_ready); goto free_adapter; } #endif rtw_hal_disable_interrupt(padapter); DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d\n" ,padapter->bDriverStopped ,padapter->bSurpriseRemoved ,padapter->bup ); status = _SUCCESS; free_adapter: if (status != _SUCCESS) { if (pnetdev) rtw_free_netdev(pnetdev); else rtw_vmfree((u8*)padapter, sizeof(*padapter)); padapter = NULL; } exit: _func_exit_; return padapter; }
int proc_get_all_sta_info(struct seq_file *m, void *v) { struct net_device *dev = m->private; _irqL irqL; struct sta_info *psta; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); struct sta_priv *pstapriv = &padapter->stapriv; int i, j; _list *plist, *phead; struct recv_reorder_ctrl *preorder_ctrl; DBG_871X_SEL_NL(m, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap); _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL); for(i=0; i< NUM_STA; i++) { phead = &(pstapriv->sta_hash[i]); plist = get_next(phead); while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) { psta = LIST_CONTAINOR(plist, struct sta_info, hash_list); plist = get_next(plist); //if(extra_arg == psta->aid) { DBG_871X_SEL_NL(m, "==============================\n"); DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr)); DBG_871X_SEL_NL(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self); DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid); #ifdef CONFIG_80211N_HT DBG_871X_SEL_NL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate); DBG_871X_SEL_NL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n", psta->bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m); DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable); DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap); #endif //CONFIG_80211N_HT DBG_871X_SEL_NL(m, "sleepq_len=%d\n", psta->sleepq_len); DBG_871X_SEL_NL(m, "sta_xmitpriv.vo_q_qcnt=%d\n", psta->sta_xmitpriv.vo_q.qcnt); DBG_871X_SEL_NL(m, "sta_xmitpriv.vi_q_qcnt=%d\n", psta->sta_xmitpriv.vi_q.qcnt); DBG_871X_SEL_NL(m, "sta_xmitpriv.be_q_qcnt=%d\n", psta->sta_xmitpriv.be_q.qcnt); DBG_871X_SEL_NL(m, "sta_xmitpriv.bk_q_qcnt=%d\n", psta->sta_xmitpriv.bk_q.qcnt); DBG_871X_SEL_NL(m, "capability=0x%x\n", psta->capability); DBG_871X_SEL_NL(m, "flags=0x%x\n", psta->flags); DBG_871X_SEL_NL(m, "wpa_psk=0x%x\n", psta->wpa_psk); DBG_871X_SEL_NL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher); DBG_871X_SEL_NL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher); DBG_871X_SEL_NL(m, "qos_info=0x%x\n", psta->qos_info); DBG_871X_SEL_NL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy); for(j=0;j<16;j++) { preorder_ctrl = &psta->recvreorder_ctrl[j]; if(preorder_ctrl->enable) { DBG_871X_SEL_NL(m, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq); } } #ifdef CONFIG_TDLS DBG_871X_SEL_NL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state); DBG_871X_SEL_NL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime); DBG_871X_SEL_NL(m, "rx_data_pkts=%llu\n", psta->sta_stats.rx_data_pkts); DBG_871X_SEL_NL(m, "rx_bytes=%llu\n", psta->sta_stats.rx_bytes); DBG_871X_SEL_NL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts); DBG_871X_SEL_NL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes); #endif //CONFIG_TDLS DBG_871X_SEL_NL(m, "==============================\n"); } } } _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL); return 0; }
int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) { int ret = 0; char *command = NULL; int cmd_num; int bytes_written = 0; #ifdef CONFIG_PNO_SUPPORT uint cmdlen = 0; uint pno_enable = 0; #endif android_wifi_priv_cmd priv_cmd; _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); #ifdef CONFIG_WFD struct wifi_display_info *pwfd_info; #endif rtw_lock_suspend(); if (!ifr->ifr_data) { ret = -EINVAL; goto exit; } if (copy_from_user(&priv_cmd, ifr->ifr_data, sizeof(android_wifi_priv_cmd))) { ret = -EFAULT; goto exit; } if ( padapter->registrypriv.mp_mode == 1) { ret = -EFAULT; goto exit; } //DBG_871X("%s priv_cmd.buf=%p priv_cmd.total_len=%d priv_cmd.used_len=%d\n",__func__,priv_cmd.buf,priv_cmd.total_len,priv_cmd.used_len); command = rtw_zmalloc(priv_cmd.total_len); if (!command) { DBG_871X("%s: failed to allocate memory\n", __FUNCTION__); ret = -ENOMEM; goto exit; } if (!access_ok(VERIFY_READ, priv_cmd.buf, priv_cmd.total_len)){ DBG_871X("%s: failed to access memory\n", __FUNCTION__); ret = -EFAULT; goto exit; } #ifdef CONFIG_COMPAT if (copy_from_user(command, compat_ptr(priv_cmd.buf), (unsigned long) priv_cmd.total_len)) { #else if (copy_from_user(command, (void *)priv_cmd.buf, priv_cmd.total_len)) { #endif ret = -EFAULT; goto exit; } DBG_871X("%s: Android private cmd \"%s\" on %s\n" , __FUNCTION__, command, ifr->ifr_name); cmd_num = rtw_android_cmdstr_to_num(command); switch(cmd_num) { case ANDROID_WIFI_CMD_START: //bytes_written = wl_android_wifi_on(net); goto response; case ANDROID_WIFI_CMD_SETFWPATH: goto response; } if (!g_wifi_on) { DBG_871X("%s: Ignore private cmd \"%s\" - iface %s is down\n" ,__FUNCTION__, command, ifr->ifr_name); ret = 0; goto exit; } switch(cmd_num) { case ANDROID_WIFI_CMD_STOP: //bytes_written = wl_android_wifi_off(net); break; case ANDROID_WIFI_CMD_SCAN_ACTIVE: //rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_ACTIVE); #ifdef CONFIG_PLATFORM_MSTAR #ifdef CONFIG_IOCTL_CFG80211 adapter_wdev_data((_adapter *)rtw_netdev_priv(net))->bandroid_scan = _TRUE; #endif //CONFIG_IOCTL_CFG80211 #endif //CONFIG_PLATFORM_MSTAR break; case ANDROID_WIFI_CMD_SCAN_PASSIVE: //rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_PASSIVE); break; case ANDROID_WIFI_CMD_RSSI: bytes_written = rtw_android_get_rssi(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_LINKSPEED: bytes_written = rtw_android_get_link_speed(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_MACADDR: bytes_written = rtw_android_get_macaddr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_BLOCK: bytes_written = rtw_android_set_block(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_RXFILTER_START: //bytes_written = net_os_set_packet_filter(net, 1); break; case ANDROID_WIFI_CMD_RXFILTER_STOP: //bytes_written = net_os_set_packet_filter(net, 0); break; case ANDROID_WIFI_CMD_RXFILTER_ADD: //int filter_num = *(command + strlen(CMD_RXFILTER_ADD) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, TRUE, filter_num); break; case ANDROID_WIFI_CMD_RXFILTER_REMOVE: //int filter_num = *(command + strlen(CMD_RXFILTER_REMOVE) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, FALSE, filter_num); break; case ANDROID_WIFI_CMD_BTCOEXSCAN_START: /* TBD: BTCOEXSCAN-START */ break; case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP: /* TBD: BTCOEXSCAN-STOP */ break; case ANDROID_WIFI_CMD_BTCOEXMODE: #if 0 uint mode = *(command + strlen(CMD_BTCOEXMODE) + 1) - '0'; if (mode == 1) net_os_set_packet_filter(net, 0); /* DHCP starts */ else net_os_set_packet_filter(net, 1); /* DHCP ends */ #ifdef WL_CFG80211 bytes_written = wl_cfg80211_set_btcoex_dhcp(net, command); #endif #endif break; case ANDROID_WIFI_CMD_SETSUSPENDOPT: //bytes_written = wl_android_set_suspendopt(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_SETBAND: bytes_written = rtw_android_setband(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_GETBAND: bytes_written = rtw_android_getband(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_COUNTRY: bytes_written = rtw_android_set_country(net, command, priv_cmd.total_len); break; #ifdef CONFIG_PNO_SUPPORT case ANDROID_WIFI_CMD_PNOSSIDCLR_SET: //bytes_written = dhd_dev_pno_reset(net); break; case ANDROID_WIFI_CMD_PNOSETUP_SET: bytes_written = rtw_android_pno_setup(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_PNOENABLE_SET: cmdlen = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_PNOENABLE_SET]); pno_enable = *(command + cmdlen + 1) - '0'; bytes_written = rtw_android_pno_enable(net, pno_enable); break; #endif case ANDROID_WIFI_CMD_P2P_DEV_ADDR: bytes_written = rtw_android_get_p2p_dev_addr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_NOA: //int skip = strlen(CMD_P2P_SET_NOA) + 1; //bytes_written = wl_cfg80211_set_p2p_noa(net, command + skip, priv_cmd.total_len - skip); break; case ANDROID_WIFI_CMD_P2P_GET_NOA: //bytes_written = wl_cfg80211_get_p2p_noa(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_PS: //int skip = strlen(CMD_P2P_SET_PS) + 1; //bytes_written = wl_cfg80211_set_p2p_ps(net, command + skip, priv_cmd.total_len - skip); break; #ifdef CONFIG_IOCTL_CFG80211 case ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE: { int skip = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE]) + 3; bytes_written = rtw_cfg80211_set_mgnt_wpsp2pie(net, command + skip, priv_cmd.total_len - skip, *(command + skip - 2) - '0'); break; } #endif //CONFIG_IOCTL_CFG80211 #ifdef CONFIG_WFD case ANDROID_WIFI_CMD_WFD_ENABLE: { // Commented by Albert 2012/07/24 // We can enable the WFD function by using the following command: // wpa_cli driver wfd-enable pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->wfd_enable = _TRUE; break; } case ANDROID_WIFI_CMD_WFD_DISABLE: { // Commented by Albert 2012/07/24 // We can disable the WFD function by using the following command: // wpa_cli driver wfd-disable pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->wfd_enable = _FALSE; break; } case ANDROID_WIFI_CMD_WFD_SET_TCPPORT: { // Commented by Albert 2012/07/24 // We can set the tcp port number by using the following command: // wpa_cli driver wfd-set-tcpport = 554 pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) { #ifdef CONFIG_COMPAT pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( compat_ptr(priv_cmd.buf) ); #else pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( priv_cmd.buf ); #endif } break; } case ANDROID_WIFI_CMD_WFD_SET_MAX_TPUT: { break; } case ANDROID_WIFI_CMD_WFD_SET_DEVTYPE: { // Commented by Albert 2012/08/28 // Specify the WFD device type ( WFD source/primary sink ) pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) { #ifdef CONFIG_COMPAT pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( compat_ptr(priv_cmd.buf) ); #else pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( priv_cmd.buf ); #endif pwfd_info->wfd_device_type &= WFD_DEVINFO_DUAL; } break; } #endif case ANDROID_WIFI_CMD_CHANGE_DTIM: { #ifdef CONFIG_LPS u8 dtim; u8 *ptr = (u8 *) &priv_cmd.buf; ptr += 9;//string command length of "SET_DTIM"; dtim = rtw_atoi(ptr); DBG_871X("DTIM=%d\n", dtim); rtw_lps_change_dtim_cmd(padapter, dtim); #endif } break; case ANDROID_WIFI_CMD_HOSTAPD_SET_MACADDR_ACL: { padapter->stapriv.acl_list.mode = ( u8 ) get_int_from_command(command); DBG_871X("%s ANDROID_WIFI_CMD_HOSTAPD_SET_MACADDR_ACL mode:%d\n", __FUNCTION__, padapter->stapriv.acl_list.mode); break; } case ANDROID_WIFI_CMD_HOSTAPD_ACL_ADD_STA: { u8 addr[ETH_ALEN] = {0x00}; macstr2num(addr, command+strlen("HOSTAPD_ACL_ADD_STA")+3); // 3 is space bar + "=" + space bar these 3 chars rtw_acl_add_sta(padapter, addr); break; } case ANDROID_WIFI_CMD_HOSTAPD_ACL_REMOVE_STA: { u8 addr[ETH_ALEN] = {0x00}; macstr2num(addr, command+strlen("HOSTAPD_ACL_REMOVE_STA")+3); // 3 is space bar + "=" + space bar these 3 chars rtw_acl_remove_sta(padapter, addr); break; } #ifdef CONFIG_GTK_OL case ANDROID_WIFI_CMD_GTK_REKEY_OFFLOAD: rtw_gtk_offload(net, priv_cmd.buf); break; #endif //CONFIG_GTK_OL case ANDROID_WIFI_CMD_P2P_DISABLE: { struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; struct wifidirect_info *pwdinfo= &(padapter->wdinfo); u8 channel, ch_offset; u16 bwmode; rtw_p2p_enable(padapter, P2P_ROLE_DISABLE); break; } default: DBG_871X("Unknown PRIVATE command %s - ignored\n", command); snprintf(command, 3, "OK"); bytes_written = strlen("OK"); } response: if (bytes_written >= 0) { if ((bytes_written == 0) && (priv_cmd.total_len > 0)) command[0] = '\0'; if (bytes_written >= priv_cmd.total_len) { DBG_871X("%s: bytes_written = %d\n", __FUNCTION__, bytes_written); bytes_written = priv_cmd.total_len; } else { bytes_written++; } priv_cmd.used_len = bytes_written; #ifdef CONFIG_COMPAT if (copy_to_user(compat_ptr(priv_cmd.buf), command, bytes_written)) { #else if (copy_to_user((void *)priv_cmd.buf, command, bytes_written)) { #endif DBG_871X("%s: failed to copy data to user buffer\n", __FUNCTION__); ret = -EFAULT; } } else { ret = bytes_written; } exit: rtw_unlock_suspend(); if (command) { rtw_mfree(command, priv_cmd.total_len); } return ret; } /** * Functions for Android WiFi card detection */ #if defined(RTW_ENABLE_WIFI_CONTROL_FUNC) static int g_wifidev_registered = 0; static struct semaphore wifi_control_sem; static struct wifi_platform_data *wifi_control_data = NULL; static struct resource *wifi_irqres = NULL; static int wifi_add_dev(void); static void wifi_del_dev(void); int rtw_android_wifictrl_func_add(void) { int ret = 0; sema_init(&wifi_control_sem, 0); ret = wifi_add_dev(); if (ret) { DBG_871X("%s: platform_driver_register failed\n", __FUNCTION__); return ret; } g_wifidev_registered = 1; /* Waiting callback after platform_driver_register is done or exit with error */ if (down_timeout(&wifi_control_sem, msecs_to_jiffies(1000)) != 0) { ret = -EINVAL; DBG_871X("%s: platform_driver_register timeout\n", __FUNCTION__); } return ret; } void rtw_android_wifictrl_func_del(void) { if (g_wifidev_registered) { wifi_del_dev(); g_wifidev_registered = 0; } } void *wl_android_prealloc(int section, unsigned long size) { void *alloc_ptr = NULL; if (wifi_control_data && wifi_control_data->mem_prealloc) { alloc_ptr = wifi_control_data->mem_prealloc(section, size); if (alloc_ptr) { DBG_871X("success alloc section %d\n", section); if (size != 0L) memset(alloc_ptr, 0, size); return alloc_ptr; } } DBG_871X("can't alloc section %d\n", section); return NULL; }
struct net_device *rtw_init_netdev(_adapter *old_padapter) { _adapter *padapter; struct net_device *pnetdev; RT_TRACE(_module_os_intfs_c_,_drv_info_,("+init_net_dev\n")); if(old_padapter != NULL) pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(_adapter), (void *)old_padapter); else pnetdev = rtw_alloc_etherdev(sizeof(_adapter)); if (!pnetdev) return NULL; padapter = rtw_netdev_priv(pnetdev); padapter->pnetdev = pnetdev; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) SET_MODULE_OWNER(pnetdev); #endif //pnetdev->init = NULL; #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29)) DBG_8192C("register rtw_netdev_ops to netdev_ops\n"); pnetdev->netdev_ops = &rtw_netdev_ops; #else pnetdev->open = netdev_open; pnetdev->stop = netdev_close; pnetdev->hard_start_xmit = rtw_xmit_entry; pnetdev->set_mac_address = rtw_net_set_mac_address; pnetdev->get_stats = rtw_net_get_stats; pnetdev->do_ioctl = rtw_ioctl; #endif #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX pnetdev->features |= NETIF_F_IP_CSUM; #endif //pnetdev->tx_timeout = NULL; pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */ pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def; #ifdef WIRELESS_SPY //priv->wireless_data.spy_data = &priv->spy_data; //pnetdev->wireless_data = &priv->wireless_data; #endif //step 2. loadparam(padapter, pnetdev); return pnetdev; }
int _netdev_open(struct net_device *pnetdev) { uint status; struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - dev_open\n")); DBG_88E("+88eu_drv - drv_open, bup =%d\n", padapter->bup); if (pwrctrlpriv->ps_flag) { padapter->net_closed = false; goto netdev_open_normal_process; } if (!padapter->bup) { padapter->bDriverStopped = false; padapter->bSurpriseRemoved = false; status = rtw_hal_init(padapter); if (status == _FAIL) { RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl88eu_hal_init(): Can't init h/w!\n")); goto netdev_open_error; } pr_info("MAC Address = %pM\n", pnetdev->dev_addr); status = rtw_start_drv_threads(padapter); if (status == _FAIL) { pr_info("Initialize driver software resource Failed!\n"); goto netdev_open_error; } if (init_hw_mlme_ext(padapter) == _FAIL) { pr_info("can't init mlme_ext_priv\n"); goto netdev_open_error; } if (padapter->intf_start) padapter->intf_start(padapter); rtw_proc_init_one(pnetdev); rtw_led_control(padapter, LED_CTL_NO_LINK); padapter->bup = true; } padapter->net_closed = false; _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000); padapter->pwrctrlpriv.bips_processing = false; rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv); if (!rtw_netif_queue_stopped(pnetdev)) netif_tx_start_all_queues(pnetdev); else netif_tx_wake_all_queues(pnetdev); netdev_open_normal_process: RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - dev_open\n")); DBG_88E("-88eu_drv - drv_open, bup =%d\n", padapter->bup); return 0; netdev_open_error: padapter->bup = false; netif_carrier_off(pnetdev); netif_tx_stop_all_queues(pnetdev); RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-88eu_drv - dev_open, fail!\n")); DBG_88E("-88eu_drv - drv_open fail, bup =%d\n", padapter->bup); return -1; }
int proc_get_btcoex_info(char *page, char **start, off_t offset, int count, int *eof, void *data) { struct net_device *dev; PADAPTER padapter; const u32 bufsize = 30*100; static u8 *pbuf = NULL; static u32 remainlen = 0; s32 len; dev = (struct net_device*)data; padapter = (PADAPTER)rtw_netdev_priv(dev); len = 0; if (0 == offset) { if (bufsize > count) { if (NULL == pbuf) { pbuf = rtw_zmalloc(bufsize); if (NULL == pbuf) { return -ENOMEM; } } BT_DisplayBtCoexInfo(padapter, pbuf, bufsize); remainlen = strlen(pbuf); if (remainlen <= count) { _rtw_memcpy(page, pbuf, remainlen); len = remainlen; remainlen = 0; } } else { _rtw_memset(page, 0, count); BT_DisplayBtCoexInfo(padapter, page, count); len = strlen(page); remainlen = 0; } } if (remainlen && pbuf) { *start = page; if (remainlen > count) len = count; else len = remainlen; _rtw_memcpy(page, pbuf+offset, len); remainlen -= len; } else { remainlen = 0; len += offset; } if (0 == remainlen) { if (pbuf) { rtw_mfree(pbuf, bufsize); DBG_871X("%s,call rtw free mem!\n",__func__); pbuf = NULL; } *eof = 1; } return len; }
int _rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev) { _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; #ifdef CONFIG_TX_MCAST2UNI struct mlme_priv *pmlmepriv = &padapter->mlmepriv; extern int rtw_mc2u_disable; #endif // CONFIG_TX_MCAST2UNI s32 res = 0; #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35)) u16 queue; #endif _func_enter_; RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("+xmit_enry\n")); if (rtw_if_up(padapter) == _FALSE) { RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("rtw_xmit_entry: rtw_if_up fail\n")); #ifdef DBG_TX_DROP_FRAME DBG_871X("DBG_TX_DROP_FRAME %s if_up fail\n", __FUNCTION__); #endif goto drop_packet; } #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35)) queue = skb_get_queue_mapping(pkt); /* No free space for Tx, tx_worker is too slow */ if (pxmitpriv->hwxmits[queue].accnt > NR_XMITFRAME/2) { //DBG_871X("%s(): stop netif_subqueue[%d]\n", __FUNCTION__, queue); netif_stop_subqueue(padapter->pnetdev, queue); return NETDEV_TX_BUSY; } #endif #ifdef CONFIG_TX_MCAST2UNI if ( !rtw_mc2u_disable && check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && ( IP_MCAST_MAC(pkt->data) || ICMPV6_MCAST_MAC(pkt->data) ) && (padapter->registrypriv.wifi_spec == 0) ) { if ( pxmitpriv->free_xmitframe_cnt > (NR_XMITFRAME/4) ) { res = rtw_mlcst2unicst(padapter, pkt); if (res == _TRUE) { goto exit; } } else { //DBG_871X("Stop M2U(%d, %d)! ", pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmitbuf_cnt); //DBG_871X("!m2u ); } } #endif // CONFIG_TX_MCAST2UNI res = rtw_xmit(padapter, &pkt); if (res < 0) { #ifdef DBG_TX_DROP_FRAME DBG_871X("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__); #endif goto drop_packet; } pxmitpriv->tx_pkts++; RT_TRACE(_module_xmit_osdep_c_, _drv_info_, ("rtw_xmit_entry: tx_pkts=%d\n", (u32)pxmitpriv->tx_pkts)); goto exit; drop_packet: pxmitpriv->tx_drop++; rtw_skb_free(pkt); RT_TRACE(_module_xmit_osdep_c_, _drv_notice_, ("rtw_xmit_entry: drop, tx_drop=%d\n", (u32)pxmitpriv->tx_drop)); exit: _func_exit_; return 0; }
int proc_get_all_sta_info(char *page, char **start, off_t offset, int count, int *eof, void *data) { _irqL irqL; struct sta_info *psta; struct net_device *dev = data; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); struct sta_priv *pstapriv = &padapter->stapriv; int i, j; _list *plist, *phead; struct recv_reorder_ctrl *preorder_ctrl; int len = 0; len += snprintf(page + len, count - len, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap); _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL); for(i=0; i< NUM_STA; i++) { phead = &(pstapriv->sta_hash[i]); plist = get_next(phead); while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) { psta = LIST_CONTAINOR(plist, struct sta_info, hash_list); plist = get_next(plist); //if(extra_arg == psta->aid) { len += snprintf(page + len, count - len, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr)); len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self); len += snprintf(page + len, count - len, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid); #ifdef CONFIG_80211N_HT len += snprintf(page + len, count - len, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate); len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi); len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable); len += snprintf(page + len, count - len, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap); #endif //CONFIG_80211N_HT len += snprintf(page + len, count - len, "sleepq_len=%d\n", psta->sleepq_len); len += snprintf(page + len, count - len, "capability=0x%x\n", psta->capability); len += snprintf(page + len, count - len, "flags=0x%x\n", psta->flags); len += snprintf(page + len, count - len, "wpa_psk=0x%x\n", psta->wpa_psk); len += snprintf(page + len, count - len, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher); len += snprintf(page + len, count - len, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher); len += snprintf(page + len, count - len, "qos_info=0x%x\n", psta->qos_info); len += snprintf(page + len, count - len, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy); for(j=0;j<16;j++) { preorder_ctrl = &psta->recvreorder_ctrl[j]; if(preorder_ctrl->enable) { len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq); } } } } } _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL); *eof = 1; return len; }
int hostapd_mode_init(_adapter *padapter) { unsigned char mac[ETH_ALEN]; struct hostapd_priv *phostapdpriv; struct net_device *pnetdev; pnetdev = rtw_alloc_etherdev(sizeof(struct hostapd_priv)); if (!pnetdev) return -ENOMEM; //SET_MODULE_OWNER(pnetdev); ether_setup(pnetdev); //pnetdev->type = ARPHRD_IEEE80211; phostapdpriv = rtw_netdev_priv(pnetdev); phostapdpriv->pmgnt_netdev = pnetdev; phostapdpriv->padapter= padapter; padapter->phostapdpriv = phostapdpriv; //pnetdev->init = NULL; #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29)) DBG_871X("register rtl871x_mgnt_netdev_ops to netdev_ops\n"); pnetdev->netdev_ops = &rtl871x_mgnt_netdev_ops; #else pnetdev->open = mgnt_netdev_open; pnetdev->stop = mgnt_netdev_close; pnetdev->hard_start_xmit = mgnt_xmit_entry; //pnetdev->set_mac_address = r871x_net_set_mac_address; //pnetdev->get_stats = r871x_net_get_stats; //pnetdev->do_ioctl = r871x_mp_ioctl; #endif pnetdev->watchdog_timeo = HZ; /* 1 second timeout */ //pnetdev->wireless_handlers = NULL; #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX pnetdev->features |= NETIF_F_IP_CSUM; #endif if(dev_alloc_name(pnetdev,"mgnt.wlan%d") < 0) { DBG_871X("hostapd_mode_init(): dev_alloc_name, fail! \n"); } //SET_NETDEV_DEV(pnetdev, pintfpriv->udev); mac[0]=0x00; mac[1]=0xe0; mac[2]=0x4c; mac[3]=0x87; mac[4]=0x11; mac[5]=0x12; _rtw_memcpy(pnetdev->dev_addr, mac, ETH_ALEN); netif_carrier_off(pnetdev); /* Tell the network stack we exist */ if (register_netdev(pnetdev) != 0) { DBG_871X("hostapd_mode_init(): register_netdev fail!\n"); if(pnetdev) { rtw_free_netdev(pnetdev); } } return 0; }
//extern int rfpwrstate_check(_adapter *padapter); static int netdev_close(struct net_device *pnetdev) { _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev); RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - drv_close\n")); if(padapter->pwrctrlpriv.bInternalAutoSuspend == _TRUE) { //rfpwrstate_check(padapter); if(padapter->pwrctrlpriv.rf_pwrstate == rf_off) padapter->pwrctrlpriv.ps_flag = _TRUE; } padapter->net_closed = _TRUE; /* if(!padapter->hw_init_completed) { DBG_8192C("(1)871x_drv - drv_close, bup=%d, hw_init_completed=%d\n", padapter->bup, padapter->hw_init_completed); padapter->bDriverStopped = _TRUE; rtw_dev_unload(padapter); } else*/ if(padapter->pwrctrlpriv.rf_pwrstate == rf_on){ DBG_8192C("(2)871x_drv - drv_close, bup=%d, hw_init_completed=%d\n", padapter->bup, padapter->hw_init_completed); //s1. if(pnetdev) { if (!netif_queue_stopped(pnetdev)) netif_stop_queue(pnetdev); } #ifndef CONFIG_ANDROID //s2. //s2-1. issue rtw_disassoc_cmd to fw rtw_disassoc_cmd(padapter); //s2-2. indicate disconnect to os rtw_indicate_disconnect(padapter); //s2-3. rtw_free_assoc_resources(padapter, 1); //s2-4. rtw_free_network_queue(padapter,_TRUE); #endif // Close LED rtw_led_control(padapter, LED_CTL_POWER_OFF); } #ifdef CONFIG_BR_EXT //if (OPMODE & (WIFI_STATION_STATE | WIFI_ADHOC_STATE)) { //void nat25_db_cleanup(_adapter *priv); nat25_db_cleanup(padapter); } #endif // CONFIG_BR_EXT #ifdef CONFIG_P2P #ifdef CONFIG_IOCTL_CFG80211 if(wdev_to_priv(padapter->rtw_wdev)->p2p_enabled == _TRUE) wdev_to_priv(padapter->rtw_wdev)->p2p_enabled = _FALSE; #endif rtw_p2p_enable(padapter, P2P_ROLE_DISABLE); #endif //CONFIG_P2P #ifdef CONFIG_IOCTL_CFG80211 DBG_871X("call rtw_indicate_scan_done when drv_close\n"); rtw_indicate_scan_done(padapter, _TRUE); padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR; //set this at the end #endif RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - drv_close\n")); DBG_8192C("-871x_drv - drv_close, bup=%d\n", padapter->bup); return 0; }
ssize_t proc_set_btcoex_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data) { struct net_device *dev = data; PADAPTER padapter; u8 tmp[80] = {0}; u32 module[2] = {0}; u32 num; padapter = (PADAPTER)rtw_netdev_priv(dev); // DBG_871X("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter)); if (NULL == buffer) { DBG_871X(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter)); return -EFAULT; } if (count < 1) { DBG_871X(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter)); return -EFAULT; } num = count; if (num > (sizeof(tmp) - 1)) num = (sizeof(tmp) - 1); if (copy_from_user(tmp, buffer, num)) { DBG_871X(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n", FUNC_ADPT_ARG(padapter)); return -EFAULT; } num = sscanf(tmp, "%x %x", module, module+1); if (1 == num) { if (0 == module[0]) _rtw_memset(module, 0, sizeof(module)); else _rtw_memset(module, 0xFF, sizeof(module)); } else if (2 != num) { DBG_871X(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n", FUNC_ADPT_ARG(padapter), tmp); if (0 == num) return -EFAULT; } DBG_871X(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n", FUNC_ADPT_ARG(padapter), module[0], module[1]); rtw_btcoex_SetDBG(padapter, module); return count; }
void netdev_br_init(struct net_device *netdev) { struct adapter *adapter = (struct adapter *)rtw_netdev_priv(netdev); rcu_read_lock(); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36) if (rcu_dereference(adapter->pnetdev->rx_handler_data)) { #else if (rcu_dereference(adapter->pnetdev->br_port)) { #endif struct net_device *br_netdev; struct net *devnet = NULL; devnet = dev_net(netdev); br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME); if (br_netdev) { memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN); dev_put(br_netdev); } else { pr_info("%s()-%d: dev_get_by_name(%s) failed!", __func__, __LINE__, CONFIG_BR_EXT_BRNAME); } } adapter->ethBrExtInfo.addPPPoETag = 1; rcu_read_unlock(); } int _netdev_open(struct net_device *pnetdev) { uint status; struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - dev_open\n")); DBG_88E("+88eu_drv - drv_open, bup =%d\n", padapter->bup); if (pwrctrlpriv->ps_flag) { padapter->net_closed = false; goto netdev_open_normal_process; } if (!padapter->bup) { padapter->bDriverStopped = false; padapter->bSurpriseRemoved = false; padapter->bCardDisableWOHSM = false; status = rtw_hal_init(padapter); if (status == _FAIL) { RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl88eu_hal_init(): Can't init h/w!\n")); goto netdev_open_error; } pr_info("MAC Address = %pM\n", pnetdev->dev_addr); status = rtw_start_drv_threads(padapter); if (status == _FAIL) { pr_info("Initialize driver software resource Failed!\n"); goto netdev_open_error; } if (init_hw_mlme_ext(padapter) == _FAIL) { pr_info("can't init mlme_ext_priv\n"); goto netdev_open_error; } if (padapter->intf_start) padapter->intf_start(padapter); rtw_proc_init_one(pnetdev); rtw_led_control(padapter, LED_CTL_NO_LINK); padapter->bup = true; } padapter->net_closed = false; _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000); padapter->pwrctrlpriv.bips_processing = false; rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv); if (!rtw_netif_queue_stopped(pnetdev)) rtw_netif_start_queue(pnetdev); else rtw_netif_wake_queue(pnetdev); netdev_br_init(pnetdev); netdev_open_normal_process: RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - dev_open\n")); DBG_88E("-88eu_drv - drv_open, bup =%d\n", padapter->bup); return 0; netdev_open_error: padapter->bup = false; netif_carrier_off(pnetdev); rtw_netif_stop_queue(pnetdev); RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-88eu_drv - dev_open, fail!\n")); DBG_88E("-88eu_drv - drv_open fail, bup =%d\n", padapter->bup); return -1; }
int _netdev_open(struct net_device *pnetdev) { uint status; _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev); struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - dev_open\n")); DBG_8192C("+871x_drv - drv_open, bup=%d\n", padapter->bup); if(pwrctrlpriv->ps_flag == _TRUE){ padapter->net_closed = _FALSE; goto netdev_open_normal_process; } if(padapter->bup == _FALSE) { padapter->bDriverStopped = _FALSE; padapter->bSurpriseRemoved = _FALSE; padapter->bCardDisableWOHSM = _FALSE; status = rtw_hal_init(padapter); if (status ==_FAIL) { RT_TRACE(_module_os_intfs_c_,_drv_err_,("rtl871x_hal_init(): Can't init h/w!\n")); goto netdev_open_error; } DBG_8192C("MAC Address = "MAC_FMT"\n", MAC_ARG(pnetdev->dev_addr)); status=rtw_start_drv_threads(padapter); if(status ==_FAIL) { RT_TRACE(_module_os_intfs_c_,_drv_err_,("Initialize driver software resource Failed!\n")); goto netdev_open_error; } if (init_hw_mlme_ext(padapter) == _FAIL) { RT_TRACE(_module_os_intfs_c_,_drv_err_,("can't init mlme_ext_priv\n")); goto netdev_open_error; } #ifdef CONFIG_DRVEXT_MODULE init_drvext(padapter); #endif if(padapter->intf_start) { padapter->intf_start(padapter); } #ifdef CONFIG_PROC_DEBUG #ifndef RTK_DMP_PLATFORM rtw_proc_init_one(pnetdev); #endif #endif #ifdef CONFIG_IOCTL_CFG80211 rtw_cfg80211_init_wiphy(padapter); #endif rtw_led_control(padapter, LED_CTL_NO_LINK); padapter->bup = _TRUE; } padapter->net_closed = _FALSE; _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000); if(( pwrctrlpriv->power_mgnt != PS_MODE_ACTIVE ) ||(padapter->pwrctrlpriv.bHWPwrPindetect)) { padapter->pwrctrlpriv.bips_processing = _FALSE; rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv); } //netif_carrier_on(pnetdev);//call this func when rtw_joinbss_event_callback return success if(!netif_queue_stopped(pnetdev)) netif_start_queue(pnetdev); else netif_wake_queue(pnetdev); #ifdef CONFIG_BR_EXT #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) rcu_read_lock(); #endif // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) //if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE) { //struct net_bridge *br = pnetdev->br_port->br;//->dev->dev_addr; #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) if (pnetdev->br_port) #else // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) if (rcu_dereference(padapter->pnetdev->rx_handler_data)) #endif // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35)) { struct net_device *br_netdev; #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) br_netdev = dev_get_by_name(CONFIG_BR_EXT_BRNAME); #else // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) struct net *devnet = NULL; #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) devnet = pnetdev->nd_net; #else // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) devnet = dev_net(pnetdev); #endif // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME); #endif // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) if (br_netdev) { memcpy(padapter->br_mac, br_netdev->dev_addr, ETH_ALEN); dev_put(br_netdev); } else printk("%s()-%d: dev_get_by_name(%s) failed!", __FUNCTION__, __LINE__, CONFIG_BR_EXT_BRNAME); } padapter->ethBrExtInfo.addPPPoETag = 1; } #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) rcu_read_unlock(); #endif // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35)) #endif // CONFIG_BR_EXT netdev_open_normal_process: RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - dev_open\n")); DBG_8192C("-871x_drv - drv_open, bup=%d\n", padapter->bup); return 0; netdev_open_error: padapter->bup = _FALSE; netif_carrier_off(pnetdev); netif_stop_queue(pnetdev); RT_TRACE(_module_os_intfs_c_,_drv_err_,("-871x_drv - dev_open, fail!\n")); DBG_8192C("-871x_drv - drv_open fail, bup=%d\n", padapter->bup); return (-1); }
int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) { int ret = 0; char *command = NULL; int cmd_num; int bytes_written = 0; android_wifi_priv_cmd priv_cmd; rtw_lock_suspend(); if (!ifr->ifr_data) { ret = -EINVAL; goto exit; } if (copy_from_user(&priv_cmd, ifr->ifr_data, sizeof(android_wifi_priv_cmd))) { ret = -EFAULT; goto exit; } command = kmalloc(priv_cmd.total_len, GFP_KERNEL); if (!command) { DBG_871X("%s: failed to allocate memory\n", __FUNCTION__); ret = -ENOMEM; goto exit; } if (copy_from_user(command, priv_cmd.buf, priv_cmd.total_len)) { ret = -EFAULT; goto exit; } DBG_871X("%s: Android private cmd \"%s\" on %s\n" , __FUNCTION__, command, ifr->ifr_name); cmd_num = rtw_android_cmdstr_to_num(command); switch(cmd_num) { case ANDROID_WIFI_CMD_START: //bytes_written = wl_android_wifi_on(net); goto response; case ANDROID_WIFI_CMD_SETFWPATH: goto response; } if (!g_wifi_on) { DBG_871X("%s: Ignore private cmd \"%s\" - iface %s is down\n" ,__FUNCTION__, command, ifr->ifr_name); ret = 0; goto exit; } switch(cmd_num) { case ANDROID_WIFI_CMD_STOP: //bytes_written = wl_android_wifi_off(net); break; case ANDROID_WIFI_CMD_SCAN_ACTIVE: rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_ACTIVE); break; case ANDROID_WIFI_CMD_SCAN_PASSIVE: rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_PASSIVE); break; case ANDROID_WIFI_CMD_RSSI: bytes_written = rtw_android_get_rssi(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_LINKSPEED: bytes_written = rtw_android_get_link_speed(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_MACADDR: bytes_written = rtw_android_get_macaddr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_BLOCK: bytes_written = rtw_android_set_block(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_RXFILTER_START: //bytes_written = net_os_set_packet_filter(net, 1); break; case ANDROID_WIFI_CMD_RXFILTER_STOP: //bytes_written = net_os_set_packet_filter(net, 0); break; case ANDROID_WIFI_CMD_RXFILTER_ADD: //int filter_num = *(command + strlen(CMD_RXFILTER_ADD) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, TRUE, filter_num); break; case ANDROID_WIFI_CMD_RXFILTER_REMOVE: //int filter_num = *(command + strlen(CMD_RXFILTER_REMOVE) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, FALSE, filter_num); break; case ANDROID_WIFI_CMD_BTCOEXSCAN_START: /* TBD: BTCOEXSCAN-START */ break; case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP: /* TBD: BTCOEXSCAN-STOP */ break; case ANDROID_WIFI_CMD_BTCOEXMODE: #if 0 uint mode = *(command + strlen(CMD_BTCOEXMODE) + 1) - '0'; if (mode == 1) net_os_set_packet_filter(net, 0); /* DHCP starts */ else net_os_set_packet_filter(net, 1); /* DHCP ends */ #ifdef WL_CFG80211 bytes_written = wl_cfg80211_set_btcoex_dhcp(net, command); #endif #endif break; case ANDROID_WIFI_CMD_SETSUSPENDOPT: //bytes_written = wl_android_set_suspendopt(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_SETBAND: //uint band = *(command + strlen(CMD_SETBAND) + 1) - '0'; //bytes_written = wldev_set_band(net, band); break; case ANDROID_WIFI_CMD_GETBAND: //bytes_written = wl_android_get_band(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_COUNTRY: bytes_written = rtw_android_set_country(net, command, priv_cmd.total_len); break; #ifdef PNO_SUPPORT case ANDROID_WIFI_CMD_PNOSSIDCLR_SET: //bytes_written = dhd_dev_pno_reset(net); break; case ANDROID_WIFI_CMD_PNOSETUP_SET: //bytes_written = wl_android_set_pno_setup(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_PNOENABLE_SET: //uint pfn_enabled = *(command + strlen(CMD_PNOENABLE_SET) + 1) - '0'; //bytes_written = dhd_dev_pno_enable(net, pfn_enabled); break; #endif case ANDROID_WIFI_CMD_P2P_DEV_ADDR: bytes_written = rtw_android_get_p2p_dev_addr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_NOA: //int skip = strlen(CMD_P2P_SET_NOA) + 1; //bytes_written = wl_cfg80211_set_p2p_noa(net, command + skip, priv_cmd.total_len - skip); break; case ANDROID_WIFI_CMD_P2P_GET_NOA: //bytes_written = wl_cfg80211_get_p2p_noa(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_PS: //int skip = strlen(CMD_P2P_SET_PS) + 1; //bytes_written = wl_cfg80211_set_p2p_ps(net, command + skip, priv_cmd.total_len - skip); break; #ifdef CONFIG_IOCTL_CFG80211 case ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE: { int skip = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE]) + 3; bytes_written = rtw_cfg80211_set_mgnt_wpsp2pie(net, command + skip, priv_cmd.total_len - skip, *(command + skip - 2) - '0'); break; } #endif //CONFIG_IOCTL_CFG80211 default: DBG_871X("Unknown PRIVATE command %s - ignored\n", command); snprintf(command, 3, "OK"); bytes_written = strlen("OK"); } response: if (bytes_written >= 0) { if ((bytes_written == 0) && (priv_cmd.total_len > 0)) command[0] = '\0'; if (bytes_written >= priv_cmd.total_len) { DBG_871X("%s: bytes_written = %d\n", __FUNCTION__, bytes_written); bytes_written = priv_cmd.total_len; } else { bytes_written++; } priv_cmd.used_len = bytes_written; if (copy_to_user(priv_cmd.buf, command, bytes_written)) { DBG_871X("%s: failed to copy data to user buffer\n", __FUNCTION__); ret = -EFAULT; } } else { ret = bytes_written; } exit: rtw_unlock_suspend(); if (command) { kfree(command); } return ret; }
void rtw_proc_init_one(struct net_device *dev) { struct proc_dir_entry *dir_dev = NULL; struct proc_dir_entry *entry=NULL; _adapter *padapter = rtw_netdev_priv(dev); if(rtw_proc == NULL) { if(padapter->chip_type == RTL8188C_8192C) { _rtw_memcpy(rtw_proc_name, RTL8192C_PROC_NAME, sizeof(RTL8192C_PROC_NAME)); } else if(padapter->chip_type == RTL8192D) { _rtw_memcpy(rtw_proc_name, RTL8192D_PROC_NAME, sizeof(RTL8192D_PROC_NAME)); } #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) rtw_proc=create_proc_entry(rtw_proc_name, S_IFDIR, proc_net); #else rtw_proc=create_proc_entry(rtw_proc_name, S_IFDIR, init_net.proc_net); #endif if (rtw_proc == NULL) { DBG_8192C(KERN_ERR "Unable to create rtw_proc directory\n"); return; } entry = create_proc_read_entry("ver_info", S_IFREG | S_IRUGO, rtw_proc, proc_get_drv_version, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } } if(padapter->dir_dev == NULL) { padapter->dir_dev = create_proc_entry(dev->name, S_IFDIR | S_IRUGO | S_IXUGO, rtw_proc); dir_dev = padapter->dir_dev; if(dir_dev==NULL) { if(rtw_proc_cnt == 0) { if(rtw_proc){ #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) remove_proc_entry(rtw_proc_name, proc_net); #else remove_proc_entry(rtw_proc_name, init_net.proc_net); #endif rtw_proc = NULL; } } DBG_8192C("Unable to create dir_dev directory\n"); return; } } else { return; } rtw_proc_cnt++; entry = create_proc_read_entry("write_reg", S_IFREG | S_IRUGO, dir_dev, proc_get_write_reg, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_write_reg; entry = create_proc_read_entry("read_reg", S_IFREG | S_IRUGO, dir_dev, proc_get_read_reg, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_read_reg; entry = create_proc_read_entry("fwstate", S_IFREG | S_IRUGO, dir_dev, proc_get_fwstate, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("sec_info", S_IFREG | S_IRUGO, dir_dev, proc_get_sec_info, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("mlmext_state", S_IFREG | S_IRUGO, dir_dev, proc_get_mlmext_state, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("qos_option", S_IFREG | S_IRUGO, dir_dev, proc_get_qos_option, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("ht_option", S_IFREG | S_IRUGO, dir_dev, proc_get_ht_option, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("rf_info", S_IFREG | S_IRUGO, dir_dev, proc_get_rf_info, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("ap_info", S_IFREG | S_IRUGO, dir_dev, proc_get_ap_info, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("adapter_state", S_IFREG | S_IRUGO, dir_dev, proc_get_adapter_state, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry = create_proc_read_entry("trx_info", S_IFREG | S_IRUGO, dir_dev, proc_get_trx_info, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } #ifdef CONFIG_AP_MODE entry = create_proc_read_entry("all_sta_info", S_IFREG | S_IRUGO, dir_dev, proc_get_all_sta_info, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } #endif #ifdef DBG_MEMORY_LEAK entry = create_proc_read_entry("_malloc_cnt", S_IFREG | S_IRUGO, dir_dev, proc_get_malloc_cnt, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } #endif #ifdef CONFIG_FIND_BEST_CHANNEL entry = create_proc_read_entry("best_channel", S_IFREG | S_IRUGO, dir_dev, proc_get_best_channel, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } #endif entry = create_proc_read_entry("rx_signal", S_IFREG | S_IRUGO, dir_dev, proc_get_rx_signal, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_rx_signal; entry = create_proc_read_entry("rssi_disp", S_IFREG | S_IRUGO, dir_dev, proc_get_rssi_disp, dev); if (!entry) { DBG_871X("Unable to create_proc_read_entry!\n"); return; } entry->write_proc = proc_set_rssi_disp; }
int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd) { int ret = 0; char *command = NULL; int cmd_num; int bytes_written = 0; android_wifi_priv_cmd priv_cmd; rtw_lock_suspend(); if (!ifr->ifr_data) { ret = -EINVAL; goto exit; } if (copy_from_user(&priv_cmd, ifr->ifr_data, sizeof(android_wifi_priv_cmd))) { ret = -EFAULT; goto exit; } //DBG_871X("%s priv_cmd.buf=%p priv_cmd.total_len=%d priv_cmd.used_len=%d\n",__func__,priv_cmd.buf,priv_cmd.total_len,priv_cmd.used_len); command = rtw_zmalloc(priv_cmd.total_len); if (!command) { DBG_871X("%s: failed to allocate memory\n", __FUNCTION__); ret = -ENOMEM; goto exit; } if (!access_ok(VERIFY_READ, priv_cmd.buf, priv_cmd.total_len)){ DBG_871X("%s: failed to access memory\n", __FUNCTION__); ret = -EFAULT; goto exit; } if (copy_from_user(command, (void *)priv_cmd.buf, priv_cmd.total_len)) { ret = -EFAULT; goto exit; } DBG_871X("%s: Android private cmd \"%s\" on %s\n" , __FUNCTION__, command, ifr->ifr_name); cmd_num = rtw_android_cmdstr_to_num(command); switch(cmd_num) { case ANDROID_WIFI_CMD_START: //bytes_written = wl_android_wifi_on(net); goto response; case ANDROID_WIFI_CMD_SETFWPATH: goto response; } if (!g_wifi_on) { DBG_871X("%s: Ignore private cmd \"%s\" - iface %s is down\n" ,__FUNCTION__, command, ifr->ifr_name); ret = 0; goto exit; } switch(cmd_num) { case ANDROID_WIFI_CMD_STOP: //bytes_written = wl_android_wifi_off(net); break; case ANDROID_WIFI_CMD_SCAN_ACTIVE: //rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_ACTIVE); #ifdef CONFIG_PLATFORM_MSTAR #ifdef CONFIG_IOCTL_CFG80211 (wdev_to_priv(net->ieee80211_ptr))->bandroid_scan = _TRUE; #endif //CONFIG_IOCTL_CFG80211 #endif //CONFIG_PLATFORM_MSTAR break; case ANDROID_WIFI_CMD_SCAN_PASSIVE: //rtw_set_scan_mode((_adapter *)rtw_netdev_priv(net), SCAN_PASSIVE); break; case ANDROID_WIFI_CMD_RSSI: bytes_written = rtw_android_get_rssi(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_LINKSPEED: bytes_written = rtw_android_get_link_speed(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_MACADDR: bytes_written = rtw_android_get_macaddr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_BLOCK: bytes_written = rtw_android_set_block(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_RXFILTER_START: //bytes_written = net_os_set_packet_filter(net, 1); break; case ANDROID_WIFI_CMD_RXFILTER_STOP: //bytes_written = net_os_set_packet_filter(net, 0); break; case ANDROID_WIFI_CMD_RXFILTER_ADD: //int filter_num = *(command + strlen(CMD_RXFILTER_ADD) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, TRUE, filter_num); break; case ANDROID_WIFI_CMD_RXFILTER_REMOVE: //int filter_num = *(command + strlen(CMD_RXFILTER_REMOVE) + 1) - '0'; //bytes_written = net_os_rxfilter_add_remove(net, FALSE, filter_num); break; case ANDROID_WIFI_CMD_BTCOEXSCAN_START: /* TBD: BTCOEXSCAN-START */ break; case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP: /* TBD: BTCOEXSCAN-STOP */ break; case ANDROID_WIFI_CMD_BTCOEXMODE: #if 0 uint mode = *(command + strlen(CMD_BTCOEXMODE) + 1) - '0'; if (mode == 1) net_os_set_packet_filter(net, 0); /* DHCP starts */ else net_os_set_packet_filter(net, 1); /* DHCP ends */ #ifdef WL_CFG80211 bytes_written = wl_cfg80211_set_btcoex_dhcp(net, command); #endif #endif break; case ANDROID_WIFI_CMD_SETSUSPENDOPT: //bytes_written = wl_android_set_suspendopt(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_SETBAND: { uint band = *(command + strlen("SETBAND") + 1) - '0'; _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); if (padapter->chip_type == RTL8192D) padapter->setband = band; break; } case ANDROID_WIFI_CMD_GETBAND: //bytes_written = wl_android_get_band(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_COUNTRY: bytes_written = rtw_android_set_country(net, command, priv_cmd.total_len); break; #ifdef PNO_SUPPORT case ANDROID_WIFI_CMD_PNOSSIDCLR_SET: //bytes_written = dhd_dev_pno_reset(net); break; case ANDROID_WIFI_CMD_PNOSETUP_SET: //bytes_written = wl_android_set_pno_setup(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_PNOENABLE_SET: //uint pfn_enabled = *(command + strlen(CMD_PNOENABLE_SET) + 1) - '0'; //bytes_written = dhd_dev_pno_enable(net, pfn_enabled); break; #endif case ANDROID_WIFI_CMD_P2P_DEV_ADDR: bytes_written = rtw_android_get_p2p_dev_addr(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_NOA: //int skip = strlen(CMD_P2P_SET_NOA) + 1; //bytes_written = wl_cfg80211_set_p2p_noa(net, command + skip, priv_cmd.total_len - skip); break; case ANDROID_WIFI_CMD_P2P_GET_NOA: //bytes_written = wl_cfg80211_get_p2p_noa(net, command, priv_cmd.total_len); break; case ANDROID_WIFI_CMD_P2P_SET_PS: //int skip = strlen(CMD_P2P_SET_PS) + 1; //bytes_written = wl_cfg80211_set_p2p_ps(net, command + skip, priv_cmd.total_len - skip); break; #ifdef CONFIG_IOCTL_CFG80211 case ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE: { int skip = strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_SET_AP_WPS_P2P_IE]) + 3; bytes_written = rtw_cfg80211_set_mgnt_wpsp2pie(net, command + skip, priv_cmd.total_len - skip, *(command + skip - 2) - '0'); break; } #endif //CONFIG_IOCTL_CFG80211 #ifdef CONFIG_WFD case ANDROID_WIFI_CMD_WFD_ENABLE: { // Commented by Albert 2012/07/24 // We can enable the WFD function by using the following command: // wpa_cli driver wfd-enable struct wifi_display_info *pwfd_info; _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->wfd_enable = _TRUE; break; } case ANDROID_WIFI_CMD_WFD_DISABLE: { // Commented by Albert 2012/07/24 // We can disable the WFD function by using the following command: // wpa_cli driver wfd-disable struct wifi_display_info *pwfd_info; _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->wfd_enable = _FALSE; break; } case ANDROID_WIFI_CMD_WFD_SET_TCPPORT: { // Commented by Albert 2012/07/24 // We can set the tcp port number by using the following command: // wpa_cli driver wfd-set-tcpport = 554 struct wifi_display_info *pwfd_info; _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) pwfd_info->rtsp_ctrlport = ( u16 ) get_int_from_command( priv_cmd.buf ); break; } case ANDROID_WIFI_CMD_WFD_SET_MAX_TPUT: { break; } case ANDROID_WIFI_CMD_WFD_SET_DEVTYPE: { // Commented by Albert 2012/08/28 // Specify the WFD device type ( WFD source/primary sink ) struct wifi_display_info *pwfd_info; _adapter* padapter = ( _adapter * ) rtw_netdev_priv(net); pwfd_info = &padapter->wfd_info; if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 ) { pwfd_info->wfd_device_type = ( u8 ) get_int_from_command( priv_cmd.buf ); pwfd_info->wfd_device_type &= WFD_DEVINFO_DUAL; } break; } #endif default: DBG_871X("Unknown PRIVATE command %s - ignored\n", command); snprintf(command, 3, "OK"); bytes_written = strlen("OK"); } response: if (bytes_written >= 0) { if ((bytes_written == 0) && (priv_cmd.total_len > 0)) command[0] = '\0'; if (bytes_written >= priv_cmd.total_len) { DBG_871X("%s: bytes_written = %d\n", __FUNCTION__, bytes_written); bytes_written = priv_cmd.total_len; } else { bytes_written++; } priv_cmd.used_len = bytes_written; if (copy_to_user((void *)priv_cmd.buf, command, bytes_written)) { DBG_871X("%s: failed to copy data to user buffer\n", __FUNCTION__); ret = -EFAULT; } } else { ret = bytes_written; } exit: rtw_unlock_suspend(); if (command) { rtw_mfree(command, priv_cmd.total_len); } return ret; }
int _rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev) { _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; #ifdef CONFIG_TX_MCAST2UNI struct mlme_priv *pmlmepriv = &padapter->mlmepriv; extern int rtw_mc2u_disable; #endif // CONFIG_TX_MCAST2UNI s32 res = 0; #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35)) u16 queue; #endif _func_enter_; if(padapter->registrypriv.mp_mode) { DBG_871X("MP_TX_DROP_OS_FRAME\n"); goto drop_packet; } DBG_COUNTER(padapter->tx_logs.os_tx); RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("+xmit_enry\n")); if (rtw_if_up(padapter) == _FALSE) { DBG_COUNTER(padapter->tx_logs.os_tx_err_up); RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("rtw_xmit_entry: rtw_if_up fail\n")); #ifdef DBG_TX_DROP_FRAME DBG_871X("DBG_TX_DROP_FRAME %s if_up fail\n", __FUNCTION__); #endif goto drop_packet; } rtw_check_xmit_resource(padapter, pkt); #ifdef CONFIG_TX_MCAST2UNI if ( !rtw_mc2u_disable && check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && ( IP_MCAST_MAC(pkt->data) || ICMPV6_MCAST_MAC(pkt->data) #ifdef CONFIG_TX_BCAST2UNI || is_broadcast_mac_addr(pkt->data) #endif ) && (padapter->registrypriv.wifi_spec == 0) ) { if ( pxmitpriv->free_xmitframe_cnt > (NR_XMITFRAME/4) ) { res = rtw_mlcst2unicst(padapter, pkt); if (res == _TRUE) { goto exit; } } else { //DBG_871X("Stop M2U(%d, %d)! ", pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmitbuf_cnt); //DBG_871X("!m2u ); DBG_COUNTER(padapter->tx_logs.os_tx_m2u_stop); } } #endif // CONFIG_TX_MCAST2UNI res = rtw_xmit(padapter, &pkt); if (res < 0) { #ifdef DBG_TX_DROP_FRAME DBG_871X("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__); #endif goto drop_packet; } RT_TRACE(_module_xmit_osdep_c_, _drv_info_, ("rtw_xmit_entry: tx_pkts=%d\n", (u32)pxmitpriv->tx_pkts)); goto exit; drop_packet: pxmitpriv->tx_drop++; rtw_os_pkt_complete(padapter, pkt); RT_TRACE(_module_xmit_osdep_c_, _drv_notice_, ("rtw_xmit_entry: drop, tx_drop=%d\n", (u32)pxmitpriv->tx_drop)); exit: _func_exit_; return 0; }
static struct adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj, struct usb_interface *pusb_intf, const struct usb_device_id *pdid) { struct adapter *padapter = NULL; struct net_device *pnetdev = NULL; int status = _FAIL; padapter = (struct adapter *)vzalloc(sizeof(*padapter)); if (padapter == NULL) goto exit; padapter->dvobj = dvobj; dvobj->if1 = padapter; padapter->bDriverStopped = true; mutex_init(&padapter->hw_init_mutex); padapter->chip_type = RTL8188E; pnetdev = rtw_init_netdev(padapter); if (pnetdev == NULL) goto free_adapter; SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj)); padapter = rtw_netdev_priv(pnetdev); /* step 2. hook HalFunc, allocate HalData */ hal_set_hal_ops(padapter); padapter->intf_start = &usb_intf_start; padapter->intf_stop = &usb_intf_stop; /* step read_chip_version */ rtw_hal_read_chip_version(padapter); /* step usb endpoint mapping */ rtw_hal_chip_configure(padapter); /* step read efuse/eeprom data and get mac_addr */ rtw_hal_read_chip_info(padapter); /* step 5. */ if (rtw_init_drv_sw(padapter) == _FAIL) { RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("Initialize driver software resource Failed!\n")); goto free_hal_data; } #ifdef CONFIG_PM if (padapter->pwrctrlpriv.bSupportRemoteWakeup) { dvobj->pusbdev->do_remote_wakeup = 1; pusb_intf->needs_remote_wakeup = 1; device_init_wakeup(&pusb_intf->dev, 1); DBG_88E("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~~~~\n"); DBG_88E("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~[%d]~~~\n", device_may_wakeup(&pusb_intf->dev)); } #endif /* 2012-07-11 Move here to prevent the 8723AS-VAU BT auto * suspend influence */ if (usb_autopm_get_interface(pusb_intf) < 0) DBG_88E("can't get autopm:\n"); /* alloc dev name after read efuse. */ rtw_init_netdev_name(pnetdev, padapter->registrypriv.ifname); rtw_macaddr_cfg(padapter->eeprompriv.mac_addr); memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN); DBG_88E("MAC Address from pnetdev->dev_addr = %pM\n", pnetdev->dev_addr); /* step 6. Tell the network stack we exist */ if (register_netdev(pnetdev) != 0) { RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("register_netdev() failed\n")); goto free_hal_data; } DBG_88E("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n" , padapter->bDriverStopped , padapter->bSurpriseRemoved , padapter->bup , padapter->hw_init_completed ); status = _SUCCESS; free_hal_data: if (status != _SUCCESS) kfree(padapter->HalData); free_adapter: if (status != _SUCCESS) { if (pnetdev) rtw_free_netdev(pnetdev); else if (padapter) vfree(padapter); padapter = NULL; } exit: return padapter; }