bool rtl8192_rfkill_init(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); struct wireless_dev *wdev = &priv->rtllib->wdev; bool radio_enabled; bool valid = rtl8192_is_radio_enabled(dev, &radio_enabled); if (valid) { priv->rfkill_off = radio_enabled; printk(KERN_INFO "rtl8192: wireless switch is %s\n", priv->rfkill_off ? "on" : "off"); wiphy_rfkill_set_hw_state(wdev->wiphy, !priv->rfkill_off); wiphy_rfkill_start_polling(wdev->wiphy); return true; } else { return false; } }
static int r8192_wx_set_debugflag(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct r8192_priv *priv = rtllib_priv(dev); u8 c = *extra; if (priv->bHwRadioOff == true) return 0; printk(KERN_INFO "=====>%s(), *extra:%x, debugflag:%x\n", __func__, *extra, rt_global_debug_component); if (c > 0) rt_global_debug_component |= (1<<c); else rt_global_debug_component &= BIT31; return 0; }
static int r8192_wx_set_rts(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { int ret; struct r8192_priv *priv = rtllib_priv(dev); if (priv->bHwRadioOff == true) return 0; down(&priv->wx_sem); ret = rtllib_wx_set_rts(priv->rtllib, info, wrqu, extra); up(&priv->wx_sem); return ret; }
static int r8192_wx_get_PromiscuousMode(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; down(&priv->wx_sem); snprintf(extra, 45, "PromiscuousMode:%d, FilterSrcSTAFrame:%d", ieee->IntelPromiscuousModeInfo.bPromiscuousOn, ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame); wrqu->data.length = strlen(extra) + 1; up(&priv->wx_sem); return 0; }
static bool firmware_check_ready(struct net_device *dev, u8 load_fw_status) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_firmware *pfirmware = priv->pFirmware; bool rt_status = true; switch (load_fw_status) { case FW_INIT_STEP0_BOOT: pfirmware->firmware_status = FW_STATUS_1_MOVE_BOOT_CODE; break; case FW_INIT_STEP1_MAIN: pfirmware->firmware_status = FW_STATUS_2_MOVE_MAIN_CODE; rt_status = CPUcheck_maincodeok_turnonCPU(dev); if (rt_status) pfirmware->firmware_status = FW_STATUS_3_TURNON_CPU; else RT_TRACE(COMP_FIRMWARE, "CPUcheck_maincodeok_turnon" "CPU fail!\n"); break; case FW_INIT_STEP2_DATA: pfirmware->firmware_status = FW_STATUS_4_MOVE_DATA_CODE; mdelay(1); rt_status = CPUcheck_firmware_ready(dev); if (rt_status) pfirmware->firmware_status = FW_STATUS_5_READY; else RT_TRACE(COMP_FIRMWARE, "CPUcheck_firmware_ready fail" "(%d)!\n", rt_status); break; default: rt_status = false; RT_TRACE(COMP_FIRMWARE, "Unknown firmware status"); break; } return rt_status; }
static int r8192_wx_set_retry(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct r8192_priv *priv = rtllib_priv(dev); int err = 0; if (priv->bHwRadioOff == true) return 0; down(&priv->wx_sem); if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled) { err = -EINVAL; goto exit; } if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) { err = -EINVAL; goto exit; } if (wrqu->retry.value > R8192_MAX_RETRY) { err = -EINVAL; goto exit; } if (wrqu->retry.flags & IW_RETRY_MAX) { priv->retry_rts = wrqu->retry.value; DMESG("Setting retry for RTS/CTS data to %d", wrqu->retry.value); } else { priv->retry_data = wrqu->retry.value; DMESG("Setting retry for non RTS/CTS data to %d", wrqu->retry.value); } rtl8192_commit(dev); exit: up(&priv->wx_sem); return err; }
int rtl8192E_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); int err; u32 val; netdev_info(dev, "================>r8192E resume call.\n"); pci_set_power_state(pdev, PCI_D0); err = pci_enable_device(pdev); if (err) { netdev_err(dev, "pci_enable_device failed on resume\n"); return err; } pci_restore_state(pdev); pci_read_config_dword(pdev, 0x40, &val); if ((val & 0x0000ff00) != 0) pci_write_config_dword(pdev, 0x40, val & 0xffff00ff); pci_enable_wake(pdev, PCI_D0, 0); if (priv->polling_timer_on == 0) check_rfctrl_gpio_timer((unsigned long)dev); if (!netif_running(dev)) { netdev_info(dev, "RTL819XE:UI is open out of resume function\n"); goto out; } netif_device_attach(dev); if (dev->netdev_ops->ndo_open) dev->netdev_ops->ndo_open(dev); if (!priv->rtllib->bSupportRemoteWakeUp) MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_INIT, true); out: RT_TRACE(COMP_POWER, "<================r8192E resume call.\n"); return 0; }
static bool _rtl92e_fw_check_ready(struct net_device *dev, u8 load_fw_status) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_firmware *pfirmware = priv->pFirmware; bool rt_status = true; switch (load_fw_status) { case FW_INIT_STEP0_BOOT: pfirmware->status = FW_STATUS_1_MOVE_BOOT_CODE; break; case FW_INIT_STEP1_MAIN: pfirmware->status = FW_STATUS_2_MOVE_MAIN_CODE; rt_status = _rtl92e_fw_boot_cpu(dev); if (rt_status) pfirmware->status = FW_STATUS_3_TURNON_CPU; else netdev_dbg(dev, "_rtl92e_fw_boot_cpu fail!\n"); break; case FW_INIT_STEP2_DATA: pfirmware->status = FW_STATUS_4_MOVE_DATA_CODE; mdelay(1); rt_status = _rtl92e_wait_for_fw(dev, CPU_GEN_FIRM_RDY, 20); if (rt_status) pfirmware->status = FW_STATUS_5_READY; else RT_TRACE(COMP_FIRMWARE, "_rtl92e_is_fw_ready fail(%d)!\n", rt_status); break; default: rt_status = false; netdev_dbg(dev, "Unknown firmware status"); break; } return rt_status; }
RT_STATUS PHY_RF6052_Config(struct net_device* dev) { struct r8192_priv *priv = rtllib_priv(dev); RT_STATUS rtStatus = RT_STATUS_SUCCESS; //RF90_RADIO_PATH_E eRFPath; //BB_REGISTER_DEFINITION_T *pPhyReg; //u32 OrgStoreRFIntSW[RF90_PATH_D+1]; // // Initialize general global value // // TODO: Extend RF_PATH_C and RF_PATH_D in the future if(priv->rf_type == RF_1T1R) priv->NumTotalRFPath = 1; else priv->NumTotalRFPath = 2; // // Config BB and RF // // switch( priv->bRegHwParaFile ) // { // case 0: // phy_RF6052_Config_HardCode(dev); // break; // case 1: rtStatus = phy_RF6052_Config_ParaFile(dev); // break; // case 2: // Partial Modify. // phy_RF6052_Config_HardCode(dev); // phy_RF6052_Config_ParaFile(dev); // break; // default: // phy_RF6052_Config_HardCode(dev); // break; // } return rtStatus; }
static void cmpk_handle_tx_rate_history(struct net_device *dev, u8 *pmsg) { struct cmpk_tx_rahis *ptxrate; u8 i, j; u16 length = sizeof(struct cmpk_tx_rahis); u32 *ptemp; struct r8192_priv *priv = rtllib_priv(dev); #ifdef ENABLE_PS pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState)); if (rtState == eRfOff) return; #endif ptemp = (u32 *)pmsg; for (i = 0; i < (length / 4); i++) { u16 temp1, temp2; temp1 = ptemp[i] & 0x0000FFFF; temp2 = ptemp[i] >> 16; ptemp[i] = (temp1 << 16) | temp2; } ptxrate = (struct cmpk_tx_rahis *)pmsg; if (ptxrate == NULL) return; for (i = 0; i < 16; i++) { if (i < 4) priv->stats.txrate.cck[i] += ptxrate->cck[i]; if (i < 8) priv->stats.txrate.ofdm[i] += ptxrate->ofdm[i]; for (j = 0; j < 4; j++) priv->stats.txrate.ht_mcs[j][i] += ptxrate->ht_mcs[j][i]; } }
static void _rtl92e_parse_pci_configuration(struct pci_dev *pdev, struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); u8 tmp; u16 LinkCtrlReg; pcie_capability_read_word(priv->pdev, PCI_EXP_LNKCTL, &LinkCtrlReg); RT_TRACE(COMP_INIT, "Link Control Register =%x\n", LinkCtrlReg); pci_read_config_byte(pdev, 0x98, &tmp); tmp |= BIT4; pci_write_config_byte(pdev, 0x98, tmp); tmp = 0x17; pci_write_config_byte(pdev, 0x70f, tmp); }
u32 rtl92e_eeprom_read(struct net_device *dev, u32 addr) { struct r8192_priv *priv = rtllib_priv(dev); u32 ret = 0; rtl92e_writeb(dev, EPROM_CMD, (EPROM_CMD_PROGRAM << EPROM_CMD_OPERATING_MODE_SHIFT)); udelay(EPROM_DELAY); /* EEPROM is configured as x16 */ if (priv->epromtype == EEPROM_93C56) ret = _rtl92e_eeprom_xfer(dev, (addr & 0xFF) | (0x6 << 8), 11); else ret = _rtl92e_eeprom_xfer(dev, (addr & 0x3F) | (0x6 << 6), 9); rtl92e_writeb(dev, EPROM_CMD, (EPROM_CMD_NORMAL<<EPROM_CMD_OPERATING_MODE_SHIFT)); return ret; }
static bool rtl8192_is_radio_enabled(struct net_device *dev, bool *radio_enabled) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); bool rf_state = false; bool turnonbypowerdomain = false; bool valid; rtl8192_before_radio_check(dev, &rf_state, &turnonbypowerdomain); *radio_enabled = rtl8192_radio_on_off_checking(dev); rtl8192_after_radio_check(dev, rf_state, turnonbypowerdomain); if (priv->bResetInProgress) { priv->RFChangeInProgress = false; valid = false; } else { valid = true; } return valid; }
void IPSLeave(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl)); RT_RF_POWER_STATE rtState; if (pPSC->bInactivePs) { rtState = priv->rtllib->eRFPowerState; if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) { RT_TRACE(COMP_PS, "IPSLeave(): Turn on RF.\n"); pPSC->eInactivePowerState = eRfOn; priv->bInPowerSaveMode = false; InactivePsWorkItemCallback(dev); } } }
void rtl92e_rtllib_ips_leave_wq(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); enum rt_rf_power_state rtState; rtState = priv->rtllib->eRFPowerState; if (priv->rtllib->PowerSaveControl.bInactivePs) { if (rtState == eRfOff) { if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) { netdev_warn(dev, "%s(): RF is OFF.\n", __func__); return; } netdev_info(dev, "=========>%s(): rtl92e_ips_leave\n", __func__); schedule_work(&priv->rtllib->ips_leave_wq); } } }
static int r8192_wx_set_essid(struct net_device *dev, struct iw_request_info *a, union iwreq_data *wrqu, char *b) { struct r8192_priv *priv = rtllib_priv(dev); int ret; if (priv->bHwRadioOff) { netdev_info(dev, "=========>%s():hw radio off,or Rf state is eRfOff, return\n", __func__); return 0; } down(&priv->wx_sem); ret = rtllib_wx_set_essid(priv->rtllib, a, wrqu, b); up(&priv->wx_sem); return ret; }
int rtl8192se_send_scan_cmd(struct net_device *dev, bool start) { struct r8192_priv *priv = rtllib_priv(dev); if(start){ priv->rtllib->scan_watch_dog =0; #if 0 queue_delayed_work_rsl(priv->priv_wq,&priv->hw_scan_simu_wq,0); #else rtl8192se_set_scan_cmd(dev, start); #endif } else { #if 0 rtl8192se_rx_surveydone_cmd(dev); #else rtl8192se_set_scan_cmd(dev, start); #endif } return true; }
static int r8192se_wx_set_radio(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct r8192_priv *priv = rtllib_priv(dev); down(&priv->wx_sem); printk(KERN_INFO "%s(): set radio ! extra is %d\n", __func__, *extra); if ((*extra != 0) && (*extra != 1)) { RT_TRACE(COMP_ERR, "%s(): set radio an err value,must 0(radio " "off) or 1(radio on)\n", __func__); up(&priv->wx_sem); return -1; } priv->sw_radio_on = *extra; up(&priv->wx_sem); return 0; }
static int r8192_wx_get_gen_ie(struct net_device *dev, struct iw_request_info *info, union iwreq_data *data, char *extra) { int ret = 0; struct r8192_priv *priv = rtllib_priv(dev); struct rtllib_device *ieee = priv->rtllib; if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) { data->data.length = 0; return 0; } if (data->data.length < ieee->wpa_ie_len) return -E2BIG; data->data.length = ieee->wpa_ie_len; memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len); return ret; }
static int r8192_wx_set_power(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { int ret; struct r8192_priv *priv = rtllib_priv(dev); if (priv->bHwRadioOff == true) { RT_TRACE(COMP_ERR, "%s():Hw is Radio Off, we can't set " "Power,return\n", __func__); return 0; } down(&priv->wx_sem); ret = rtllib_wx_set_power(priv->rtllib, info, wrqu, extra); up(&priv->wx_sem); return ret; }
void rtllib_ips_leave_wq(struct net_device *dev) { struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev); RT_RF_POWER_STATE rtState; rtState = priv->rtllib->eRFPowerState; if(priv->rtllib->PowerSaveControl.bInactivePs){ if(rtState == eRfOff){ if(priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) { RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__); return; } else{ printk("=========>%s(): IPSLeave\n",__FUNCTION__); queue_work_rsl(priv->rtllib->wq,&priv->rtllib->ips_leave_wq); } } } }
static int r8192_wx_set_power(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { int ret; struct r8192_priv *priv = rtllib_priv(dev); if (priv->bHwRadioOff) { netdev_warn(dev, "%s(): Can't set Power: Radio is Off.\n", __func__); return 0; } down(&priv->wx_sem); ret = rtllib_wx_set_power(priv->rtllib, info, wrqu, extra); up(&priv->wx_sem); return ret; }
void rtl92e_ips_enter(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *) &(priv->rtllib->PowerSaveControl); enum rt_rf_power_state rtState; if (pPSC->bInactivePs) { rtState = priv->rtllib->eRFPowerState; if (rtState == eRfOn && !pPSC->bSwRfProcessing && (priv->rtllib->state != RTLLIB_LINKED) && (priv->rtllib->iw_mode != IW_MODE_MASTER)) { RT_TRACE(COMP_PS, "rtl92e_ips_enter(): Turn off RF.\n"); pPSC->eInactivePowerState = eRfOff; priv->isRFOff = true; priv->bInPowerSaveMode = true; _rtl92e_ps_update_rf_state(dev); } } }
void rtl92e_scan_op_backup(struct net_device *dev, u8 Operation) { struct r8192_priv *priv = rtllib_priv(dev); if (priv->up) { switch (Operation) { case SCAN_OPT_BACKUP: priv->rtllib->InitialGainHandler(dev, IG_Backup); break; case SCAN_OPT_RESTORE: priv->rtllib->InitialGainHandler(dev, IG_Restore); break; default: RT_TRACE(COMP_SCAN, "Unknown Scan Backup Operation.\n"); break; } } }
static int r8192_wx_set_frag(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct r8192_priv *priv = rtllib_priv(dev); if (priv->bHwRadioOff == true) return 0; if (wrqu->frag.disabled) priv->rtllib->fts = DEFAULT_FRAG_THRESHOLD; else { if (wrqu->frag.value < MIN_FRAG_THRESHOLD || wrqu->frag.value > MAX_FRAG_THRESHOLD) return -EINVAL; priv->rtllib->fts = wrqu->frag.value & ~0x1; } return 0; }
static void cmpk_count_tx_status(struct net_device *dev, struct cmpk_tx_status *pstx_status) { struct r8192_priv *priv = rtllib_priv(dev); #ifdef ENABLE_PS enum rt_rf_power_state rtstate; pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState)); if (rtState == eRfOff) return; #endif priv->stats.txfeedbackok += pstx_status->txok; priv->stats.txoktotal += pstx_status->txok; priv->stats.txfeedbackfail += pstx_status->txfail; priv->stats.txerrtotal += pstx_status->txfail; priv->stats.txretrycount += pstx_status->txretry; priv->stats.txfeedbackretry += pstx_status->txretry; priv->stats.txmulticast += pstx_status->txmcok; priv->stats.txbroadcast += pstx_status->txbcok; priv->stats.txunicast += pstx_status->txucok; priv->stats.txerrmulticast += pstx_status->txmcfail; priv->stats.txerrbroadcast += pstx_status->txbcfail; priv->stats.txerrunicast += pstx_status->txucfail; priv->stats.txbytesmulticast += pstx_status->txmclength; priv->stats.txbytesbroadcast += pstx_status->txbclength; priv->stats.txbytesunicast += pstx_status->txuclength; priv->stats.last_packet_rate = pstx_status->rate; } /* cmpk_CountTxStatus */
static void _rtl92e_phy_config_bb(struct net_device *dev, u8 ConfigType) { int i; u32 *Rtl819XPHY_REGArray_Table = NULL; u32 *Rtl819XAGCTAB_Array_Table = NULL; u16 AGCTAB_ArrayLen, PHY_REGArrayLen = 0; struct r8192_priv *priv = rtllib_priv(dev); AGCTAB_ArrayLen = AGCTAB_ArrayLength; Rtl819XAGCTAB_Array_Table = Rtl819XAGCTAB_Array; if (priv->rf_type == RF_2T4R) { PHY_REGArrayLen = PHY_REGArrayLength; Rtl819XPHY_REGArray_Table = Rtl819XPHY_REGArray; } else if (priv->rf_type == RF_1T2R) { PHY_REGArrayLen = PHY_REG_1T2RArrayLength; Rtl819XPHY_REGArray_Table = Rtl819XPHY_REG_1T2RArray; } if (ConfigType == BaseBand_Config_PHY_REG) { for (i = 0; i < PHY_REGArrayLen; i += 2) { rtl92e_set_bb_reg(dev, Rtl819XPHY_REGArray_Table[i], bMaskDWord, Rtl819XPHY_REGArray_Table[i+1]); RT_TRACE(COMP_DBG, "i: %x, The Rtl819xUsbPHY_REGArray[0] is %x Rtl819xUsbPHY_REGArray[1] is %x\n", i, Rtl819XPHY_REGArray_Table[i], Rtl819XPHY_REGArray_Table[i+1]); } } else if (ConfigType == BaseBand_Config_AGC_TAB) { for (i = 0; i < AGCTAB_ArrayLen; i += 2) { rtl92e_set_bb_reg(dev, Rtl819XAGCTAB_Array_Table[i], bMaskDWord, Rtl819XAGCTAB_Array_Table[i+1]); RT_TRACE(COMP_DBG, "i:%x, The rtl819XAGCTAB_Array[0] is %x rtl819XAGCTAB_Array[1] is %x\n", i, Rtl819XAGCTAB_Array_Table[i], Rtl819XAGCTAB_Array_Table[i+1]); } } }
void SwLedControlMode7(struct net_device *dev, LED_CTL_MODE LedAction) { struct r8192_priv *priv = rtllib_priv(dev); PLED_8190 pLed0 = &(priv->SwLed0); switch(LedAction) { case LED_CTL_POWER_ON: case LED_CTL_LINK: case LED_CTL_NO_LINK: SwLedOn(dev, pLed0); break; case LED_CTL_POWER_OFF: SwLedOff(dev, pLed0); break; default: break; } }
static int r8192_wx_get_scan(struct net_device *dev, struct iw_request_info *a, union iwreq_data *wrqu, char *b) { int ret; struct r8192_priv *priv = rtllib_priv(dev); if (!priv->up) return -ENETDOWN; if (priv->bHwRadioOff == true) return 0; down(&priv->wx_sem); ret = rtllib_wx_get_scan(priv->rtllib, a, wrqu, b); up(&priv->wx_sem); return ret; }
static int r8192_wx_get_retry(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct r8192_priv *priv = rtllib_priv(dev); wrqu->retry.disabled = 0; /* can't be disabled */ if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) return -EINVAL; if (wrqu->retry.flags & IW_RETRY_MAX) { wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MAX; wrqu->retry.value = priv->retry_rts; } else { wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MIN; wrqu->retry.value = priv->retry_data; } return 0; }