/* SPDX-License-Identifier: GPL-2.0 */
|
#include <linux/delay.h>
|
#include <linux/device.h>
|
#include <linux/errno.h>
|
#include <linux/file.h>
|
#include <linux/fs.h>
|
#include <linux/init.h>
|
#include <linux/kdev_t.h>
|
#include <linux/kernel.h>
|
#include <linux/major.h>
|
#include <linux/miscdevice.h>
|
#include <linux/module.h>
|
#include <linux/printk.h>
|
#include <linux/proc_fs.h>
|
#include <linux/slab.h>
|
#include <linux/string.h>
|
#include <linux/timer.h>
|
#include <linux/types.h>
|
#include <linux/uaccess.h>
|
#include <linux/version.h>
|
#include <linux/vmalloc.h>
|
#include <marlin_platform.h>
|
#include "rf.h"
|
#include "wcn_integrate.h"
|
|
#define SYSTEM_WIFI_CONFIG_FILE "/system/etc/connectivity_configure.ini"
|
#define SYSTEM_WIFI_CALI_FILE "/system/etc/connectivity_calibration.ini"
|
#define VENDOR_WIFI_CONFIG_FILE "/vendor/etc/connectivity_configure.ini"
|
#define VENDOR_WIFI_CALI_FILE "/vendor/etc/connectivity_calibration.ini"
|
#define VENDOR_WIFI_CONFIG_AD_FILE "/vendor/etc/wcn/connectivity_configure.ini"
|
#define SYSTEM_WIFI_CONFIG_AD_FILE "/system/etc/wcn/connectivity_configure.ini"
|
#define VENDOR_WIFI_CALI_AD_FILE "/vendor/etc/wcn/connectivity_calibration.ini"
|
#define SYSTEM_WIFI_CALI_AD_FILE "/system/etc/wcn/connectivity_calibration.ini"
|
#define WIFI_CALI_DUMP_FILE "/mnt/vendor/wcn/connectivity_calibration_bak.ini"
|
|
#define CONF_TYPE 1
|
#define CALI_TYPE 2
|
|
#define MIN_DOUBLE_DIGIT 10
|
#define CF_TAB(NAME, MEM_OFFSET, TYPE) \
|
{ NAME, (size_t)(&(((struct wifi_config_t *)(0))->MEM_OFFSET)), TYPE}
|
#define CL_TAB(NAME, MEM_OFFSET, TYPE) \
|
{ NAME, (size_t)(&(((struct wifi_cali_t *)(0))->MEM_OFFSET)), TYPE}
|
#define OFS_MARK_STRING \
|
"#-----------------------------------------------------------------\r\n"
|
#define GAIN_MP_ST \
|
((int8_t *)&p->txpower_cali.txpower_gain_mapping_table1[0])
|
#define GAIN_MP_ED \
|
((int8_t *)&p->txpower_cali.txpower_gain_mapping_table1[31])
|
#define TXPW_CARCH_ST \
|
((int8_t *)&p->txpower_cali.txpower_subcarries_channel[0])
|
#define TXPW_CARCH_ED \
|
((int8_t *)&p->txpower_cali.txpower_subcarries_channel[14])
|
|
static struct nvm_name_table g_config_table[] = {
|
/*
|
* [SETCTION 0]Marlin config Version info
|
*/
|
CF_TAB("conf_version", config_version, 1),
|
|
/*
|
* [SETCTION 1]wifi TX Power tx power control: tx_power_control_t
|
*/
|
CF_TAB("data_rate_power", tx_power_control.data_rate_power, 1),
|
CF_TAB("channel_num", tx_power_control.channel_num, 1),
|
CF_TAB("channel_range", tx_power_control.channel_range, 1),
|
CF_TAB("b_tx_power_dr0", tx_power_control.b_tx_power_dr0, 1),
|
CF_TAB("b_tx_power_dr1", tx_power_control.b_tx_power_dr1, 1),
|
CF_TAB("g_tx_power_dr0", tx_power_control.g_tx_power_dr0, 1),
|
CF_TAB("g_tx_power_dr1", tx_power_control.g_tx_power_dr1, 1),
|
CF_TAB("g_tx_power_dr2", tx_power_control.g_tx_power_dr2, 1),
|
CF_TAB("g_tx_power_dr3", tx_power_control.g_tx_power_dr3, 1),
|
CF_TAB("n_tx_power_dr0", tx_power_control.n_tx_power_dr0, 1),
|
CF_TAB("n_tx_power_dr1", tx_power_control.n_tx_power_dr1, 1),
|
CF_TAB("n_tx_power_dr2", tx_power_control.n_tx_power_dr2, 1),
|
CF_TAB("n_tx_power_dr3", tx_power_control.n_tx_power_dr3, 1),
|
CF_TAB("power_reserved", tx_power_control.power_reserved, 1),
|
|
/*
|
* [SETCTION 2]wifi PHY/RF reg init: init_register_t
|
*/
|
CF_TAB("phy0_init_num", init_register.phy0_init_num, 1),
|
CF_TAB("init_phy0_regs", init_register.init_phy0_regs, 2),
|
CF_TAB("phy1_init_num", init_register.phy1_init_num, 1),
|
CF_TAB("init_phy1_regs", init_register.init_phy1_regs, 2),
|
CF_TAB("rf_init_num", init_register.rf_init_num, 1),
|
CF_TAB("init_rf_regs", init_register.init_rf_regs, 4),
|
CF_TAB("reserved_w16_num", init_register.reserved_w16_num, 1),
|
CF_TAB("reserved_w16_regs", init_register.reserved_w16_regs, 2),
|
CF_TAB("reserved_w32_num", init_register.reserved_w32_num, 1),
|
CF_TAB("reserved_w32_regs", init_register.reserved_w32_regs, 2),
|
|
/*
|
* [SETCTION 3]wifi enhance config: enhance_config_t
|
*/
|
CF_TAB("tpc_enable", enhance_config.tpc_enable, 1),
|
CF_TAB("power_save_key", enhance_config.power_save_key, 1),
|
CF_TAB("enhance_reserved", enhance_config.enhance_reserved, 1),
|
|
/*
|
* [SETCTION 4]Wifi/BT/lte coex config: coex_config_t
|
*/
|
CF_TAB("CoexExcutionMode",
|
coex_config.CoexExcutionMode, 1),
|
CF_TAB("CoexWifiScanCntPerChannel",
|
coex_config.CoexWifiScanCntPerChannel, 1),
|
CF_TAB("CoexWifiScanDurationOneTime",
|
coex_config.CoexWifiScanDurationOneTime, 1),
|
CF_TAB("CoexScoPeriodsToBlockDuringDhcp",
|
coex_config.CoexScoPeriodsToBlockDuringDhcp, 1),
|
CF_TAB("CoexA2dpDhcpProtectLevel",
|
coex_config.CoexA2dpDhcpProtectLevel, 1),
|
CF_TAB("CoexScoperiodsToBlockDuringEap",
|
coex_config.CoexScoperiodsToBlockDuringEap, 1),
|
CF_TAB("CoexA2dpEapProtectLevel",
|
coex_config.CoexA2dpEapProtectLevel, 1),
|
CF_TAB("CoexScoPeriodsToBlockDuringWifiJoin",
|
coex_config.CoexScoPeriodsToBlockDuringWifiJoin, 1),
|
CF_TAB("CoexA2dpWifiJoinProtectLevel",
|
coex_config.CoexA2dpWifiJoinProtectLevel, 1),
|
CF_TAB("CoexEnterPMStateTime",
|
coex_config.CoexEnterPMStateTime, 2),
|
CF_TAB("CoexAclA2dpBtWorkTime",
|
coex_config.CoexAclA2dpBtWorkTime, 2),
|
CF_TAB("CoexAclA2dpWifiWorkTime",
|
coex_config.CoexAclA2dpWifiWorkTime, 2),
|
CF_TAB("CoexAclNoA2dpBtWorkTime",
|
coex_config.CoexAclNoA2dpBtWorkTime, 2),
|
CF_TAB("CoexAclNoA2dpWifiWorkTime",
|
coex_config.CoexAclNoA2dpWifiWorkTime, 2),
|
CF_TAB("CoexAclMixBtWorkTime",
|
coex_config.CoexAclMixBtWorkTime, 2),
|
CF_TAB("CoexAclMixWifiWorkTime",
|
coex_config.CoexAclMixWifiWorkTime, 2),
|
CF_TAB("CoexPageInqBtWorkTime",
|
coex_config.CoexPageInqBtWorkTime, 2),
|
CF_TAB("CoexPageInqWifiWorkTime",
|
coex_config.CoexPageInqWifiWorkTime, 2),
|
CF_TAB("CoexScoSchema",
|
coex_config.CoexScoSchema, 2),
|
CF_TAB("CoexDynamicScoSchemaEnable",
|
coex_config.CoexDynamicScoSchemaEnable, 2),
|
CF_TAB("CoexScoPeriodsBtTakeAll",
|
coex_config.CoexScoPeriodsBtTakeAll, 2),
|
CF_TAB("CoexLteTxAdvancedTime",
|
coex_config.CoexLteTxAdvancedTime, 2),
|
CF_TAB("CoexLteOneSubFrameLen",
|
coex_config.CoexLteOneSubFrameLen, 2),
|
CF_TAB("CoexLteTxTimerLen",
|
coex_config.CoexLteTxTimerLen, 2),
|
CF_TAB("CoexLteTxTimerFrameHeadLen",
|
coex_config.CoexLteTxTimerFrameHeadLen, 2),
|
CF_TAB("CoexLteStrategyFlag",
|
coex_config.CoexLteStrategyFlag, 2),
|
CF_TAB("CoexWifiDegradePowerValue",
|
coex_config.CoexWifiDegradePowerValue, 2),
|
CF_TAB("CoexBtDegradePowerValue",
|
coex_config.CoexBtDegradePowerValue, 2),
|
CF_TAB("CoexWifi2300TxSpur2Lte",
|
coex_config.CoexWifi2300TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2310TxSpur2Lte",
|
coex_config.CoexWifi2310TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2320TxSpur2Lte",
|
coex_config.CoexWifi2320TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2330TxSpur2Lte",
|
coex_config.CoexWifi2330TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2340TxSpur2Lte",
|
coex_config.CoexWifi2340TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2350TxSpur2Lte",
|
coex_config.CoexWifi2350TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2360TxSpur2Lte",
|
coex_config.CoexWifi2360TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2370TxSpur2Lte",
|
coex_config.CoexWifi2370TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2380TxSpur2Lte",
|
coex_config.CoexWifi2380TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2390TxSpur2Lte",
|
coex_config.CoexWifi2390TxSpur2Lte[0], 2),
|
CF_TAB("CoexWifi2400TxSpur2Lte",
|
coex_config.CoexWifi2400TxSpur2Lte[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2300",
|
coex_config.CoexLteTxSpur2Wifi2300[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2310",
|
coex_config.CoexLteTxSpur2Wifi2310[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2320",
|
coex_config.CoexLteTxSpur2Wifi2320[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2330",
|
coex_config.CoexLteTxSpur2Wifi2330[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2340",
|
coex_config.CoexLteTxSpur2Wifi2340[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2350",
|
coex_config.CoexLteTxSpur2Wifi2350[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2360",
|
coex_config.CoexLteTxSpur2Wifi2360[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2370",
|
coex_config.CoexLteTxSpur2Wifi2370[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2380",
|
coex_config.CoexLteTxSpur2Wifi2380[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2390",
|
coex_config.CoexLteTxSpur2Wifi2390[0], 2),
|
CF_TAB("CoexLteTxSpur2Wifi2400",
|
coex_config.CoexLteTxSpur2Wifi2400[0], 2),
|
CF_TAB("CoexReserved", coex_config.CoexReserved, 2),
|
|
/*
|
* [SETCTION 5]Wifi&BT public config
|
*/
|
CF_TAB("public_reserved", public_config.public_reserved, 1),
|
{0, 0, 0}
|
};
|
|
static struct nvm_name_table g_cali_table[] = {
|
/*
|
* [SETCTION 0]Marlin cali Version info
|
*/
|
CL_TAB("cali_version", cali_version, 1),
|
|
/*
|
* [SETCTION 1]Calibration Config: cali_config_t
|
*/
|
CL_TAB("is_calibrated", cali_config.is_calibrated, 1),
|
CL_TAB("rc_cali_en", cali_config.rc_cali_en, 1),
|
CL_TAB("dcoc_cali_en", cali_config.dcoc_cali_en, 1),
|
CL_TAB("txiq_cali_en", cali_config.txiq_cali_en, 1),
|
CL_TAB("rxiq_cali_en", cali_config.rxiq_cali_en, 1),
|
CL_TAB("txpower_cali_en", cali_config.txpower_cali_en, 1),
|
CL_TAB("dpd_cali_en", cali_config.dpd_cali_en, 1),
|
CL_TAB("config_reserved", cali_config.config_reserved[0], 1),
|
|
/*
|
* [SETCTION 2]rc calibration data: rctune_cali_t
|
*/
|
CL_TAB("rctune_value", rctune_cali.rctune_value, 1),
|
CL_TAB("rc_cali_reserved", rctune_cali.rctune_reserved[0], 1),
|
|
/*
|
* [SETCTION 3]doco calibration data: dcoc_cali_t
|
*/
|
CL_TAB("dcoc_cali_code", dcoc_cali.dcoc_cali_code[0], 2),
|
CL_TAB("dcoc_reserved", dcoc_cali.dcoc_reserved[0], 4),
|
|
/*
|
* [SETCTION 4]txiq calibration data: txiq_cali_t
|
*/
|
CL_TAB("rf_txiq_c11", txiq_cali.rf_txiq_c11, 4),
|
CL_TAB("rf_txiq_c12", txiq_cali.rf_txiq_c12, 4),
|
CL_TAB("rf_txiq_c22", txiq_cali.rf_txiq_c22, 4),
|
CL_TAB("rf_txiq_dc", txiq_cali.rf_txiq_dc, 4),
|
CL_TAB("txiq_reserved", txiq_cali.txiq_reserved[0], 4),
|
|
/*
|
* [SETCTION 5]rxiq calibration data: rxiq_cali_t
|
*/
|
CL_TAB("rf_rxiq_coef21_22", rxiq_cali.rf_rxiq_coef21_22, 4),
|
CL_TAB("rf_rxiq_coef11_12", rxiq_cali.rf_rxiq_coef11_12, 4),
|
CL_TAB("rxiq_reserved", rxiq_cali.rxiq_reserved[0], 4),
|
|
/*
|
* [SETCTION 6]txpower calibration data: txpower_cali_t
|
*/
|
CL_TAB("txpower_psat_temperature",
|
txpower_cali.txpower_psat_temperature, 4),
|
CL_TAB("txpower_psat_gainindex",
|
txpower_cali.txpower_psat_gainindex, 1),
|
|
CL_TAB("txpower_psat_power",
|
txpower_cali.txpower_psat_power, 2),
|
CL_TAB("txpower_psat_backoff",
|
txpower_cali.txpower_psat_backoff, 1),
|
CL_TAB("txpower_psat_upper_limit",
|
txpower_cali.txpower_psat_upper_limit, 1),
|
CL_TAB("txpower_psat_lower_limit",
|
txpower_cali.txpower_psat_lower_limit, 1),
|
|
CL_TAB("txpower_freq_delta_gainindex",
|
txpower_cali.txpower_freq_delta_gainindex[0], 1),
|
|
CL_TAB("txpower_psat_11b_backoff",
|
txpower_cali.txpower_psat_11b_backoff, 1),
|
CL_TAB("txpower_psat_11g_backoff",
|
txpower_cali.txpower_psat_11g_backoff, 1),
|
CL_TAB("txpower_psat_11n_backoff",
|
txpower_cali.txpower_psat_11n_backoff, 1),
|
CL_TAB("txpower_sar_11b_backoff",
|
txpower_cali.txpower_sar_11b_backoff, 1),
|
CL_TAB("txpower_sar_11g_backoff",
|
txpower_cali.txpower_sar_11g_backoff, 1),
|
CL_TAB("txpower_sar_11n_backoff",
|
txpower_cali.txpower_sar_11n_backoff, 1),
|
CL_TAB("txpower_countrycode_11b_backoff",
|
txpower_cali.txpower_countrycode_11b_backoff, 1),
|
CL_TAB("txpower_countrycode_11g_backoff",
|
txpower_cali.txpower_countrycode_11g_backoff, 1),
|
CL_TAB("txpower_countrycode_11n_backoff",
|
txpower_cali.txpower_countrycode_11n_backoff, 1),
|
CL_TAB("g_txpower_npi_set",
|
txpower_cali.g_txpower_npi_set, 1),
|
CL_TAB("txpower_gain_mapping_flag",
|
txpower_cali.txpower_gain_mapping_flag, 1),
|
|
CL_TAB("txpower_gain_mapping_table1",
|
txpower_cali.txpower_gain_mapping_table[0], 1),
|
CL_TAB("txpower_gain_mapping_table2",
|
txpower_cali.txpower_gain_mapping_table[1], 1),
|
CL_TAB("txpower_gain_mapping_table3",
|
txpower_cali.txpower_gain_mapping_table[2], 1),
|
CL_TAB("txpower_gain_mapping_table4",
|
txpower_cali.txpower_gain_mapping_table[3], 1),
|
CL_TAB("txpower_gain_mapping_table5",
|
txpower_cali.txpower_gain_mapping_table[4], 1),
|
CL_TAB("txpower_gain_mapping_table6",
|
txpower_cali.txpower_gain_mapping_table[5], 1),
|
CL_TAB("txpower_gain_mapping_table7",
|
txpower_cali.txpower_gain_mapping_table[6], 1),
|
CL_TAB("txpower_gain_mapping_table8",
|
txpower_cali.txpower_gain_mapping_table[7], 1),
|
CL_TAB("txpower_gain_mapping_table9",
|
txpower_cali.txpower_gain_mapping_table[8], 1),
|
CL_TAB("txpower_gain_mapping_table10",
|
txpower_cali.txpower_gain_mapping_table[9], 1),
|
CL_TAB("txpower_gain_mapping_table11",
|
txpower_cali.txpower_gain_mapping_table[10], 1),
|
CL_TAB("txpower_gain_mapping_table12",
|
txpower_cali.txpower_gain_mapping_table[11], 1),
|
CL_TAB("txpower_gain_mapping_table13",
|
txpower_cali.txpower_gain_mapping_table[12], 1),
|
CL_TAB("txpower_gain_mapping_table14",
|
txpower_cali.txpower_gain_mapping_table[13], 1),
|
|
CL_TAB("txpower_subcarries_compensation_flag",
|
txpower_cali.txpower_subcarries_compensation_flag, 1),
|
CL_TAB("txpower_subcarries_channel1",
|
txpower_cali.txpower_subcarries_channel[0], 1),
|
CL_TAB("txpower_subcarries_channel2",
|
txpower_cali.txpower_subcarries_channel[1], 1),
|
CL_TAB("txpower_subcarries_channel3",
|
txpower_cali.txpower_subcarries_channel[2], 1),
|
CL_TAB("txpower_subcarries_channel4",
|
txpower_cali.txpower_subcarries_channel[3], 1),
|
CL_TAB("txpower_subcarries_channel5",
|
txpower_cali.txpower_subcarries_channel[4], 1),
|
CL_TAB("txpower_subcarries_channel6",
|
txpower_cali.txpower_subcarries_channel[5], 1),
|
CL_TAB("txpower_subcarries_channel7",
|
txpower_cali.txpower_subcarries_channel[6], 1),
|
CL_TAB("txpower_subcarries_channel8",
|
txpower_cali.txpower_subcarries_channel[7], 1),
|
CL_TAB("txpower_subcarries_channel9",
|
txpower_cali.txpower_subcarries_channel[8], 1),
|
CL_TAB("txpower_subcarries_channel10",
|
txpower_cali.txpower_subcarries_channel[9], 1),
|
CL_TAB("txpower_subcarries_channel11",
|
txpower_cali.txpower_subcarries_channel[10], 1),
|
CL_TAB("txpower_subcarries_channel12",
|
txpower_cali.txpower_subcarries_channel[11], 1),
|
CL_TAB("txpower_subcarries_channel13",
|
txpower_cali.txpower_subcarries_channel[12], 1),
|
CL_TAB("txpower_subcarries_channel14",
|
txpower_cali.txpower_subcarries_channel[13], 1),
|
|
CL_TAB("txpower_psat_trace_value",
|
txpower_cali.txpower_psat_trace_value[0], 1),
|
CL_TAB("txpower_reserved",
|
txpower_cali.txpower_reserved[0], 4),
|
CL_TAB("c_pad",
|
txpower_cali.c_pad[0], 1),
|
|
/*
|
* [SETCTION 7]DPD calibration data: dpd_cali_t
|
*/
|
CL_TAB("dpd_cali_channel_num",
|
dpd_cali.dpd_cali_channel_num, 1),
|
CL_TAB("dpd_cali_channel",
|
dpd_cali.dpd_cali_channel[0], 1),
|
CL_TAB("dpd_mod_switch_flag",
|
dpd_cali.dpd_mod_switch_flag, 1),
|
CL_TAB("dpd_npi_cali_flag",
|
dpd_cali.dpd_npi_cali_flag, 1),
|
CL_TAB("channel1_dpd_cali_table",
|
dpd_cali.channel_dpd_cali_table[0], 4),
|
CL_TAB("channel2_dpd_cali_table",
|
dpd_cali.channel_dpd_cali_table[1], 4),
|
CL_TAB("channel3_dpd_cali_table",
|
dpd_cali.channel_dpd_cali_table[2], 4),
|
CL_TAB("dpd_reserved",
|
dpd_cali.dpd_reserved[0], 4),
|
|
/*
|
* [SETCTION 8]RF parameters data: rf_para_t
|
*/
|
CL_TAB("rf_ctune", rf_para.rf_ctune[0], 1),
|
CL_TAB("rf_reserved", rf_para.rf_reserved[0], 4),
|
|
/*
|
* [SETCTION 9]RF parameters data: tpc_cfg_t
|
*/
|
CL_TAB("tpc_cfg", tpc_cfg.tpc_cfg[0], 4),
|
CL_TAB("tpc_reserved", tpc_cfg.tpc_reserved[0], 4),
|
{0, 0, 0}
|
};
|
|
static int find_type(char key)
|
{
|
if ((key >= 'a' && key <= 'w') ||
|
(key >= 'y' && key <= 'z') ||
|
(key >= 'A' && key <= 'W') ||
|
(key >= 'Y' && key <= 'Z') ||
|
('_' == key))
|
return 1;
|
if ((key >= '0' && key <= '9') ||
|
('-' == key))
|
return 2;
|
if (('x' == key) ||
|
('X' == key) ||
|
('.' == key))
|
return 3;
|
if ((key == '\0') ||
|
('\r' == key) ||
|
('\n' == key) ||
|
('#' == key))
|
return 4;
|
return 0;
|
}
|
|
static int wifi_nvm_set_cmd(struct nvm_name_table *pTable,
|
struct nvm_cali_cmd *cmd, void *p_data)
|
{
|
int i;
|
unsigned char *p;
|
|
if ((pTable->type != 1) &&
|
(pTable->type != 2) &&
|
(pTable->type != 4))
|
return -1;
|
|
p = (unsigned char *)(p_data) + pTable->mem_offset;
|
|
pr_info("[g_table]%s, offset:%u, num:%u, value: %x %x %x",
|
pTable->itm, pTable->mem_offset, cmd->num,
|
cmd->par[0], cmd->par[1], cmd->par[2]);
|
pr_debug(", %x %x %x %x %x %x\n",
|
cmd->par[6], cmd->par[7], cmd->par[8],
|
cmd->par[9], cmd->par[10], cmd->par[11]);
|
|
for (i = 0; i < cmd->num; i++) {
|
if (pTable->type == 1)
|
*((unsigned char *)p + i) =
|
(unsigned char)(cmd->par[i]);
|
else if (pTable->type == 2)
|
*((unsigned short *)p + i) =
|
(unsigned short)(cmd->par[i]);
|
else if (pTable->type == 4)
|
*((unsigned int *)p + i) =
|
(unsigned int)(cmd->par[i]);
|
else
|
pr_info("%s, type err\n", __func__);
|
}
|
return 0;
|
}
|
|
static void get_cmd_par(char *str, struct nvm_cali_cmd *cmd)
|
{
|
int i, j, bufType, cType, flag;
|
char tmp[128];
|
char c;
|
s64 val;
|
|
bufType = -1;
|
cType = 0;
|
flag = 0;
|
memset(cmd, 0, sizeof(struct nvm_cali_cmd));
|
for (i = 0, j = 0;; i++) {
|
c = str[i];
|
cType = find_type(c);
|
if ((cType == 1) || (cType == 2) ||
|
(cType == 3)) {
|
tmp[j] = c;
|
j++;
|
if (bufType == -1) {
|
if (cType == 2)
|
bufType = 2;
|
else
|
bufType = 1;
|
} else if (bufType == 2) {
|
if (cType == 1)
|
bufType = 1;
|
}
|
continue;
|
}
|
if (-1 != bufType) {
|
tmp[j] = '\0';
|
|
if ((bufType == 1) && (flag == 0)) {
|
strcpy(cmd->itm, tmp);
|
flag = 1;
|
} else {
|
if (kstrtos64(tmp, 0, &val))
|
pr_err("kstrtos64 %s: error is %d\n",
|
tmp, kstrtos64(tmp, 0, &val));
|
cmd->par[cmd->num] = val & 0xFFFFFFFFFFFFFFFF;
|
cmd->num++;
|
}
|
bufType = -1;
|
j = 0;
|
}
|
if (cType == 0)
|
continue;
|
if (cType == 4)
|
return;
|
}
|
}
|
|
static struct nvm_name_table *cf_table_match(struct nvm_cali_cmd *cmd)
|
{
|
int i;
|
struct nvm_name_table *pTable = NULL;
|
int len = sizeof(g_config_table) / sizeof(struct nvm_name_table);
|
|
if ((cmd == NULL) || (cmd->itm == NULL))
|
return NULL;
|
for (i = 0; i < len; i++) {
|
if (g_config_table[i].itm == NULL)
|
continue;
|
if (strcmp(g_config_table[i].itm, cmd->itm) != 0)
|
continue;
|
pTable = &g_config_table[i];
|
break;
|
}
|
return pTable;
|
}
|
|
static struct nvm_name_table *cali_table_match(struct nvm_cali_cmd *cmd)
|
{
|
int i;
|
struct nvm_name_table *pTable = NULL;
|
int len = sizeof(g_cali_table) / sizeof(struct nvm_name_table);
|
|
if ((cmd == NULL) || (cmd->itm == NULL))
|
return NULL;
|
for (i = 0; i < len; i++) {
|
if (g_cali_table[i].itm == NULL)
|
continue;
|
if (strcmp(g_cali_table[i].itm, cmd->itm) != 0)
|
continue;
|
pTable = &g_cali_table[i];
|
break;
|
}
|
return pTable;
|
}
|
|
static int wifi_nvm_buf_operate(char *pBuf, int file_len,
|
const int type, void *p_data)
|
{
|
int i, p;
|
struct nvm_cali_cmd cmd;
|
struct nvm_name_table *pTable = NULL;
|
|
if ((pBuf == NULL) || (file_len == 0))
|
return -1;
|
for (i = 0, p = 0; i < file_len; i++) {
|
if (('\n' == *(pBuf + i)) ||
|
('\r' == *(pBuf + i)) ||
|
('\0' == *(pBuf + i))) {
|
if (5 <= (i - p)) {
|
get_cmd_par((pBuf + p), &cmd);
|
if (type == 1) {
|
pTable = cf_table_match(&cmd);
|
} else if (type == 2) { /*calibration */
|
pTable = cali_table_match(&cmd);
|
} else {
|
pr_info("%s unknown type\n", __func__);
|
return -1;
|
}
|
|
if (pTable != NULL)
|
wifi_nvm_set_cmd(pTable, &cmd, p_data);
|
}
|
p = i + 1;
|
}
|
}
|
return 0;
|
}
|
|
static int wifi_nvm_parse(const char *path, const int type, void *p_data)
|
{
|
unsigned char *p_buf = NULL;
|
unsigned int read_len, buffer_len;
|
struct file *file;
|
char *buffer = NULL;
|
loff_t file_size = 0, pos = 0;
|
|
pr_info("%s()...\n", __func__);
|
|
file = filp_open(path, O_RDONLY, 0);
|
if (IS_ERR(file)) {
|
pr_err("open file %s error\n", path);
|
return -1;
|
}
|
|
file_size = vfs_llseek(file, 0, SEEK_END);
|
buffer_len = 0;
|
buffer = vmalloc(file_size);
|
p_buf = buffer;
|
if (!buffer) {
|
fput(file);
|
pr_err("no memory\n");
|
return -1;
|
}
|
|
do {
|
#if KERNEL_VERSION(4, 14, 0) <= LINUX_VERSION_CODE
|
read_len = kernel_read(file, (void *)p_buf, file_size, &pos);
|
#else
|
read_len = kernel_read(file, pos, p_buf, file_size);
|
#endif
|
if (read_len > 0) {
|
buffer_len += read_len;
|
file_size -= read_len;
|
p_buf += read_len;
|
}
|
} while ((read_len > 0) && (file_size > 0));
|
|
fput(file);
|
|
pr_info("%s read %s data_len:0x%x\n", __func__, path, buffer_len);
|
wifi_nvm_buf_operate(buffer, buffer_len, type, p_data);
|
vfree(buffer);
|
pr_info("%s(), ok!\n", __func__);
|
return 0;
|
}
|
|
int get_connectivity_config_param(struct wifi_config_t *p)
|
{
|
int ret;
|
char *path = VENDOR_WIFI_CONFIG_FILE;
|
#ifdef CONFIG_SC2342_INTEG
|
if (wcn_get_aon_chip_id() == WCN_SHARKLE_CHIP_AD) {
|
path = SYSTEM_WIFI_CONFIG_AD_FILE;
|
ret = wifi_nvm_parse(path, CONF_TYPE, (void *)p);
|
if (!ret)
|
return ret;
|
}
|
#endif
|
ret = wifi_nvm_parse(SYSTEM_WIFI_CONFIG_FILE, CONF_TYPE, (void *)p);
|
if (ret < 0) {
|
#ifdef CONFIG_SC2342_INTEG
|
struct file *file;
|
|
path = VENDOR_WIFI_CONFIG_AD_FILE;
|
file = filp_open(path, O_RDONLY, 0);
|
if (IS_ERR(file)) {
|
pr_err("open file %s error,try vendor/etc\n", path);
|
path = VENDOR_WIFI_CONFIG_FILE;
|
} else {
|
filp_close(file, NULL);
|
if ((wcn_get_aon_chip_id() != WCN_SHARKLE_CHIP_AD) &&
|
(wcn_get_aon_chip_id() != WCN_PIKE2_CHIP_AB))
|
path = VENDOR_WIFI_CONFIG_FILE;
|
}
|
#endif
|
pr_info("%s path : %s\n", __func__, path);
|
return wifi_nvm_parse(path, CONF_TYPE, (void *)p);
|
}
|
return ret;
|
}
|
|
int get_connectivity_cali_param(struct wifi_cali_t *p)
|
{
|
int ret;
|
char *path = VENDOR_WIFI_CALI_FILE;
|
|
#ifdef CONFIG_SC2342_INTEG
|
if (wcn_get_aon_chip_id() == WCN_SHARKLE_CHIP_AD) {
|
path = SYSTEM_WIFI_CALI_AD_FILE;
|
ret = wifi_nvm_parse(path, CALI_TYPE, (void *)p);
|
if (!ret)
|
return ret;
|
}
|
#endif
|
ret = wifi_nvm_parse(SYSTEM_WIFI_CALI_FILE, CALI_TYPE, (void *)p);
|
if (ret < 0) {
|
#ifdef CONFIG_SC2342_INTEG
|
struct file *file;
|
|
path = VENDOR_WIFI_CALI_AD_FILE;
|
file = filp_open(path, O_RDONLY, 0);
|
if (IS_ERR(file)) {
|
pr_err("open file %s error,try vendor/etc\n", path);
|
path = VENDOR_WIFI_CALI_FILE;
|
} else {
|
filp_close(file, NULL);
|
if ((wcn_get_aon_chip_id() != WCN_SHARKLE_CHIP_AD) &&
|
(wcn_get_aon_chip_id() != WCN_PIKE2_CHIP_AB))
|
path = VENDOR_WIFI_CALI_FILE;
|
}
|
#endif
|
pr_info("%s path : %s\n", __func__, path);
|
return wifi_nvm_parse(path, CALI_TYPE, (void *)p);
|
}
|
return ret;
|
}
|
|
|
static int write_file(struct file *fp, char *buf, size_t len)
|
{
|
loff_t offset = 0;
|
|
offset = vfs_llseek(fp, 0, SEEK_END);
|
if (kernel_write(fp, buf, len, offset) < 0) {
|
pr_err("kernel_write() for fp failed:");
|
return -1;
|
}
|
|
return 0;
|
}
|
|
#define DUMP(fp, fmt, args...) \
|
do { \
|
static char buf[1024]; \
|
size_t len = snprintf(buf, sizeof(buf), fmt, ## args); \
|
write_file(fp, buf, len); \
|
} while (0)
|
|
static void cali_save_file(char *path, struct wifi_cali_t *p)
|
{
|
struct file *fp;
|
int i, j;
|
|
set_fs(KERNEL_DS);
|
|
fp = filp_open(path, O_RDWR | O_CREAT | O_TRUNC, 0771);
|
if (IS_ERR_OR_NULL(fp)) {
|
pr_err("%s(), open error!\n", __func__);
|
return;
|
}
|
DUMP(fp, "[SETCTION 0]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# Marlin2 cali Version info\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "cali_version = %d\r\n\r\n", p->cali_version);
|
|
|
DUMP(fp, "[SETCTION 1]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# Calibration Config\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "is_calibrated = %d\r\n",
|
p->cali_config.is_calibrated/*p->cali_config->is_calibrated*/);
|
DUMP(fp, "rc_cali_en = %d\r\n", p->cali_config.rc_cali_en);
|
DUMP(fp, "dcoc_cali_en = %d\r\n",
|
p->cali_config.dcoc_cali_en);
|
DUMP(fp, "txiq_cali_en = %d\r\n", p->cali_config.txiq_cali_en);
|
DUMP(fp, "rxiq_cali_en = %d\r\n", p->cali_config.rxiq_cali_en);
|
DUMP(fp, "txpower_cali_en = %d\r\n",
|
p->cali_config.txpower_cali_en);
|
DUMP(fp, "dpd_cali_en = %d\r\n",
|
p->cali_config.dpd_cali_en);
|
DUMP(fp, "config_reserved = %d, %d, %d, %d\r\n\r\n",
|
p->cali_config.config_reserved[0],
|
p->cali_config.config_reserved[1],
|
p->cali_config.config_reserved[2],
|
p->cali_config.config_reserved[3]);
|
|
|
DUMP(fp, "[SETCTION 2]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# rc calibration data\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "rctune_value = 0x%x\n",
|
p->rctune_cali.rctune_value);
|
DUMP(fp, "rc_cali_reserved= 0x%x, 0x%x\r\n\r\n",
|
p->rctune_cali.rctune_reserved[0],
|
p->rctune_cali.rctune_reserved[1]);
|
|
DUMP(fp, "[SETCTION 3]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# doco calibration data\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
|
DUMP(fp, "dcoc_cali_code =");
|
for (i = 0; i < DCOC_CALI_CODE_LEN - 1; i++)
|
DUMP(fp, " 0x%x,", p->dcoc_cali.dcoc_cali_code[i]);
|
DUMP(fp, " 0x%x\r\n",
|
p->dcoc_cali.dcoc_cali_code[DCOC_CALI_CODE_LEN - 1]);
|
|
DUMP(fp, "dcoc_reserved = 0x%x, 0x%x, 0x%x, 0x%x\r\n\r\n",
|
p->dcoc_cali.dcoc_reserved[0],
|
p->dcoc_cali.dcoc_reserved[1],
|
p->dcoc_cali.dcoc_reserved[2],
|
p->dcoc_cali.dcoc_reserved[3]);
|
|
|
DUMP(fp, "[SETCTION 4]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# txiq calibration data\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "rf_txiq_c11 = 0x%x\r\n", p->txiq_cali.rf_txiq_c11);
|
DUMP(fp, "rf_txiq_c12 = 0x%x\r\n", p->txiq_cali.rf_txiq_c12);
|
DUMP(fp, "rf_txiq_c22 = 0x%x\r\n", p->txiq_cali.rf_txiq_c22);
|
DUMP(fp, "rf_txiq_dc = 0x%x\r\n", p->txiq_cali.rf_txiq_dc);
|
DUMP(fp, "txiq_reserved = 0x%x, 0x%x, 0x%x, 0x%x\r\n",
|
p->txiq_cali.txiq_reserved[0],
|
p->txiq_cali.txiq_reserved[1],
|
p->txiq_cali.txiq_reserved[2],
|
p->txiq_cali.txiq_reserved[3]);
|
DUMP(fp, "\r\n");
|
|
|
DUMP(fp, "[SETCTION 5]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# rxiq calibration data\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "rf_rxiq_coef21_22 = 0x%x\r\n",
|
p->rxiq_cali.rf_rxiq_coef21_22);
|
DUMP(fp, "rf_rxiq_coef11_12 = 0x%x\r\n",
|
p->rxiq_cali.rf_rxiq_coef11_12);
|
DUMP(fp, "rxiq_reserved = 0x%x, 0x%x\r\n",
|
p->rxiq_cali.rxiq_reserved[0],
|
p->rxiq_cali.rxiq_reserved[1]);
|
DUMP(fp, "\r\n");
|
|
DUMP(fp, "[SETCTION 6]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# txpower calibration data\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "txpower_psat_temperature = %d\r\n",
|
p->txpower_cali.txpower_psat_temperature);
|
DUMP(fp, "txpower_psat_gainindex = %d\r\n",
|
p->txpower_cali.txpower_psat_gainindex);
|
DUMP(fp, "txpower_psat_power = %d\r\n",
|
p->txpower_cali.txpower_psat_power);
|
DUMP(fp, "txpower_psat_backoff = %d\r\n",
|
p->txpower_cali.txpower_psat_backoff);
|
DUMP(fp, "txpower_psat_upper_limit = %d\r\n",
|
p->txpower_cali.txpower_psat_upper_limit);
|
DUMP(fp, "txpower_psat_lower_limit = %d\r\n",
|
p->txpower_cali.txpower_psat_lower_limit);
|
|
DUMP(fp, "txpower_freq_delta_gainindex =");
|
for (i = 0; i < TXPOWER_LEN - 1; i++)
|
DUMP(fp, " %d,",
|
p->txpower_cali.txpower_freq_delta_gainindex[i]);
|
DUMP(fp, " %d\r\n",
|
p->txpower_cali.txpower_freq_delta_gainindex[TXPOWER_LEN - 1]);
|
|
DUMP(fp, "txpower_psat_11b_backoff = %d\r\n",
|
p->txpower_cali.txpower_psat_11b_backoff);
|
DUMP(fp, "txpower_psat_11g_backoff = %d\r\n",
|
p->txpower_cali.txpower_psat_11g_backoff);
|
DUMP(fp, "txpower_psat_11n_backoff = %d\r\n",
|
p->txpower_cali.txpower_psat_11n_backoff);
|
DUMP(fp, "txpower_sar_11b_backoff = %d\r\n",
|
p->txpower_cali.txpower_sar_11b_backoff);
|
DUMP(fp, "txpower_sar_11g_backoff = %d\r\n",
|
p->txpower_cali.txpower_sar_11g_backoff);
|
DUMP(fp, "txpower_sar_11n_backoff = %d\r\n",
|
p->txpower_cali.txpower_sar_11n_backoff);
|
DUMP(fp, "txpower_countrycode_11b_backoff = %d\r\n",
|
p->txpower_cali.txpower_countrycode_11b_backoff);
|
DUMP(fp, "txpower_countrycode_11g_backoff = %d\r\n",
|
p->txpower_cali.txpower_countrycode_11g_backoff);
|
DUMP(fp, "txpower_countrycode_11n_backoff = %d\r\n",
|
p->txpower_cali.txpower_countrycode_11n_backoff);
|
DUMP(fp, "g_txpower_npi_set = %d\r\n",
|
p->txpower_cali.g_txpower_npi_set);
|
DUMP(fp, "txpower_gain_mapping_flag = %d\r\n",
|
p->txpower_cali.txpower_gain_mapping_flag);
|
|
for (j = 0; j < TXPOWER_GAIN_MAP_COUNTER; j++) {
|
if (j < MIN_DOUBLE_DIGIT)
|
DUMP(fp, "txpower_gain_mapping_table%d =", j + 1);
|
else
|
DUMP(fp, "txpower_gain_mapping_table%d =", j + 1);
|
|
for (i = 0; i < TXPOWER_GAIN_MAPPING_LEN - 1; i++)
|
DUMP(fp, " %d,",
|
p->txpower_cali.txpower_gain_mapping_table[j][i]);
|
DUMP(fp, " %d\r\n",
|
p->txpower_cali.txpower_gain_mapping_table[j]
|
[TXPOWER_GAIN_MAPPING_LEN - 1]);
|
}
|
|
DUMP(fp, "txpower_subcarries_compensation_flag = %d\r\n",
|
p->txpower_cali.txpower_subcarries_compensation_flag);
|
|
for (j = 0; j < TXPOWER_SUBCARRIES_COUNTER; j++) {
|
if (j < MIN_DOUBLE_DIGIT)
|
DUMP(fp, "txpower_subcarries_channel%d =", j + 1);
|
else
|
DUMP(fp, "txpower_subcarries_channel%d =", j + 1);
|
|
for (i = 0; i < TXPOWER_SUBCARRIES_LEN - 1; i++)
|
DUMP(fp, " %d,",
|
p->txpower_cali.txpower_subcarries_channel[j][i]);
|
DUMP(fp, " %d\r\n",
|
p->txpower_cali.txpower_subcarries_channel[j]
|
[TXPOWER_SUBCARRIES_LEN - 1]);
|
}
|
|
DUMP(fp, "txpower_psat_trace_value = %d, %d, %d, %d\r\n",
|
p->txpower_cali.txpower_psat_trace_value[0],
|
p->txpower_cali.txpower_psat_trace_value[1],
|
p->txpower_cali.txpower_psat_trace_value[2],
|
p->txpower_cali.txpower_psat_trace_value[3]);
|
|
DUMP(fp, "txpower_reserved = %d, %d, %d, %d\r\n",
|
p->txpower_cali.txpower_reserved[0],
|
p->txpower_cali.txpower_reserved[1],
|
p->txpower_cali.txpower_reserved[2],
|
p->txpower_cali.txpower_reserved[3]);
|
|
DUMP(fp, "c_pad = %d, %d, %d\r\n", p->txpower_cali.c_pad[0],
|
p->txpower_cali.c_pad[1],
|
p->txpower_cali.c_pad[2]);
|
|
|
DUMP(fp, "[SETCTION 7]\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# DPD calibration data\r\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "dpd_cali_channel_num = %d\r\n",
|
p->dpd_cali.dpd_cali_channel_num);
|
DUMP(fp, "dpd_cali_channel = %d, %d, %d\r\n",
|
p->dpd_cali.dpd_cali_channel[0],
|
p->dpd_cali.dpd_cali_channel[1],
|
p->dpd_cali.dpd_cali_channel[2]);
|
DUMP(fp, "dpd_mod_switch_flag = %d\r\n",
|
p->dpd_cali.dpd_mod_switch_flag);
|
DUMP(fp, "dpd_npi_cali_flag = %d\r\n",
|
p->dpd_cali.dpd_npi_cali_flag);
|
|
for (j = 0; j < CHANNEL_DPD_CALI_NUM; j++) {
|
DUMP(fp, "channel%d_dpd_cali_table =", j + 1);
|
for (i = 0; i < CHANNEL_DPD_CALI_LEN - 1; i++)
|
DUMP(fp, " 0x%x,",
|
p->dpd_cali.channel_dpd_cali_table[j][i]);
|
DUMP(fp, " 0x%x\r\n", p->dpd_cali.channel_dpd_cali_table[j]
|
[CHANNEL_DPD_CALI_LEN - 1]);
|
}
|
|
DUMP(fp, "dpd_reserved = 0x%x, 0x%x, 0x%x, 0x%x\r\n",
|
p->dpd_cali.dpd_reserved[0],
|
p->dpd_cali.dpd_reserved[1],
|
p->dpd_cali.dpd_reserved[2],
|
p->dpd_cali.dpd_reserved[3]);
|
|
|
DUMP(fp, "[SETCTION 8]\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# RF parameters data\n");
|
DUMP(fp, OFS_MARK_STRING);
|
|
DUMP(fp, "rf_ctune =");
|
for (i = 0; i < RF_CTUNE_LEN - 1; i++)
|
DUMP(fp, " %d,", p->rf_para.rf_ctune[i]);
|
DUMP(fp, " %d\r\n", p->rf_para.rf_ctune[RF_CTUNE_LEN - 1]);
|
|
DUMP(fp, "rf_reserved = %d, %d, %d, %d\r\n\r\n",
|
p->rf_para.rf_reserved[0],
|
p->rf_para.rf_reserved[1],
|
p->rf_para.rf_reserved[2],
|
p->rf_para.rf_reserved[3]);
|
|
|
DUMP(fp, "[SETCTION 9]\n");
|
DUMP(fp, OFS_MARK_STRING);
|
DUMP(fp, "# TPC Configuration data\n");
|
DUMP(fp, OFS_MARK_STRING);
|
|
DUMP(fp, "tpc_cfg =");
|
for (i = 0; i < TPC_CFG_LEN - 1; i++)
|
DUMP(fp, " 0x%x,", p->tpc_cfg.tpc_cfg[i]);
|
DUMP(fp, " 0x%x\r\n", p->tpc_cfg.tpc_cfg[TPC_CFG_LEN - 1]);
|
|
DUMP(fp, "tpc_reserved = 0x%x, 0x%x, 0x%x, 0x%x\r\n",
|
p->tpc_cfg.tpc_reserved[0],
|
p->tpc_cfg.tpc_reserved[1],
|
p->tpc_cfg.tpc_reserved[2],
|
p->tpc_cfg.tpc_reserved[3]);
|
|
|
filp_close(fp, NULL);
|
set_fs(USER_DS);
|
|
}
|
|
|
void dump_cali_file(struct wifi_cali_t *p)
|
{
|
pr_err("%s() write cali bak file: %s\n", __func__, WIFI_CALI_DUMP_FILE);
|
cali_save_file(WIFI_CALI_DUMP_FILE, p);
|
}
|
