int rtw_drv_proc_init(void)
{
int ret = _FAIL;
ssize_t i;
struct proc_dir_entry *entry = NULL;
if (rtw_proc != NULL) {
rtw_warn_on(1);
goto exit;
}
rtw_proc = rtw_proc_create_dir(RTW_PROC_NAME, get_proc_net, NULL);
if (rtw_proc == NULL) {
rtw_warn_on(1);
goto exit;
}
for (i=0;i<drv_proc_hdls_num;i++) {
entry = rtw_proc_create_entry(drv_proc_hdls[i].name, rtw_proc, &rtw_drv_proc_fops, (void *)i);
if (!entry) {
rtw_warn_on(1);
goto exit;
}
}
ret = _SUCCESS;
exit:
return ret;
}
void rtw_odm_init(_adapter *adapter)
{
PDM_ODM_T odm = adapter_to_odm(adapter);
odm->Adapter = adapter;
rtw_warn_on(!odm->Adapter);
switch (adapter->chip_type) {
case RTL8188C_8192C:
odm->SupportICType = ODM_RTL8192C;
break;
case RTL8192D:
odm->SupportICType = ODM_RTL8192D;
break;
default:
odm->SupportICType = 0;
};
rtw_warn_on(!odm->SupportICType);
switch (adapter->interface_type) {
case RTW_USB:
odm->SupportInterface = ODM_ITRF_USB;
break;
case RTW_PCIE:
odm->SupportInterface = ODM_ITRF_PCIE;
break;
default:
odm->SupportInterface = 0;
};
rtw_warn_on(!odm->SupportInterface);
ODM_InitDebugSetting(odm);
}
void rtw_adapter_proc_replace(struct net_device *dev)
{
struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
struct proc_dir_entry *dir_dev = NULL;
_adapter *adapter = rtw_netdev_priv(dev);
int i;
dir_dev = adapter->dir_dev;
if (dir_dev == NULL) {
rtw_warn_on(1);
return;
}
for (i=0;i<adapter_proc_hdls_num;i++)
remove_proc_entry(adapter_proc_hdls[i].name, dir_dev);
rtw_odm_proc_deinit(adapter);
remove_proc_entry(adapter->old_ifname, drv_proc);
adapter->dir_dev = NULL;
rtw_adapter_proc_init(dev);
}
bool rtw_chbw_to_freq_range(u8 ch, u8 bw, u8 offset, u32 *hi, u32 *lo)
{
u8 c_ch;
u32 freq;
u32 hi_ret = 0, lo_ret = 0;
int i;
bool valid = _FALSE;
if (hi)
*hi = 0;
if (lo)
*lo = 0;
c_ch = rtw_get_center_ch(ch, bw, offset);
freq = rtw_ch2freq(c_ch);
if (!freq) {
rtw_warn_on(1);
goto exit;
}
if (bw == CHANNEL_WIDTH_80) {
hi_ret = freq + 40;
lo_ret = freq - 40;
} else if (bw == CHANNEL_WIDTH_40) {
hi_ret = freq + 20;
lo_ret = freq - 20;
} else if (bw == CHANNEL_WIDTH_20) {
hi_ret = freq + 10;
lo_ret = freq - 10;
} else {
rtw_warn_on(1);
}
if (hi)
*hi = hi_ret;
if (lo)
*lo = lo_ret;
valid = _TRUE;
exit:
return valid;
}
inline void rtw_st_ctl_register(struct st_ctl_t *st_ctl, u8 st_reg_id, struct st_register *reg)
{
if (st_reg_id >= SESSION_TRACKER_REG_ID_NUM) {
rtw_warn_on(1);
return;
}
st_ctl->reg[st_reg_id].s_proto = reg->s_proto;
st_ctl->reg[st_reg_id].rule = reg->rule;
}
_adapter *rtw_get_iface_by_id(_adapter *padapter, u8 iface_id)
{
_adapter *iface = NULL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
if ((padapter == NULL) || (iface_id >= CONFIG_IFACE_NUMBER)) {
rtw_warn_on(1);
return iface;
}
return dvobj->padapters[iface_id];
}
struct proc_dir_entry *rtw_adapter_proc_init(struct net_device *dev)
{
struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
struct proc_dir_entry *dir_dev = NULL;
struct proc_dir_entry *entry = NULL;
_adapter *adapter = rtw_netdev_priv(dev);
u8 rf_type;
ssize_t i;
if (drv_proc == NULL) {
rtw_warn_on(1);
goto exit;
}
if (adapter->dir_dev != NULL) {
rtw_warn_on(1);
goto exit;
}
dir_dev = rtw_proc_create_dir(dev->name, drv_proc, dev);
if (dir_dev == NULL) {
rtw_warn_on(1);
goto exit;
}
adapter->dir_dev = dir_dev;
for (i=0;i<adapter_proc_hdls_num;i++) {
entry = rtw_proc_create_entry(adapter_proc_hdls[i].name, dir_dev, &rtw_adapter_proc_fops, (void *)i);
if (!entry) {
rtw_warn_on(1);
goto exit;
}
}
rtw_odm_proc_init(dev);
exit:
return dir_dev;
}
s32 rtw_hal_fill_h2c_cmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
{
s32 ret = _FAIL;
if (padapter->HalFunc.fill_h2c_cmd)
ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
else {
DBG_871X("%s: func[fill_h2c_cmd] not defined!\n", __FUNCTION__);
rtw_warn_on(1);
}
return ret;
}
struct proc_dir_entry *rtw_odm_proc_init(struct net_device *dev)
{
struct proc_dir_entry *dir_odm = 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_odm != NULL) {
rtw_warn_on(1);
goto exit;
}
dir_odm = rtw_proc_create_dir("odm", adapter->dir_dev, dev);
if (dir_odm == NULL) {
rtw_warn_on(1);
goto exit;
}
adapter->dir_odm = dir_odm;
for (i=0;i<odm_proc_hdls_num;i++) {
entry = rtw_proc_create_entry(odm_proc_hdls[i].name, dir_odm, &rtw_odm_proc_fops, (void *)i);
if (!entry) {
rtw_warn_on(1);
goto exit;
}
}
exit:
return dir_odm;
}
s32 rtw_hal_c2h_evt_read(_adapter *adapter, u8 *buf)
{
HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
HAL_VERSION *hal_ver = &HalData->VersionID;
s32 ret = _FAIL;
if (IS_81XXC(*hal_ver) || IS_8723_SERIES(*hal_ver) ||IS_92D(*hal_ver) ||IS_8188E(*hal_ver)) {
ret = c2h_evt_read(adapter, buf);
} else if(IS_8192E(*hal_ver) || IS_8812_SERIES(*hal_ver) || IS_8821_SERIES(*hal_ver) || IS_8723B_SERIES(*hal_ver)) {
ret = c2h_evt_read_88xx(adapter, buf);
} else {
rtw_warn_on(1);
}
return ret;
}
bool rtw_hal_c2h_valid(_adapter *adapter, u8 *buf)
{
HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
HAL_VERSION *hal_ver = &HalData->VersionID;
bool ret = _FAIL;
if (IS_81XXC(*hal_ver) || IS_8723_SERIES(*hal_ver) ||IS_92D(*hal_ver) ||IS_8188E(*hal_ver)) {
ret = c2h_evt_valid((struct c2h_evt_hdr *)buf);
} else if(IS_8192E(*hal_ver) || IS_8812_SERIES(*hal_ver) || IS_8821_SERIES(*hal_ver) || IS_8723B_SERIES(*hal_ver)) {
ret = c2h_evt_valid((struct c2h_evt_hdr_88xx*)buf);
} else {
rtw_warn_on(1);
}
return ret;
}
VOID
ODM_Write_DIG(
IN PDM_ODM_T pDM_Odm,
IN u1Byte CurrentIGI
)
{
_adapter *adapter = pDM_Odm->Adapter;
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(adapter);
struct dm_priv *dmpriv = &pHalData->dmpriv;
DIG_T *pDigTable = &dmpriv->DM_DigTable;
if(pDigTable->CurIGValue != CurrentIGI) {
pDigTable->CurIGValue = CurrentIGI;
rtw_warn_on(!pDM_Odm->write_dig);
if (pDM_Odm->write_dig)
pDM_Odm->write_dig(adapter);
}
}
void rtw_rf_set_tx_gain_offset(_adapter *adapter, u8 path, s8 offset)
{
u8 write_value;
DBG_871X("kfree gain_offset 0x55:0x%x ", rtw_hal_read_rfreg(adapter, path, 0x55, 0xffffffff));
switch (rtw_get_chip_type(adapter)) {
#ifdef CONFIG_RTL8703B
case RTL8703B:
write_value = RF_TX_GAIN_OFFSET_8703B(offset);
rtw_hal_write_rfreg(adapter, path, 0x55, 0x0fc000, write_value);
break;
#endif /* CONFIG_RTL8703B */
#ifdef CONFIG_RTL8188F
case RTL8188F:
write_value = RF_TX_GAIN_OFFSET_8188F(offset);
rtw_hal_write_rfreg(adapter, path, 0x55, 0x0fc000, write_value);
break;
#endif /* CONFIG_RTL8188F */
#ifdef CONFIG_RTL8192E
case RTL8192E:
write_value = RF_TX_GAIN_OFFSET_8192E(offset);
rtw_hal_write_rfreg(adapter, path, 0x55, 0x0f8000, write_value);
break;
#endif /* CONFIG_RTL8188F */
#ifdef CONFIG_RTL8821A
case RTL8821:
write_value = RF_TX_GAIN_OFFSET_8821A(offset);
rtw_hal_write_rfreg(adapter, path, 0x55, 0x0f8000, write_value);
break;
#endif /* CONFIG_RTL8821A */
#ifdef CONFIG_RTL8814A
case RTL8814A:
DBG_871X("\nkfree by PhyDM on the sw CH. path %d\n", path);
break;
#endif /* CONFIG_RTL8821A */
default:
rtw_warn_on(1);
break;
}
DBG_871X(" after :0x%x\n", rtw_hal_read_rfreg(adapter, path, 0x55, 0xffffffff));
}
void rtw_odm_proc_deinit(_adapter *adapter)
{
struct proc_dir_entry *dir_odm = NULL;
int i;
dir_odm = adapter->dir_odm;
if (dir_odm == NULL) {
rtw_warn_on(1);
return;
}
for (i=0;i<odm_proc_hdls_num;i++)
remove_proc_entry(odm_proc_hdls[i].name, dir_odm);
remove_proc_entry("odm", adapter->dir_dev);
adapter->dir_odm = NULL;
}
inline void rtw_st_ctl_unregister(struct st_ctl_t *st_ctl, u8 st_reg_id)
{
int i;
if (st_reg_id >= SESSION_TRACKER_REG_ID_NUM) {
rtw_warn_on(1);
return;
}
st_ctl->reg[st_reg_id].s_proto = 0;
st_ctl->reg[st_reg_id].rule = NULL;
/* clear tracker queue if no session trecker registered */
for (i = 0; i < SESSION_TRACKER_REG_ID_NUM; i++)
if (st_ctl->reg[i].s_proto != 0)
break;
if (i >= SESSION_TRACKER_REG_ID_NUM)
rtw_st_ctl_clear_tracker_q(st_ctl);
}
s8 rtw_rf_get_kfree_tx_gain_offset(_adapter *padapter, u8 path, u8 ch)
{
s8 kfree_offset = 0;
#ifdef CONFIG_RF_GAIN_OFFSET
HAL_DATA_TYPE *hal_data = GET_HAL_DATA(padapter);
struct kfree_data_t *kfree_data = GET_KFREE_DATA(padapter);
s8 bb_gain_sel = rtw_ch_to_bb_gain_sel(ch);
if (bb_gain_sel < BB_GAIN_2G || bb_gain_sel >= BB_GAIN_NUM) {
rtw_warn_on(1);
goto exit;
}
if (kfree_data->flag & KFREE_FLAG_ON) {
kfree_offset = kfree_data->bb_gain[bb_gain_sel][path];
if (1)
DBG_871X("%s path:%u, ch:%u, bb_gain_sel:%d, kfree_offset:%d\n"
, __func__, path, ch, bb_gain_sel, kfree_offset);
}
exit:
#endif /* CONFIG_RF_GAIN_OFFSET */
return kfree_offset;
}
void SetHwReg(struct adapter *adapter, u8 variable, u8 *val)
{
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
DM_ODM_T *odm = &(hal_data->odmpriv);
switch (variable) {
case HW_VAR_PORT_SWITCH:
hw_var_port_switch(adapter);
break;
case HW_VAR_INIT_RTS_RATE:
rtw_warn_on(1);
break;
case HW_VAR_SEC_CFG:
{
u16 reg_scr;
reg_scr = rtw_read16(adapter, REG_SECCFG);
rtw_write16(adapter, REG_SECCFG, reg_scr|SCR_CHK_KEYID|SCR_RxDecEnable|SCR_TxEncEnable);
}
break;
case HW_VAR_SEC_DK_CFG:
{
struct security_priv *sec = &adapter->securitypriv;
u8 reg_scr = rtw_read8(adapter, REG_SECCFG);
if (val) { /* Enable default key related setting */
reg_scr |= SCR_TXBCUSEDK;
if (sec->dot11AuthAlgrthm != dot11AuthAlgrthm_8021X)
reg_scr |= (SCR_RxUseDK|SCR_TxUseDK);
} else /* Disable default key related setting */
reg_scr &= ~(SCR_RXBCUSEDK|SCR_TXBCUSEDK|SCR_RxUseDK|SCR_TxUseDK);
rtw_write8(adapter, REG_SECCFG, reg_scr);
}
break;
case HW_VAR_DM_FLAG:
odm->SupportAbility = *((u32 *)val);
break;
case HW_VAR_DM_FUNC_OP:
if (*((u8 *)val) == true) {
/* save dm flag */
odm->BK_SupportAbility = odm->SupportAbility;
} else {
/* restore dm flag */
odm->SupportAbility = odm->BK_SupportAbility;
}
break;
case HW_VAR_DM_FUNC_SET:
if (*((u32 *)val) == DYNAMIC_ALL_FUNC_ENABLE) {
struct dm_priv *dm = &hal_data->dmpriv;
dm->DMFlag = dm->InitDMFlag;
odm->SupportAbility = dm->InitODMFlag;
} else {
odm->SupportAbility |= *((u32 *)val);
}
break;
case HW_VAR_DM_FUNC_CLR:
/*
* input is already a mask to clear function
* don't invert it again! George, Lucas@20130513
*/
odm->SupportAbility &= *((u32 *)val);
break;
case HW_VAR_AMPDU_MIN_SPACE:
/* TODO - Is something needed here? */
break;
case HW_VAR_WIRELESS_MODE:
/* TODO - Is something needed here? */
break;
default:
DBG_871X_LEVEL(
_drv_always_,
FUNC_ADPT_FMT" variable(%d) not defined!\n",
FUNC_ADPT_ARG(adapter),
variable
);
break;
}
}
inline void rtw_mi_update_iface_status(struct mlme_priv *pmlmepriv, sint state)
{
_adapter *adapter = container_of(pmlmepriv, _adapter, mlmepriv);
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct mi_state *iface_state = &dvobj->iface_state;
u8 i;
u8 u_ch, u_offset, u_bw;
_adapter *iface;
struct mlme_ext_priv *mlmeext;
if ((state == WIFI_MONITOR_STATE) || /* (state == WIFI_OP_CH_SWITCHING) || */
(state == WIFI_ADHOC_MASTER_STATE) || (state == WIFI_ADHOC_STATE) ||
(state == WIFI_SITE_MONITOR) || (state == 0xFFFFFFFF) ||
(state == WIFI_UNDER_WPS)
)
return;
if (0)
RTW_INFO("%s => will change or clean state to 0x%08x\n", __func__, state);
_rtw_memset(iface_state, 0, sizeof(struct mi_state));
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
mlmeext = &iface->mlmeextpriv;
if (check_fwstate(&iface->mlmepriv, WIFI_STATION_STATE) == _TRUE) {
iface_state->sta_num++;
if (check_fwstate(&iface->mlmepriv, _FW_LINKED) == _TRUE)
iface_state->ld_sta_num++;
if (check_fwstate(&iface->mlmepriv, _FW_UNDER_LINKING) == _TRUE)
iface_state->lg_sta_num++;
} else if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE) == _TRUE
&& check_fwstate(&iface->mlmepriv, _FW_LINKED) == _TRUE
) {
iface_state->ap_num++;
if (iface->stapriv.asoc_sta_count > 2)
iface_state->ld_ap_num++;
} else if (check_fwstate(&iface->mlmepriv, WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE) == _TRUE
&& check_fwstate(&iface->mlmepriv, _FW_LINKED) == _TRUE
) {
iface_state->adhoc_num++;
if (iface->stapriv.asoc_sta_count > 2)
iface_state->ld_adhoc_num++;
}
if (check_fwstate(&iface->mlmepriv, WIFI_UNDER_WPS) == _TRUE)
iface_state->uwps_num++;
}
if (rtw_mi_get_ch_setting_union(adapter, &u_ch, &u_bw, &u_offset))
rtw_mi_update_union_chan_inf(adapter , u_ch, u_offset , u_bw);
else {
if (0) {
dump_adapters_status(RTW_DBGDUMP , dvobj);
RTW_INFO("%s-[ERROR] cannot get union channel\n", __func__);
rtw_warn_on(1);
}
}
#ifdef DBG_IFACE_STATUS
DBG_IFACE_STATUS_DUMP(adapter);
#endif
}