mirrors/rtl8812au
1
0
Fork 0
mirror of https://github.com/aircrack-ng/rtl8812au.git synced 2024-11-25 14:44:09 +00:00
Code Releases Activity
8d3c254ed7
rtl8812au/hal/phydm/phydm_soml.c
kimocoder 29fab55737 Uploaded the 8812au v5.2.20.2 driver
2018-07-02 18:49:32 +02:00

605 lines
20 KiB
C
Raw Blame History

/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*****************************************************************************/
/* ************************************************************
* include files
* ************************************************************ */
#include "mp_precomp.h"
#include "phydm_precomp.h"
#ifdef NEVER
void
phydm_dynamicsoftmletting(
struct PHY_DM_STRUCT *p_dm
)
{
u32 ret_val;
#if (RTL8822B_SUPPORT == 1)
if (*(p_dm->p_mp_mode) == false) {
if (p_dm->support_ic_type & ODM_RTL8822B) {
if ((!p_dm->is_linked)|(p_dm->iot_table.is_linked_cmw500))
return;
if (true == p_dm->bsomlenabled) {
PHYDM_DBG(p_dm, ODM_COMP_API, ("PHYDM_DynamicSoftMLSetting(): SoML has been enable, skip dynamic SoML switch\n"));
return;
}
ret_val = odm_get_bb_reg(p_dm, 0xf8c, MASKBYTE0);
PHYDM_DBG(p_dm, ODM_COMP_API, ("PHYDM_DynamicSoftMLSetting(): Read 0xF8C = 0x%08X\n", ret_val));
if (ret_val < 0x16) {
PHYDM_DBG(p_dm, ODM_COMP_API, ("PHYDM_DynamicSoftMLSetting(): 0xF8C(== 0x%08X) < 0x16, enable SoML\n", ret_val));
phydm_somlrxhp_setting(p_dm, true);
/*odm_set_bb_reg(p_dm, 0x19a8, MASKDWORD, 0xc10a0000);*/
p_dm->bsomlenabled = true;
}
}
}
#endif
}
#endif
#ifdef CONFIG_ADAPTIVE_SOML
void
phydm_soml_on_off(
void *p_dm_void,
u8 swch
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &(p_dm->dm_soml_table);
if (swch == SOML_ON) {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("(( Turn on )) SOML\n"));
if (p_dm->support_ic_type == ODM_RTL8822B)
phydm_somlrxhp_setting(p_dm, true);
else if (p_dm->support_ic_type == ODM_RTL8197F)
odm_set_bb_reg(p_dm, 0x998, BIT(6), swch);
} else if (swch == SOML_OFF) {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("(( Turn off )) SOML\n"));
if (p_dm->support_ic_type == ODM_RTL8822B)
phydm_somlrxhp_setting(p_dm, false);
else if (p_dm->support_ic_type == ODM_RTL8197F)
odm_set_bb_reg(p_dm, 0x998, BIT(6), swch);
}
p_dm_soml_table->soml_on_off = swch;
}
#if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
void
phydm_adaptive_soml_callback(
struct timer_list *p_timer
)
{
struct _ADAPTER *adapter = (struct _ADAPTER *)p_timer->Adapter;
HAL_DATA_TYPE *p_hal_data = GET_HAL_DATA(adapter);
struct PHY_DM_STRUCT *p_dm = &(p_hal_data->DM_OutSrc);
struct adaptive_soml *p_dm_soml_table = &(p_dm->dm_soml_table);
#if DEV_BUS_TYPE == RT_PCI_INTERFACE
#if USE_WORKITEM
odm_schedule_work_item(&(p_dm_soml_table->phydm_adaptive_soml_workitem));
#else
{
/*dbg_print("phydm_adaptive_soml-phydm_adaptive_soml_callback\n");*/
phydm_adsl(p_dm);
}
#endif
#else
odm_schedule_work_item(&(p_dm_soml_table->phydm_adaptive_soml_workitem));
#endif
}
void
phydm_adaptive_soml_workitem_callback(
void *p_context
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct _ADAPTER *p_adapter = (struct _ADAPTER *)p_context;
HAL_DATA_TYPE *p_hal_data = GET_HAL_DATA(p_adapter);
struct PHY_DM_STRUCT *p_dm = &(p_hal_data->DM_OutSrc);
/*dbg_print("phydm_adaptive_soml-phydm_adaptive_soml_workitem_callback\n");*/
phydm_adsl(p_dm);
#endif
}
#elif (DM_ODM_SUPPORT_TYPE == ODM_CE)
void
phydm_adaptive_soml_callback(
void *dm_void
)
{
struct PHY_DM_STRUCT *dm = (struct PHY_DM_STRUCT *)dm_void;
void *padapter = dm->adapter;
if (*dm->p_is_net_closed)
return;
if (dm->support_interface == ODM_ITRF_PCIE) {
phydm_adsl(dm);
} else {
/* Can't do I/O in timer callback*/
rtw_run_in_thread_cmd(padapter, phydm_adaptive_soml_workitem_callback, padapter);
}
}
void
phydm_adaptive_soml_workitem_callback(
void *context
)
{
void *adapter = (void *)context;
HAL_DATA_TYPE *hal_data = GET_HAL_DATA(((PADAPTER)adapter));
struct PHY_DM_STRUCT *dm = &hal_data->odmpriv;
/*dbg_print("phydm_adaptive_soml-phydm_adaptive_soml_workitem_callback\n");*/
phydm_adsl(dm);
}
#else
void
phydm_adaptive_soml_callback(
void *p_dm_void
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("******SOML_Callback******\n"));
phydm_adsl(p_dm);
}
#endif
void
phydm_soml_debug(
void *p_dm_void,
u32 *const dm_value,
u32 *_used,
char *output,
u32 *_out_len
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &(p_dm->dm_soml_table);
u32 used = *_used;
u32 out_len = *_out_len;
if (dm_value[0] == 1) { /*Turn on/off SOML*/
p_dm_soml_table->soml_select = (u8)dm_value[1];
} else if (dm_value[0] == 2) { /*training number for SOML*/
p_dm_soml_table->soml_train_num = (u8)dm_value[1];
PHYDM_SNPRINTF((output + used, out_len - used, "soml_train_num = ((%d))\n", p_dm_soml_table->soml_train_num));
} else if (dm_value[0] == 3) { /*training interval for SOML*/
p_dm_soml_table->soml_intvl = (u8)dm_value[1];
PHYDM_SNPRINTF((output + used, out_len - used, "soml_intvl = ((%d))\n", p_dm_soml_table->soml_intvl));
} else if (dm_value[0] == 4) { /*function period for SOML*/
p_dm_soml_table->soml_period = (u8)dm_value[1];
PHYDM_SNPRINTF((output + used, out_len - used, "soml_period = ((%d))\n", p_dm_soml_table->soml_period));
} else if (dm_value[0] == 5) { /*delay_time for SOML*/
p_dm_soml_table->soml_delay_time = (u8)dm_value[1];
PHYDM_SNPRINTF((output + used, out_len - used, "soml_delay_time = ((%d))\n", p_dm_soml_table->soml_delay_time));
} else if (dm_value[0] == 100) { /*show parameters*/
PHYDM_SNPRINTF((output + used, out_len - used, "soml_train_num = ((%d))\n", p_dm_soml_table->soml_train_num));
PHYDM_SNPRINTF((output + used, out_len - used, "soml_intvl = ((%d))\n", p_dm_soml_table->soml_intvl));
PHYDM_SNPRINTF((output + used, out_len - used, "soml_period = ((%d))\n", p_dm_soml_table->soml_period));
PHYDM_SNPRINTF((output + used, out_len - used, "soml_delay_time = ((%d))\n", p_dm_soml_table->soml_delay_time));
}
*_used = used;
*_out_len = out_len;
}
void
phydm_soml_statistics(
void *p_dm_void,
u8 on_off_state
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &(p_dm->dm_soml_table);
u8 i;
u32 num_bytes_diff;
if (on_off_state == SOML_ON) {
if (*p_dm->p_channel <= 14) {
for (i = ODM_RATEMCS0; i <= ODM_RATEMCS15; i++) {
num_bytes_diff = p_dm_soml_table->num_ht_bytes[i - ODM_RATEMCS0] - p_dm_soml_table->pre_num_ht_bytes[i - ODM_RATEMCS0];
p_dm_soml_table->num_ht_bytes_on[i - ODM_RATEMCS0] += num_bytes_diff;
p_dm_soml_table->pre_num_ht_bytes[i - ODM_RATEMCS0] = p_dm_soml_table->num_ht_bytes[i - ODM_RATEMCS0];
}
}
if (p_dm->support_ic_type == ODM_RTL8822B) {
for (i = ODM_RATEVHTSS1MCS0; i <= ODM_RATEVHTSS2MCS9; i++) {
num_bytes_diff = p_dm_soml_table->num_vht_bytes[i - ODM_RATEVHTSS1MCS0] - p_dm_soml_table->pre_num_vht_bytes[i - ODM_RATEVHTSS1MCS0];
p_dm_soml_table->num_vht_bytes_on[i - ODM_RATEVHTSS1MCS0] += num_bytes_diff;
p_dm_soml_table->pre_num_vht_bytes[i - ODM_RATEVHTSS1MCS0] = p_dm_soml_table->num_vht_bytes[i - ODM_RATEVHTSS1MCS0];
}
}
} else if (on_off_state == SOML_OFF) {
if (*p_dm->p_channel <= 14) {
for (i = ODM_RATEMCS0; i <= ODM_RATEMCS15; i++) {
num_bytes_diff = p_dm_soml_table->num_ht_bytes[i - ODM_RATEMCS0] - p_dm_soml_table->pre_num_ht_bytes[i - ODM_RATEMCS0];
p_dm_soml_table->num_ht_bytes_off[i - ODM_RATEMCS0] += num_bytes_diff;
p_dm_soml_table->pre_num_ht_bytes[i - ODM_RATEMCS0] = p_dm_soml_table->num_ht_bytes[i - ODM_RATEMCS0];
}
}
if (p_dm->support_ic_type == ODM_RTL8822B) {
for (i = ODM_RATEVHTSS1MCS0; i <= ODM_RATEVHTSS2MCS9; i++) {
num_bytes_diff = p_dm_soml_table->num_vht_bytes[i - ODM_RATEVHTSS1MCS0] - p_dm_soml_table->pre_num_vht_bytes[i - ODM_RATEVHTSS1MCS0];
p_dm_soml_table->num_vht_bytes_off[i - ODM_RATEVHTSS1MCS0] += num_bytes_diff;
p_dm_soml_table->pre_num_vht_bytes[i - ODM_RATEVHTSS1MCS0] = p_dm_soml_table->num_vht_bytes[i - ODM_RATEVHTSS1MCS0];
}
}
}
}
void
phydm_adsl(
void *p_dm_void
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &(p_dm->dm_soml_table);
u8 i;
u8 next_on_off;
u8 rate_num = 1, rate_ss_shift = 0;
u32 byte_total_on = 0, byte_total_off = 0;
u32 ht_reset[HT_RATE_IDX] = {0}, vht_reset[VHT_RATE_IDX] = {0};
u8 size = sizeof(ht_reset[0]);
if (p_dm->support_ic_type & ODM_IC_4SS)
rate_num = 4;
else if (p_dm->support_ic_type & ODM_IC_3SS)
rate_num = 3;
else if (p_dm->support_ic_type & ODM_IC_2SS)
rate_num = 2;
if (!(p_dm->support_ic_type & ODM_ADAPTIVE_SOML_SUPPORT_IC))
return;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("rssi_min =%d\n", p_dm->rssi_min));
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("soml_state_cnt =((%d))\n", p_dm_soml_table->soml_state_cnt));
/*Traning state: 0(alt) 1(ori) 2(alt) 3(ori)============================================================*/
if (p_dm_soml_table->soml_state_cnt < (p_dm_soml_table->soml_train_num << 1)) {
if (p_dm_soml_table->soml_state_cnt == 0) {
odm_move_memory(p_dm, p_dm_soml_table->num_ht_bytes, ht_reset, HT_RATE_IDX * size);
odm_move_memory(p_dm, p_dm_soml_table->num_ht_bytes_on, ht_reset, HT_RATE_IDX * size);
odm_move_memory(p_dm, p_dm_soml_table->num_ht_bytes_off, ht_reset, HT_RATE_IDX * size);
odm_move_memory(p_dm, p_dm_soml_table->num_vht_bytes, vht_reset, VHT_RATE_IDX * size);
odm_move_memory(p_dm, p_dm_soml_table->num_vht_bytes_on, vht_reset, VHT_RATE_IDX * size);
odm_move_memory(p_dm, p_dm_soml_table->num_vht_bytes_off, vht_reset, VHT_RATE_IDX * size);
p_dm_soml_table->is_soml_method_enable = 1;
p_dm_soml_table->soml_state_cnt++;
next_on_off = (p_dm_soml_table->soml_on_off == SOML_ON) ? SOML_ON : SOML_OFF;
phydm_soml_on_off(p_dm, next_on_off);
odm_set_timer(p_dm, &p_dm_soml_table->phydm_adaptive_soml_timer, p_dm_soml_table->soml_delay_time); /*ms*/
} else if ((p_dm_soml_table->soml_state_cnt % 2) != 0) {
p_dm_soml_table->soml_state_cnt++;
odm_move_memory(p_dm, p_dm_soml_table->pre_num_ht_bytes, p_dm_soml_table->num_ht_bytes, HT_RATE_IDX * size);
odm_move_memory(p_dm, p_dm_soml_table->pre_num_vht_bytes, p_dm_soml_table->num_vht_bytes, VHT_RATE_IDX * size);
odm_set_timer(p_dm, &p_dm_soml_table->phydm_adaptive_soml_timer, p_dm_soml_table->soml_intvl); /*ms*/
} else if ((p_dm_soml_table->soml_state_cnt % 2) == 0) {
p_dm_soml_table->soml_state_cnt++;
phydm_soml_statistics(p_dm, p_dm_soml_table->soml_on_off);
next_on_off = (p_dm_soml_table->soml_on_off == SOML_ON) ? SOML_OFF : SOML_ON;
phydm_soml_on_off(p_dm, next_on_off);
odm_set_timer(p_dm, &p_dm_soml_table->phydm_adaptive_soml_timer, p_dm_soml_table->soml_delay_time); /*ms*/
}
}
/*Decision state: ==============================================================*/
else {
p_dm_soml_table->soml_state_cnt = 0;
phydm_soml_statistics(p_dm, p_dm_soml_table->soml_on_off);
/* [Search 1st and 2ed rate by counter] */
if (*p_dm->p_channel <= 14) {
for (i = 0; i < rate_num; i++) {
rate_ss_shift = (i << 3);
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("*num_ht_bytes_on HT MCS[%d :%d ] = {%d, %d, %d, %d, %d, %d, %d, %d}\n",
(rate_ss_shift),
(rate_ss_shift + 7),
p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 0], p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 1],
p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 2], p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 3],
p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 4], p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 5],
p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 6], p_dm_soml_table->num_ht_bytes_on[rate_ss_shift + 7]));
}
for (i = 0; i < rate_num; i++) {
rate_ss_shift = (i << 3);
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("*num_ht_bytes_off HT MCS[%d :%d ] = {%d, %d, %d, %d, %d, %d, %d, %d}\n",
(rate_ss_shift), (rate_ss_shift + 7),
p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 0], p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 1],
p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 2], p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 3],
p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 4], p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 5],
p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 6], p_dm_soml_table->num_ht_bytes_off[rate_ss_shift + 7]));
}
for (i = ODM_RATEMCS8; i <= ODM_RATEMCS15; i++) {
byte_total_on += p_dm_soml_table->num_ht_bytes_on[i - ODM_RATEMCS0];
byte_total_off += p_dm_soml_table->num_ht_bytes_off[i - ODM_RATEMCS0];
}
} else if (p_dm->support_ic_type == ODM_RTL8822B) {
for (i = 0; i < rate_num; i++) {
rate_ss_shift = 10 * i;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("* num_vht_bytes_on VHT-%d ss MCS[0:9] = {%d, %d, %d, %d, %d, %d, %d, %d, %d, %d}\n",
(i + 1),
p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 0], p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 1],
p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 2], p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 3],
p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 4], p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 5],
p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 6], p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 7],
p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 8], p_dm_soml_table->num_vht_bytes_on[rate_ss_shift + 9]));
}
for (i = 0; i < rate_num; i++) {
rate_ss_shift = 10 * i;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("* num_vht_bytes_off VHT-%d ss MCS[0:9] = {%d, %d, %d, %d, %d, %d, %d, %d, %d, %d}\n",
(i + 1),
p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 0], p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 1],
p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 2], p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 3],
p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 4], p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 5],
p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 6], p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 7],
p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 8], p_dm_soml_table->num_vht_bytes_off[rate_ss_shift + 9]));
}
for (i = ODM_RATEVHTSS2MCS0; i <= ODM_RATEVHTSS2MCS9; i++) {
byte_total_on += p_dm_soml_table->num_vht_bytes_on[i - ODM_RATEVHTSS1MCS0];
byte_total_off += p_dm_soml_table->num_vht_bytes_off[i - ODM_RATEVHTSS1MCS0];
}
}
/* [Decision] */
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[ byte_total_on = %d ; byte_total_off = %d ]\n", byte_total_on, byte_total_off));
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[Decisoin state ]\n"));
if (byte_total_on > byte_total_off) {
next_on_off = SOML_ON;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[ byte_total_on > byte_total_off ==> SOML_ON ]\n"));
} else if (byte_total_on < byte_total_off) {
next_on_off = SOML_OFF;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[ byte_total_on < byte_total_off ==> SOML_OFF ]\n"));
} else {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[ stay at soml_last_state ]\n"));
next_on_off = p_dm_soml_table->soml_last_state;
}
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[ Final decisoin ] : "));
phydm_soml_on_off(p_dm, next_on_off);
p_dm_soml_table->soml_last_state = next_on_off;
}
}
void
phydm_adaptive_soml_reset(
void *p_dm_void
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &p_dm->dm_soml_table;
p_dm_soml_table->soml_state_cnt = 0;
p_dm_soml_table->is_soml_method_enable = 0;
p_dm_soml_table->soml_counter = 0;
}
#endif /* end of CONFIG_ADAPTIVE_SOML*/
void
phydm_soml_bytes_acq(
void *dm_void,
u8 rate_id,
u32 length
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *dm = (struct PHY_DM_STRUCT *)dm_void;
struct adaptive_soml *dm_soml_table = &dm->dm_soml_table;
if ((rate_id >= ODM_RATEMCS0) && (rate_id <= ODM_RATEMCS31))
dm_soml_table->num_ht_bytes[rate_id - ODM_RATEMCS0] += length;
else if ((rate_id >= ODM_RATEVHTSS1MCS0) && (rate_id <= ODM_RATEVHTSS4MCS9))
dm_soml_table->num_vht_bytes[rate_id - ODM_RATEVHTSS1MCS0] += length;
#endif
}
void
phydm_adaptive_soml_timers(
void *p_dm_void,
u8 state
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &p_dm->dm_soml_table;
if (state == INIT_SOML_TIMMER) {
odm_initialize_timer(p_dm, &p_dm_soml_table->phydm_adaptive_soml_timer,
(void *)phydm_adaptive_soml_callback, NULL, "phydm_adaptive_soml_timer");
} else if (state == CANCEL_SOML_TIMMER) {
odm_cancel_timer(p_dm, &p_dm_soml_table->phydm_adaptive_soml_timer);
} else if (state == RELEASE_SOML_TIMMER) {
odm_release_timer(p_dm, &p_dm_soml_table->phydm_adaptive_soml_timer);
}
#endif
}
void
phydm_adaptive_soml_init(
void *p_dm_void
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &p_dm->dm_soml_table;
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("phydm_adaptive_soml_init\n"));
p_dm_soml_table->soml_state_cnt = 0;
p_dm_soml_table->soml_delay_time = 40;
p_dm_soml_table->soml_intvl = 150;
p_dm_soml_table->soml_train_num = 4;
p_dm_soml_table->is_soml_method_enable = 0;
p_dm_soml_table->soml_counter = 0;
p_dm_soml_table->soml_period = 4;
p_dm_soml_table->soml_select = 0;
if (p_dm->support_ic_type & (ODM_RTL8197F | ODM_RTL8192F))
odm_set_bb_reg(p_dm, 0x988, BIT(25), 1);
#endif
}
void
phydm_adaptive_soml(
void *p_dm_void
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
struct adaptive_soml *p_dm_soml_table = &p_dm->dm_soml_table;
if (!(p_dm->support_ability & ODM_BB_ADAPTIVE_SOML)) {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML,
("[Return!!!] Not Support Adaptive SOML Function\n"));
return;
}
if (p_dm_soml_table->soml_counter < p_dm_soml_table->soml_period) {
p_dm_soml_table->soml_counter++;
return;
}
p_dm_soml_table->soml_counter = 0;
if (p_dm_soml_table->soml_select == 0) {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[Adaptive SOML Training !!!]\n"));
} else if (p_dm_soml_table->soml_select == 1) {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[Turn on SOML !!!] Exit from Adaptive SOML Training\n"));
phydm_soml_on_off(p_dm, SOML_ON);
return;
} else if (p_dm_soml_table->soml_select == 2) {
PHYDM_DBG(p_dm, DBG_ADPTV_SOML, ("[Turn off SOML !!!] Exit from Adaptive SOML Training\n"));
phydm_soml_on_off(p_dm, SOML_OFF);
return;
}
if (p_dm->support_ic_type & ODM_ADAPTIVE_SOML_SUPPORT_IC)
phydm_adsl(p_dm);
#endif
}
void
phydm_enable_adaptive_soml(
void *dm_void
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *dm = (struct PHY_DM_STRUCT *)dm_void;
PHYDM_DBG(dm, DBG_ADPTV_SOML, ("[%s][Return!!!] enable Adaptive SOML\n\n", __func__));
dm->support_ability |= ODM_BB_ADAPTIVE_SOML;
phydm_soml_on_off(dm, SOML_ON);
#endif
}
void
phydm_stop_adaptive_soml(
void *dm_void
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *dm = (struct PHY_DM_STRUCT *)dm_void;
PHYDM_DBG(dm, DBG_ADPTV_SOML, ("[%s][Return!!!] Stop Adaptive SOML\n\n", __func__));
dm->support_ability &= ~ODM_BB_ADAPTIVE_SOML;
phydm_soml_on_off(dm, SOML_ON);
#endif
}
void
phydm_adaptive_soml_para_set(
void *dm_void,
u8 train_num,
u8 intvl,
u8 period,
u8 delay_time
)
{
#ifdef CONFIG_ADAPTIVE_SOML
struct PHY_DM_STRUCT *dm = (struct PHY_DM_STRUCT *)dm_void;
struct adaptive_soml *dm_soml_table = &dm->dm_soml_table;
dm_soml_table->soml_train_num = train_num;
dm_soml_table->soml_intvl = intvl;
dm_soml_table->soml_period = period;
dm_soml_table->soml_delay_time = delay_time;
#endif
}
void
phydm_init_soft_ml_setting(
void *p_dm_void
)
{
struct PHY_DM_STRUCT *p_dm = (struct PHY_DM_STRUCT *)p_dm_void;
#if (RTL8822B_SUPPORT == 1)
if (*(p_dm->p_mp_mode) == false) {
if (p_dm->support_ic_type & ODM_RTL8822B)
/*odm_set_bb_reg(p_dm, 0x19a8, MASKDWORD, 0xd10a0000);*/
phydm_somlrxhp_setting(p_dm, true);
p_dm->bsomlenabled = true;
}
#endif
#if (RTL8821C_SUPPORT == 1)
if (*(p_dm->p_mp_mode) == false) {
if (p_dm->support_ic_type & ODM_RTL8821C)
odm_set_bb_reg(p_dm, 0x19a8, BIT(31)|BIT(30)|BIT(29)|BIT(28), 0xd);
}
#endif
}
View Git Blame Copy Permalink