justmarvinn/luckfox-pico-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
58b09aba5d
luckfox-pico-sdk/sysdrv/drv_ko/wifi/ssv6x5x/ssvdevice/ssv_cmd.c
eng33 00aee4108a creat: first commit
2023-08-08 20:36:47 +08:00

2341 lines
90 KiB
C
Raw Blame History

/*
* Copyright (c) 2015 iComm-semi Ltd.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <linux/kernel.h>
#include <linux/version.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
#include <linux/export.h>
#else
#include <linux/module.h>
#endif
#include <linux/platform_device.h>
#include <linux/string.h>
#include <linux/sched.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)
#include <linux/sched/prio.h>
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)
#include <linux/sched/rt.h>
#endif
#include <ssv_conf_parser.h>
#include <ssv6200.h>
#include <hci/hctrl.h>
#include <smac/dev.h>
#include <smac/ssv_skb.h>
#include <hal.h>
#include "ssv_cmd.h"
#include <ssv_version.h>
#include <linux_80211.h>
#define SSV_CMD_PRINTF()
EXPORT_SYMBOL(snprintf_res);
static int ssv_cmd_help(struct ssv_softc *sc, int argc, char *argv[])
{
extern struct ssv_cmd_table cmd_table[];
struct ssv_cmd_table *sc_tbl;
int total_cmd = 0;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
snprintf_res(cmd_data, "Usage:\n");
//Skip 3 help command.
for (sc_tbl = &cmd_table[3]; sc_tbl->cmd; sc_tbl++) {
snprintf_res(cmd_data, "%-20s\t\t%s\n", (char*)sc_tbl->cmd, sc_tbl->usage);
total_cmd++;
}
snprintf_res(cmd_data, "Total CMDs: %x\n\nType cli help [CMD] for more detail command.\n\n", total_cmd);
return 0;
}
static int ssv_cmd_reg(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 addr, value, count;
char *endp;
int s;
int ret = 0;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/* reg [r|w] [address] [value|word-count] */
if ((argc == 4) && (strcmp(argv[1], "w") == 0)) {
/* reg w <address> <word_value> */
addr = simple_strtoul(argv[2], &endp, 16);
value = simple_strtoul(argv[3], &endp, 16);
if (SMAC_REG_WRITE(sc->sh, addr, value)) ;
snprintf_res(cmd_data, " => write [0x%08x]: 0x%08x\n", addr, value);
return 0;
#ifdef CONFIG_USB_EP0_RW_REGISTER
} else if ((argc == 4) && (strcmp(argv[1], "w2") == 0)) {
/* reg w <address> <word_value> */
addr = simple_strtoul(argv[2], &endp, 16);
value = simple_strtoul(argv[3], &endp, 16);
if (SMAC_REG_MCU_WRITE(sc->sh, addr, value)) ;
snprintf_res(cmd_data, " => safe write [0x%08x]: 0x%08x\n", addr, value);
return 0;
#endif
} else if (((argc == 4) || (argc == 3)) && (strcmp(argv[1], "r") == 0)) {
/* reg r <address> <word_count> */
count = (argc ==3 )? 1: simple_strtoul(argv[3], &endp, 10);
addr = simple_strtoul(argv[2], &endp, 16);
snprintf_res(cmd_data, "ADDRESS: 0x%08x\n", addr);
for(s = 0; s < count; s++, addr += 4) {
if (SMAC_REG_READ(sc->sh, addr, &value));
snprintf_res(cmd_data, "%08x ", value);
if (((s+1) & 0x07) == 0){
snprintf_res(cmd_data, "\n");
}
}
snprintf_res(cmd_data, "\n");
return 0;
#ifdef CONFIG_USB_EP0_RW_REGISTER
} else if (((argc == 4) || (argc == 3)) && (strcmp(argv[1], "r2") == 0)) {
/* reg r <address> <word_count> */
count = (argc ==3 )? 1: simple_strtoul(argv[3], &endp, 10);
addr = simple_strtoul(argv[2], &endp, 16);
snprintf_res(cmd_data, "ADDRESS: 0x%08x\n", addr);
for(s = 0; s < count; s++, addr += 4) {
if (SMAC_REG_MCU_READ(sc->sh, addr, &value));
snprintf_res(cmd_data, "%08x ", value);
if (((s+1) & 0x07) == 0){
snprintf_res(cmd_data, "\n");
}
}
snprintf_res(cmd_data, "\n");
return 0;
#endif
} else if (argc == 5 && strcmp(argv[1], "bw")==0) {
u32 addr_list[8],value_list[8];
/* reg bw <address_list> <word_value_list> <word_count> */
addr = simple_strtoul(argv[2], &endp, 16);
value = simple_strtoul(argv[3], &endp, 16);
count = simple_strtoul(argv[4], &endp, 16); //amount of access register
//write same value to sequential registers
for (s=0; s<count; s++) {
addr_list[s] = addr+4*s;
value_list[s] = value;
}
ret = HAL_BURST_WRITE_REG(sc->sh, addr_list, value_list, count);
if (ret >= 0) {
snprintf_res(cmd_data, " ==> write done.\n");
return 0;
} else if (ret == -EOPNOTSUPP) {
snprintf_res(cmd_data, "Does not support this command!\n");
return 0;
}
} else if (argc == 4 && strcmp(argv[1], "br")==0) {
/* reg br <address_list> <word_count> */
u32 addr_list[8],value_list[8];
addr = simple_strtoul(argv[2], &endp, 16);
count = simple_strtoul(argv[3], &endp, 16);
//read from seqential registers
for (s=0; s<count; s++)
addr_list[s] = addr+4*s;
ret = HAL_BURST_READ_REG(sc->sh, addr_list, value_list, count);
if (ret >= 0) {
snprintf_res(cmd_data, "ADDRESS: 0x%x\n", addr);
snprintf_res(cmd_data, "REG-COUNT: %d\n", count);
for (s=0; s<count; s++)
snprintf_res(cmd_data, "addr %x ==> %x\n", addr_list[s], value_list[s]);
return 0;
} else if (ret == -EOPNOTSUPP) {
snprintf_res(cmd_data, "Does not support this command!\n");
return 0;
}
}
else {
snprintf_res(cmd_data, "reg [r|w] [address] [value|word-count]\n\n");
snprintf_res(cmd_data, "reg [br] [address] [word-count]\n\n");
snprintf_res(cmd_data, "reg [bw] [address] [value] [word-count]\n\n");
return 0;
}
return -1;
#else
return 0;
#endif
}
struct ssv6xxx_cfg ssv_cfg;
EXPORT_SYMBOL(ssv_cfg);
#if 0
static int __string2s32(u8 *val_str, void *val)
{
char *endp;
int base=10;
if (val_str[0]=='0' && ((val_str[1]=='x')||(val_str[1]=='X')))
base = 16;
*(int *)val = simple_strtoul(val_str, &endp, base);
return 0;
}
#endif
static int __string2bool(u8 *u8str, void *val, u32 arg)
{
char *endp;
*(u8 *)val = !!simple_strtoul(u8str, &endp, 10);
return 0;
}
static int __string2u32(u8 *u8str, void *val, u32 arg)
{
char *endp;
int base=10;
if (u8str[0]=='0' && ((u8str[1]=='x')||(u8str[1]=='X')))
base = 16;
*(u32 *)val = simple_strtoul(u8str, &endp, base);
return 0;
}
static int __string2s32(u8 *u8str, void *val, u32 arg)
{
char *endp;
int base=10;
*(s32 *)val = simple_strtol(u8str, &endp, base);
return 0;
}
static int __string2flag32(u8 *flag_str, void *flag, u32 arg)
{
u32 *val=(u32 *)flag;
if (arg >= (sizeof(u32)<<3))
return -1;
if (strcmp(flag_str, "on")==0) {
*val |= (1<<arg);
return 0;
}
if (strcmp(flag_str, "off")==0) {
*val &= ~(1<<arg);
return 0;
}
return -1;
}
static int __string2mac(u8 *mac_str, void *val, u32 arg)
{
int s, macaddr[6];
u8 *mac=(u8 *)val;
s = sscanf(mac_str, "%02x:%02x:%02x:%02x:%02x:%02x",
&macaddr[0], &macaddr[1], &macaddr[2],
&macaddr[3], &macaddr[4], &macaddr[5]);
if (s != 6)
return -1;
mac[0] = (u8)macaddr[0], mac[1] = (u8)macaddr[1];
mac[2] = (u8)macaddr[2], mac[3] = (u8)macaddr[3];
mac[4] = (u8)macaddr[4], mac[5] = (u8)macaddr[5];
return 0;
}
static int __string2str(u8 *path, void *val, u32 arg)
{
u8 *temp=(u8 *)val;
sprintf(temp,"%s",path);
return 0;
}
static int __string2configuration(u8 *mac_str, void *val, u32 arg)
{
unsigned int address,value;
int i;
i = sscanf(mac_str, "%08x:%08x", &address, &value);
if (i != 2)
return -1;
for(i=0; i<EXTERNEL_CONFIG_SUPPORT; i++)
{
if(ssv_cfg.configuration[i][0] == 0x0)
{
ssv_cfg.configuration[i][0] = address;
ssv_cfg.configuration[i][1] = value;
return 0;
}
}
return 0;
}
// Note: if there is no default value, set default to NULL, and it will be initialized as zero
struct ssv6xxx_cfg_cmd_table cfg_cmds[] = {
{ "hw_mac", (void *)&ssv_cfg.maddr[0][0], 0, __string2mac , NULL},
{ "hw_mac_2", (void *)&ssv_cfg.maddr[1][0], 0, __string2mac , NULL},
{ "def_chan", (void *)&ssv_cfg.def_chan, 0, __string2u32 , "6"},
{ "hw_cap_ht", (void *)&ssv_cfg.hw_caps, 0, __string2flag32 , "on"},
{ "hw_cap_gf", (void *)&ssv_cfg.hw_caps, 1, __string2flag32 , "off"},
{ "hw_cap_2ghz", (void *)&ssv_cfg.hw_caps, 2, __string2flag32 , "on"},
{ "hw_cap_5ghz", (void *)&ssv_cfg.hw_caps, 3, __string2flag32 , "off"},
{ "hw_cap_security", (void *)&ssv_cfg.hw_caps, 4, __string2flag32 , "on"},
{ "hw_cap_sgi", (void *)&ssv_cfg.hw_caps, 5, __string2flag32 , "on"},
{ "hw_cap_ht40", (void *)&ssv_cfg.hw_caps, 6, __string2flag32 , "on"},
{ "hw_cap_ap", (void *)&ssv_cfg.hw_caps, 7, __string2flag32 , "on"},
{ "hw_cap_p2p", (void *)&ssv_cfg.hw_caps, 8, __string2flag32 , "on"},
{ "hw_cap_ampdu_rx", (void *)&ssv_cfg.hw_caps, 9, __string2flag32 , "on"},
{ "hw_cap_ampdu_tx", (void *)&ssv_cfg.hw_caps, 10, __string2flag32 , "on"},
{ "hw_cap_tdls", (void *)&ssv_cfg.hw_caps, 11, __string2flag32 , "off"},
{ "hw_cap_stbc", (void *)&ssv_cfg.hw_caps, 12, __string2flag32 , "on"},
{ "hw_cap_hci_rx_aggr", (void *)&ssv_cfg.hw_caps, 13, __string2flag32 , "on"},
{ "hw_cap_beacon", (void *)&ssv_cfg.hw_caps, 14, __string2flag32 , "off"},
{ "hw_cap_krack", (void *)&ssv_cfg.hw_caps, 15, __string2flag32 , "off"},
{ "hw_cap_wow", (void *)&ssv_cfg.hw_caps, 16, __string2flag32 , "on"},
{ "hw_cap_bq4", (void *)&ssv_cfg.hw_caps, 17, __string2flag32 , "off"},
{ "hw_cap_hci_tx_aggr", (void *)&ssv_cfg.hw_caps, 18, __string2flag32 , "on"},
{ "hw_cap_report_tx_ack", (void *)&ssv_cfg.hw_caps, 19, __string2flag32 , "off"},
{ "use_wpa2_only", (void *)&ssv_cfg.use_wpa2_only, 0, __string2u32 , NULL},
{ "wifi_tx_gain_level_gn",(void *)&ssv_cfg.wifi_tx_gain_level_gn, 0, __string2u32 , NULL},
{ "wifi_tx_gain_level_b", (void *)&ssv_cfg.wifi_tx_gain_level_b, 0, __string2u32 , NULL},
{ "xtal_clock", (void *)&ssv_cfg.crystal_type, 0, __string2u32 , "24"},
{ "volt_regulator", (void *)&ssv_cfg.volt_regulator, 0, __string2u32 , "1"},
{ "firmware_path", (void *)&ssv_cfg.firmware_path[0], 0, __string2str , NULL},
{ "flash_bin_path", (void *)&ssv_cfg.flash_bin_path[0], 0, __string2str , NULL},
{ "mac_address_path", (void *)&ssv_cfg.mac_address_path[0], 0, __string2str , NULL},
{ "mac_output_path", (void *)&ssv_cfg.mac_output_path[0], 0, __string2str , NULL},
{ "ignore_efuse_mac", (void *)&ssv_cfg.ignore_efuse_mac, 0, __string2u32 , NULL},
{ "efuse_rate_gain_mask", (void *)&ssv_cfg.efuse_rate_gain_mask, 0, __string2u32 , "0x1"},
{ "mac_address_mode", (void *)&ssv_cfg.mac_address_mode, 0, __string2u32 , NULL},
{ "register", NULL, 0, __string2configuration, NULL},
{ "beacon_rssi_minimal", (void *)&ssv_cfg.beacon_rssi_minimal, 0, __string2u32 , NULL},
{ "force_chip_identity", (void *)&ssv_cfg.force_chip_identity, 0, __string2u32 , NULL},
{ "external_firmware_name", (void *)&ssv_cfg.external_firmware_name[0], 0, __string2str, NULL},
{ "ignore_firmware_version", (void *)&ssv_cfg.ignore_firmware_version, 0, __string2u32, NULL},
{ "use_sw_cipher", (void *)&ssv_cfg.use_sw_cipher, 0, __string2u32, NULL},
{ "auto_rate_enable", (void *)&ssv_cfg.auto_rate_enable, 0, __string2u32 , "1"},
// rc_rate_idx_set combine 4 rate idx into u32
// , byte 0 should be for series0, byte 1 for series 1 ....
// default set all 4 series to mcs7
{ "rc_rate_idx_set", (void *)&ssv_cfg.rc_rate_idx_set, 0, __string2u32 , "0x7777"},
// rc_rate_idx_set combine 4 retry set into u32
// , byte 0 should be for series0, byte 1 for series 1 ....
// default only set serires retry to and disable other series.
{ "rc_retry_set", (void *)&ssv_cfg.rc_retry_set, 0, __string2u32 , "0x4444"},
{ "rc_mf", (void *)&ssv_cfg.rc_mf, 0, __string2u32 , NULL},
{ "rc_long_short", (void *)&ssv_cfg.rc_long_short, 0, __string2u32 , NULL},
{ "rc_ht40", (void *)&ssv_cfg.rc_ht40, 0, __string2u32 , NULL},
{ "rc_phy_mode" , (void *)&ssv_cfg.rc_phy_mode, 0, __string2u32 , "3"},
// tx page
{ "tx_page_threshold" , (void *)&ssv_cfg.tx_page_threshold, 0, __string2u32 , "160"},
{ "max_rx_aggr_size", (void *)&ssv_cfg.max_rx_aggr_size, 0, __string2u32 , "64"},
{ "ampdu_pkt_max_size", (void *)&ssv_cfg.ampdu_pkt_max_size, 0, __string2u32 , "23040"},
{ "online_reset", (void *)&ssv_cfg.online_reset, 0, __string2u32 , "0x00f"},
{ "hw_rx_agg_cnt", (void *)&ssv_cfg.hw_rx_agg_cnt, 0, __string2u32 , "3"},
{ "hw_rx_agg_method_3", (void *)&ssv_cfg.hw_rx_agg_method_3, 0, __string2bool , "0"},
{ "hw_rx_agg_timer_reload", (void *)&ssv_cfg.hw_rx_agg_timer_reload, 0, __string2u32 , "20"},
{ "rx_max_recv_cnt", (void *)&ssv_cfg.rx_max_recv_cnt, 0, __string2u32 , "2"},
{ "usb_hw_resource", (void *)&ssv_cfg.usb_hw_resource, 0, __string2u32 , "0"},
{ "tx_stuck_detect", (void *)&ssv_cfg.tx_stuck_detect, 0, __string2bool , "0"},
{ "clk_src_80m", (void *)&ssv_cfg.clk_src_80m, 0, __string2bool , "1"},
{ "rts_thres_len", (void *)&ssv_cfg.rts_thres_len, 0, __string2u32 , "0"},
{ "bk_txq_size", (void *)&ssv_cfg.bk_txq_size, 0, __string2u32 , "6"},
{ "be_txq_size", (void *)&ssv_cfg.be_txq_size, 0, __string2u32 , "10"},
{ "vi_txq_size", (void *)&ssv_cfg.vi_txq_size, 0, __string2u32 , "10"},
{ "vo_txq_size", (void *)&ssv_cfg.vo_txq_size, 0, __string2u32 , "8"},
{ "manage_txq_size", (void *)&ssv_cfg.manage_txq_size, 0, __string2u32 , "8"},
{ "autosgi", (void *)&ssv_cfg.auto_sgi, 0, __string2u32 , "0x1"},
{ "rx_threshold", (void *)&ssv_cfg.rx_threshold, 0, __string2u32 , "256"},
{ "flowctl", (void *)&ssv_cfg.flowctl, 0, __string2bool , "1"},
{ "flowctl_low_threshold",(void *)&ssv_cfg.flowctl_low_threshold, 0, __string2u32 , "96"},
{ "flowctl_high_threshold",(void *)&ssv_cfg.flowctl_high_threshold,0, __string2u32 , "128"},
{ "ctry", (void *)&ssv_cfg.ctry, 0, __string2str , NULL},
{ "external_pa", (void *)&ssv_cfg.external_pa, 0, __string2bool , "0"},
{ "external_lna_2g", (void *)&ssv_cfg.external_lna_2g, 0, __string2u32 , "0x00080d00"},
{ "external_lna_5g", (void *)&ssv_cfg.external_lna_5g, 0, __string2u32 , "0x000c0801"},
{ "auto_edcca", (void *)&ssv_cfg.auto_edcca, 0, __string2bool , "1"},
{ "rx_ip_align", (void *)&ssv_cfg.rx_ip_align, 0, __string2bool , "1"},
{ "rx_ip_csum_off", (void *)&ssv_cfg.rx_ip_csum_off, 0, __string2bool , "1"},
{ "rx_non_preempt_num", (void *)&ssv_cfg.rx_non_preempt_num, 0, __string2u32 , "32"},
{ "directly_ack_ctrl", (void *)&ssv_cfg.directly_ack_ctrl, 0, __string2bool , "1"},
{ "powermode", (void *)&ssv_cfg.powermode, 0, __string2u32 , "4"},
{ "lp_keepalive", (void *)&ssv_cfg.lp_keepalive, 0, __string2u32 , "30000"},
{ "lp_userdtim", (void *)&ssv_cfg.lp_userdtim, 0, __string2u32 , "0"},
{ "lp_wakeuppin", (void *)&ssv_cfg.lp_wakeuppin, 0, __string2u32 , "1"},
{ "lp_ignoredisconnection",(void *)&ssv_cfg.lp_ignoredisconnection,0, __string2u32 , "0"},
{ "lp_dataretx_guard", (void *)&ssv_cfg.lp_dataretx_guard, 0, __string2u32 , "0"},
/* lp_beaconloss_guard must be more than lp_beaconloss_maxcnt
* lp_beaconloss_guard fw default value 20
* lp_beaconloss_maxcnt fw default value 10
*/
{ "lp_beaconloss_guard", (void *)&ssv_cfg.lp_beaconloss_guard, 0, __string2u32 , "0"},
{ "lp_beaconloss_maxcnt", (void *)&ssv_cfg.lp_beaconloss_maxcnt, 0, __string2u32 , "0"},
{ "wmm_follow_vo", (void *)&ssv_cfg.wmm_follow_vo, 0, __string2bool , "1"},
{ "backoff_enable", (void *)&ssv_cfg.backoff_enable, 0, __string2bool , "0"},
{ "backoff_value", (void *)&ssv_cfg.backoff_value, 0, __string2u32 , "0"},
{ "rc_mask", (void *)&ssv_cfg.rc_mask , 0, __string2u32 , "0xFED"},
{ "scan_hc_period", (void *)&ssv_cfg.scan_hc_period, 0, __string2u32 , "100"},
{ "scan_oc_period", (void *)&ssv_cfg.scan_oc_period, 0, __string2u32 , "50"},
{ "fw_reset", (void *)&ssv_cfg.fw_reset, 0, __string2bool , "1"},
{ "fw_status_idle_cnt", (void *)&ssv_cfg.fw_status_idle_cnt, 0, __string2u32 , "20"},
{ "fw_tx_waitnum", (void *)&ssv_cfg.fw_tx_waitnum, 0, __string2u32 , "0"},
{ "fw_tx_chkhwqnum", (void *)&ssv_cfg.fw_tx_chkhwqnum, 0, __string2u32 , "0"},
{ "fw_tx_duration", (void *)&ssv_cfg.fw_tx_duration, 0, __string2u32 , "0"},
{ "fw_tx_duration_period",(void *)&ssv_cfg.fw_tx_duration_period, 0, __string2u32 , "2"},
{ "ampdu_rx_size_cap", (void *)&ssv_cfg.ampdu_rx_size_cap, 0, __string2u32 , "1"},
{ "sleep_gpio_ctrl", (void *)&ssv_cfg.sleep_gpio_ctrl, 0, __string2u32 , "0x00028018"},
{ "dormant_gpio_ctrl", (void *)&ssv_cfg.dormant_gpio_ctrl, 0, __string2u32 , "0x0002b718"},
{ "hci_trigger_en", (void *)&ssv_cfg.hci_trigger_en, 0, __string2u32 , "0"},
{ "hci_trigger_qlen", (void *)&ssv_cfg.hci_trigger_qlen, 0, __string2u32 , "10"},
{ "hci_trigger_pkt_size", (void *)&ssv_cfg.hci_trigger_pkt_size, 0, __string2u32 , "80"},
{ "hci_task_timeout", (void *)&ssv_cfg.hci_task_timeout, 0, __string2u32 , "3"},
{ "disable_fw_thermal", (void *)&ssv_cfg.disable_fw_thermal, 0, __string2u32 , "0"},
{ "rf_band_gain_offset", (void *)&ssv_cfg.rf_band_gain_offset, 0, __string2s32 , "0"},
{ "rf_band5100_gain_offset", (void *)&ssv_cfg.rf_band5100_gain_offset, 0, __string2s32 , "0"},
{ "rf_band5500_gain_offset", (void *)&ssv_cfg.rf_band5500_gain_offset, 0, __string2s32 , "0"},
{ "rf_band5700_gain_offset", (void *)&ssv_cfg.rf_band5700_gain_offset, 0, __string2s32 , "0"},
{ "rf_band5900_gain_offset", (void *)&ssv_cfg.rf_band5900_gain_offset, 0, __string2s32 , "0"},
{ "rf_b_rate_offset", (void *)&ssv_cfg.rf_b_rate_offset, 0, __string2s32 , "0"},
{ "rf_g_rate_offset", (void *)&ssv_cfg.rf_g_rate_offset, 0, __string2s32 , "0"},
{ "rf_ht20_rate_offset", (void *)&ssv_cfg.rf_ht20_rate_offset, 0, __string2s32 , "0"},
{ "rf_ht40_rate_offset", (void *)&ssv_cfg.rf_ht40_rate_offset, 0, __string2s32 , "0"},
{ "padpd", (void *)&ssv_cfg.padpd, 0, __string2u32 , "7"},
{ "disable_greentx", (void *)&ssv_cfg.disable_greentx, 0, __string2bool , "0"},
{ "disable_cci", (void *)&ssv_cfg.disable_cci, 0, __string2bool , "0"},
#ifdef CONFIG_ENABLE_HOST_THERMAL
{ "disable_host_thermal", (void *)&ssv_cfg.disable_host_thermal, 0, __string2u32 , "0"},
{ "temp_config_table", (void *)&ssv_cfg.temp_compensation_table[0], 0, __string2str, NULL},
{ "host_thermal_debug", (void *)&ssv_cfg.host_thermal_debug, 0, __string2u32 , "0"},
#endif
{ "ap_force_tim_always_high", (void *)&ssv_cfg.ap_force_tim_always_high, 0, __string2u32 , "0"},
{ NULL, NULL, 0, NULL, NULL},
};
EXPORT_SYMBOL(cfg_cmds);
static int ssv_cmd_cfg(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
int s;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if ((argc == 2) && (strcmp(argv[1], "reset") == 0)) {
memset(&ssv_cfg, 0, sizeof(ssv_cfg));
return 0;
} else if ((argc == 2) && (strcmp(argv[1], "show") == 0)) {
snprintf_res(cmd_data, ">> ssv6xxx config:\n");
snprintf_res(cmd_data, " hw_caps = 0x%08x\n", ssv_cfg.hw_caps);
snprintf_res(cmd_data, " def_chan = %d\n", ssv_cfg.def_chan);
snprintf_res(cmd_data, " wifi_tx_gain_level_gn = %d\n", ssv_cfg.wifi_tx_gain_level_gn);
snprintf_res(cmd_data, " wifi_tx_gain_level_b = %d\n", ssv_cfg.wifi_tx_gain_level_b);
snprintf_res(cmd_data, " sta-mac = %02x:%02x:%02x:%02x:%02x:%02x",
ssv_cfg.maddr[0][0], ssv_cfg.maddr[0][1], ssv_cfg.maddr[0][2],
ssv_cfg.maddr[0][3], ssv_cfg.maddr[0][4], ssv_cfg.maddr[0][5]);
snprintf_res(cmd_data, "\n");
return 0;
}
if (argc != 4)
return -1;
for(s = 0; cfg_cmds[s].cfg_cmd != NULL; s++) {
if (strcmp(cfg_cmds[s].cfg_cmd, argv[1]) == 0) {
cfg_cmds[s].translate_func(argv[3],
cfg_cmds[s].var, cfg_cmds[s].arg);
snprintf_res(cmd_data, "");
return 0;
}
}
return -1;
#else
return 0;
#endif
}
// snprintf to result buffer
void snprintf_res(struct ssv_cmd_data *cmd_data, const char *fmt, ... )
{
char *buf_head;
int buf_left;
va_list args;
char *ssv6xxx_result_buf = cmd_data->ssv6xxx_result_buf;
ssv6xxx_result_buf = cmd_data->ssv6xxx_result_buf;
// buf end reached
if (cmd_data->rsbuf_len >= (cmd_data->rsbuf_size -1))
return;
buf_head = ssv6xxx_result_buf + cmd_data->rsbuf_len;
buf_left = cmd_data->rsbuf_size - cmd_data->rsbuf_len;
va_start(args, fmt);
cmd_data->rsbuf_len += vsnprintf(buf_head, buf_left, fmt, args);
va_end(args);
// No need for protection here. If vsnprint use more
// than buf_left. It will put 0x0 at last byte automatically
// when overflow and stop copy,
}
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static void _dump_sta_info (struct ssv_softc *sc,
struct ssv_vif_info *vif_info,
struct ssv_sta_info *sta_info,
int sta_idx)
{
struct ssv_sta_priv_data *priv_sta = (struct ssv_sta_priv_data *)sta_info->sta->drv_priv;/* sta_info is already protected by ssv_cmd_submit(). */
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if ((sta_info->s_flags & STA_FLAG_VALID) == 0) {/* sta_info is already protected by ssv_cmd_submit(). */
snprintf_res(cmd_data,
" Station %d: %d is not valid\n",
sta_idx, priv_sta->sta_idx);
} else {
snprintf_res(cmd_data,
" Station %d: %d\n"
" Address: %02X:%02X:%02X:%02X:%02X:%02X\n"
" WISD: %d\n"
" AID: %d\n",
sta_idx, priv_sta->sta_idx,
sta_info->sta->addr[0], sta_info->sta->addr[1], sta_info->sta->addr[2],
sta_info->sta->addr[3], sta_info->sta->addr[4], sta_info->sta->addr[5],
sta_info->hw_wsid, sta_info->aid);/* sta_info is already protected by ssv_cmd_submit(). */
snprintf_res(cmd_data,
" SIGNAL: %d\n",
-(sta_info->signal));
}
}
void ssv6xxx_dump_sta_info (struct ssv_softc *sc)
{
int j, sta_idx = 0;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
snprintf_res(cmd_data, " >>>> bcast queue len[%d]\n", sc->bcast_txq.cur_qsize);
for (j = 0; j < SSV6200_MAX_VIF; j++) {
struct ieee80211_vif *vif = sc->vif_info[j].vif;
struct ssv_vif_priv_data *priv_vif;
struct ssv_sta_priv_data *sta_priv_iter;
if (vif == NULL){
snprintf_res(cmd_data, " VIF: %d is not used.\n", j);
continue;
}
snprintf_res(cmd_data,
" VIF: %d - [%02X:%02X:%02X:%02X:%02X:%02X] type[%d] p2p[%d] p2p_status[%d] channel[%d]\n", j,
vif->addr[0], vif->addr[1], vif->addr[2],
vif->addr[3], vif->addr[4], vif->addr[5], vif->type, vif->p2p, sc->p2p_status, sc->hw_chan);
priv_vif = (struct ssv_vif_priv_data *)(vif->drv_priv);
snprintf_res(cmd_data,
" - sta asleep mask[%08X]\n", priv_vif->sta_asleep_mask);
list_for_each_entry(sta_priv_iter, &priv_vif->sta_list, list){
if ((sc->sta_info[sta_priv_iter->sta_idx].s_flags & STA_FLAG_VALID) == 0) {/* sta_info is already protected by ssv_cmd_submit(). */
snprintf_res(cmd_data, " STA: %d is not valid.\n", sta_idx);
continue;
}
_dump_sta_info(sc, &sc->vif_info[priv_vif->vif_idx],
&sc->sta_info[sta_priv_iter->sta_idx], sta_idx);
sta_idx++;
}
}
} // ssv6xxx_dump_sta_info
#endif
static int ssv_cmd_sta(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
if ((argc >= 2) && (strcmp(argv[1], "show") == 0))
ssv6xxx_dump_sta_info(sc);
else
snprintf_res(&sc->cmd_data, "sta show\n\n");
#endif
return 0;
}
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static void ssv_cmd_get_chip_id(struct ssv_softc *sc, char *chip_id)
{
HAL_GET_CHIP_ID(sc->sh);
strcpy(chip_id, sc->sh->chip_id);
}
#endif
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static bool ssv6xxx_dump_cfg(struct ssv_hw *sh)
{
struct ssv_cmd_data *cmd_data = &sh->sc->cmd_data;
snprintf_res(cmd_data, "\n>> Current Configuration:\n\n");
snprintf_res(cmd_data, " hw_mac: %pM\n", sh->cfg.maddr[0]);
snprintf_res(cmd_data, " hw_mac2: %pM\n", sh->cfg.maddr[1]);
snprintf_res(cmd_data, " def_chan: %d\n", sh->cfg.def_chan);
snprintf_res(cmd_data, " hw_caps: 0x%x\n", sh->cfg.hw_caps);
snprintf_res(cmd_data, " use_wpa2_only: %d\n", sh->cfg.use_wpa2_only);
snprintf_res(cmd_data, " wifi_tx_gain_level_gn: %d\n", sh->cfg.wifi_tx_gain_level_gn);
snprintf_res(cmd_data, " wifi_tx_gain_level_b: %d\n", sh->cfg.wifi_tx_gain_level_b);
snprintf_res(cmd_data, " xtal_clock: %d\n", sh->cfg.crystal_type);
snprintf_res(cmd_data, " volt_regulator: %d\n", sh->cfg.volt_regulator);
snprintf_res(cmd_data, " firmware_path: %s\n", sh->cfg.firmware_path);
snprintf_res(cmd_data, " mac_address_path: %s\n", sh->cfg.mac_address_path);
snprintf_res(cmd_data, " mac_output_path: %s\n", sh->cfg.mac_output_path);
snprintf_res(cmd_data, " ignore_efuse_mac: %d\n", sh->cfg.ignore_efuse_mac);
snprintf_res(cmd_data, " mac_address_mode: %d\n", sh->cfg.mac_address_mode);
snprintf_res(cmd_data, " beacon_rssi_minimal: %d\n", sh->cfg.beacon_rssi_minimal);
snprintf_res(cmd_data, " force_chip_identity: 0x%x\n", sh->cfg.force_chip_identity);
snprintf_res(cmd_data, " external_firmware_name: %s\n", sh->cfg.external_firmware_name);
snprintf_res(cmd_data, " ignore_firmware_version: %d\n", sh->cfg.ignore_firmware_version);
snprintf_res(cmd_data, " auto_rate_enable: %d\n", sh->cfg.auto_rate_enable);
snprintf_res(cmd_data, " rc_rate_idx_set: 0x%x\n", sh->cfg.rc_rate_idx_set);
snprintf_res(cmd_data, " rc_retry_set: 0x%x\n", sh->cfg.rc_retry_set);
snprintf_res(cmd_data, " rc_mf: %d\n", sh->cfg.rc_mf);
snprintf_res(cmd_data, " rc_long_short: %d\n", sh->cfg.rc_long_short);
snprintf_res(cmd_data, " rc_ht40: %d\n", sh->cfg.rc_ht40);
snprintf_res(cmd_data, " rc_phy_mode: %d\n", sh->cfg.rc_phy_mode);
snprintf_res(cmd_data, " hwqlimit(BK queue): %d\n", sh->cfg.bk_txq_size);
snprintf_res(cmd_data, " hwqlimit(BE queue): %d\n", sh->cfg.be_txq_size);
snprintf_res(cmd_data, " hwqlimit(VI queue): %d\n", sh->cfg.vi_txq_size);
snprintf_res(cmd_data, " hwqlimit(VO queue): %d\n", sh->cfg.vo_txq_size);
snprintf_res(cmd_data, " hwqlimit(MNG queue): %d\n", sh->cfg.manage_txq_size);
snprintf_res(cmd_data, "\n\n");
return 0;
}
#endif
//dump [wsid|decision|phy-info|phy-reg|rf-reg|cfg]
static int ssv_cmd_dump(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if (argc != 2) {
snprintf_res(cmd_data, "dump [wsid|decision|phy-reg|rf-reg|cfg]\n");
return 0;
}
if (strcmp(argv[1], "wsid") == 0) {
return SSV_DUMP_WSID(sc->sh);
}
if (strcmp(argv[1], "decision") == 0 ) {
return SSV_DUMP_DECISION(sc->sh);
}
if (strcmp(argv[1], "phy-reg") == 0) {
return HAL_DUMP_PHY_REG(sc->sh);
}
if (strcmp(argv[1], "rf-reg") == 0) {
return HAL_DUMP_RF_REG(sc->sh);
}
if (strcmp(argv[1], "cfg") == 0) {
return ssv6xxx_dump_cfg(sc->sh);
}
snprintf_res(cmd_data, "dump [wsid|decision|phy-reg|rf-reg|cfg]\n");
#endif
return 0;
}
static int ssv_cmd_irq(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
char *endp;
u32 irq_sts;
struct ssv6xxx_hci_info *hci = &sc->sh->hci;
struct ssv6xxx_hwif_ops *ifops = hci->if_ops;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/* irq [set|get] [mask|enable|disable|status] */
if ((argc >= 3) && (strcmp(argv[1], "set") == 0)) {
if ((strcmp(argv[2], "mask") == 0) && (argc == 4)) {
irq_sts = simple_strtoul(argv[3], &endp, 16);
if (!sc->sh->hci.if_ops->irq_setmask) {
snprintf_res(cmd_data, "The interface doesn't provide irq_setmask operation.\n");
return 0;
}
ifops->irq_setmask(hci->dev, irq_sts);
snprintf_res(cmd_data, "set sdio irq mask to 0x%08x\n", irq_sts);
return 0;
}
if (strcmp(argv[2], "enable") == 0) {
if (!ifops->irq_enable) {
snprintf_res(cmd_data, "The interface doesn't provide irq_enable operation.\n");
return 0;
}
ifops->irq_enable(hci->dev);
snprintf_res(cmd_data, "enable sdio irq.\n");
return 0;
}
if (strcmp(argv[2], "disable") == 0) {
if (!ifops->irq_disable) {
snprintf_res(cmd_data, "The interface doesn't provide irq_disable operation.\n");
return 0;
}
ifops->irq_disable(hci->dev, false);
snprintf_res(cmd_data, "disable sdio irq.\n");
return 0;
}
return -1;
} else if ( (argc == 3) && (strcmp(argv[1], "get") == 0)) {
if (strcmp(argv[2], "mask") == 0) {
if (!ifops->irq_getmask) {
snprintf_res(cmd_data, "The interface doesn't provide irq_getmask operation.\n");
return 0;
}
ifops->irq_getmask(hci->dev, &irq_sts);
snprintf_res(cmd_data, "sdio irq mask: 0x%08x, int_mask=0x%08x\n", irq_sts,
hci->hci_ctrl->int_mask);
return 0;
}
if (strcmp(argv[2], "status") == 0) {
if (!ifops->irq_getstatus) {
snprintf_res(cmd_data, "The interface doesn't provide irq_getstatus operation.\n");
return 0;
}
ifops->irq_getstatus(hci->dev, &irq_sts);
snprintf_res(cmd_data, "sdio irq status: 0x%08x\n", irq_sts);
return 0;
}
return -1;
} else {
snprintf_res(cmd_data, "irq [set|get] [mask|enable|disable|status]\n");
}
#endif
return 0;
}
//mac [security|wsid|rxq] [show]
//mac [set|get] [rate] [auto|idx]
//mac [rx|tx] [eable|disable]
static int ssv_cmd_mac(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
char *endp;
int i;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
#if 0
if ((argc == 3) && (!strcmp(argv[1], "wsid")) && (!strcmp(argv[2], "show"))) {
u32 s;
}
return 0;
} else
#endif
if ((argc == 3) && (!strcmp(argv[1], "rx"))){
if (!strcmp(argv[2], "enable")){
sc->dbg_rx_frame = 1;
} else {
sc->dbg_rx_frame = 0;
}
snprintf_res(cmd_data, " dbg_rx_frame %d\n", sc->dbg_rx_frame);
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "tx"))){
if(!strcmp(argv[2], "enable")){
sc->dbg_tx_frame = 1;
} else {
sc->dbg_tx_frame = 0;
}
snprintf_res(cmd_data, " dbg_tx_frame %d\n", sc->dbg_tx_frame);
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "rxq")) && (!strcmp(argv[2], "show"))) {
snprintf_res(cmd_data, " rx frame %d\n", sc->rx.rx_count);
snprintf_res(cmd_data, " rx data frame %d\n", sc->rx.rx_data_count);
snprintf_res(cmd_data, " rx mgmt frame %d\n", sc->rx.rx_mgmt_count);
snprintf_res(cmd_data, " rx bcn frame %d\n", sc->rx.rx_bcn_count);
snprintf_res(cmd_data, " rx probereq frame %d\n", sc->rx.rx_probereq_count);
snprintf_res(cmd_data, " rx proberesp frame %d\n", sc->rx.rx_proberesp_count);
snprintf_res(cmd_data, " rx assoc_req frame %d\n", sc->rx.rx_assoc_req_count);
snprintf_res(cmd_data, " rx assoc_resp frame %d\n", sc->rx.rx_assoc_resp_count);
snprintf_res(cmd_data, " rx auth frame %d\n", sc->rx.rx_auth_count);
snprintf_res(cmd_data, " rx disassoc frame %d\n", sc->rx.rx_disassoc_count);
snprintf_res(cmd_data, " rx deauth frame %d\n", sc->rx.rx_deauth_count);
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "txq")) && (!strcmp(argv[2], "show"))) {
snprintf_res(cmd_data, " tx frame %d\n", sc->tx.tx_count);
snprintf_res(cmd_data, " tx data frame %d\n", sc->tx.data_count);
snprintf_res(cmd_data, " tx mgmt frame %d\n", sc->tx.mgmt_count);
snprintf_res(cmd_data, " tx auth frame %d\n", sc->tx.auth_count);
snprintf_res(cmd_data, " tx deauth frame %d\n", sc->tx.deauth_count);
snprintf_res(cmd_data, " tx assocreq frame %d\n", sc->tx.assoc_req_count);
snprintf_res(cmd_data, " tx assocresp frame %d\n", sc->tx.assoc_resp_count);
snprintf_res(cmd_data, " tx probereq frame %d\n", sc->tx.probe_req_count);
snprintf_res(cmd_data, " tx proberesp frame %d\n", sc->tx.probe_resp_count);
return 0;
}
else if ((argc == 4) && (!strcmp(argv[1], "set")) && (!strcmp(argv[2], "rate"))) {
if (strcmp(argv[3], "auto") == 0) {
sc->sc_flags &= ~SC_OP_FIXED_RATE;
return 0;
}
i = simple_strtoul(argv[3], &endp, 10);
if ( i < 0 || i > 38) {
snprintf_res(cmd_data, " Invalid rat index !!\n");
return -1;
}
sc->max_rate_idx = i;
sc->sc_flags |= SC_OP_FIXED_RATE;
snprintf_res(cmd_data, " Set rate to index %d\n", i);
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "get")) && (!strcmp(argv[2], "rate"))) {
if (sc->sc_flags & SC_OP_FIXED_RATE)
snprintf_res(cmd_data, " Current Rate Index: %d\n", sc->max_rate_idx);
else
snprintf_res(cmd_data, " Current Rate Index: auto\n");
return 0;
} else if ((argc == 2) && (!strcmp(argv[1], "setting"))){
snprintf_res(cmd_data, "tx_cfg threshold:\n");
snprintf_res(cmd_data, "\t tx_id_threshold %d tx_cfg tx_lowthreshold_id_trigger %d tx_page_threshold %d\n",
sc->sh->tx_info.tx_id_threshold, sc->sh->tx_info.tx_lowthreshold_id_trigger,
sc->sh->tx_info.tx_page_threshold);
snprintf_res(cmd_data, "rx_cfg threshold:\n");
snprintf_res(cmd_data, "\t rx_id_threshold %d rx_page_threshold %d\n",
sc->sh->rx_info.rx_id_threshold, sc->sh->rx_info.rx_page_threshold);
snprintf_res(cmd_data, "tx page available %d\n" , sc->sh->tx_page_available);
snprintf_res(cmd_data, "total tx+rx page %d\n" , sc->sh->total_tx_rx_page);
//snprintf_res(cmd_data, "max aggr size %d page %d\n" , SSV_GET_MAX_AMPDU_SIZE(sc->sh),
// SSV_GET_MAX_AMPDU_SIZE(sc->sh) >> HW_MMU_PAGE_SHIFT);
} else {
snprintf_res(cmd_data, "mac [rxq] [show]\n");
snprintf_res(cmd_data, "mac [set|get] [rate] [auto|idx]\n");
snprintf_res(cmd_data, "mac [rx|tx] [eable|disable]\n");
snprintf_res(cmd_data, "mac [setting]\n");
}
#endif
return 0;
}
//hci [txq|rxq] [show]
static int ssv_cmd_hci(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv6xxx_hci_ctrl *hci_ctrl = sc->sh->hci.hci_ctrl;
struct ssv_sw_txq *txq;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
int s = 0;
if ((argc == 3) && (!strcmp(argv[1], "txq")) && (!strcmp(argv[2], "show"))) {
for(s = 0; s < SSV_SW_TXQ_NUM; s++) {
txq = &hci_ctrl->sw_txq[s];
snprintf_res(cmd_data, ">> txq[%d] pause %d ", txq->txq_no, txq->paused);
snprintf_res(cmd_data, "cur_qsize=%d\n", skb_queue_len(&txq->qhead));
snprintf_res(cmd_data, " Total %d frame sent\n", txq->tx_pkt);
}
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "hwq")) && (!strcmp(argv[2], "show"))){
snprintf_res(cmd_data, ">> HW Queue mask: 0x%02x\n", hci_ctrl->hw_txq_mask);
snprintf_res(cmd_data, ">> EDCA0: %s\n", ((hci_ctrl->hw_txq_mask & TXQ_EDCA_0) ? "stop" : "start"));
snprintf_res(cmd_data, ">> EDCA1: %s\n", ((hci_ctrl->hw_txq_mask & TXQ_EDCA_1) ? "stop" : "start"));
snprintf_res(cmd_data, ">> EDCA2: %s\n", ((hci_ctrl->hw_txq_mask & TXQ_EDCA_2) ? "stop" : "start"));
snprintf_res(cmd_data, ">> EDCA3: %s\n", ((hci_ctrl->hw_txq_mask & TXQ_EDCA_3) ? "stop" : "start"));
snprintf_res(cmd_data, ">> MGMTQ: %s\n", ((hci_ctrl->hw_txq_mask & TXQ_MGMT) ? "stop" : "start"));
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "rxq")) && (!strcmp(argv[2], "show"))){
snprintf_res(cmd_data, ">> rx_packet = %d, rx_isr_count = %d\n",
hci_ctrl->rx_pkt, hci_ctrl->rx_isr_cnt);
return 0;
}
else
{
snprintf_res(cmd_data, "hci [txq|rxq] [show]\n\n");
return 0;
}
#endif
return 0;
}
static int ssv_cmd_hwq(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/*
MBOX HWID OWNER in queue Out queue
0 MCU 16 16
1 HCI 8 16
2 Reserved X X
3 Security TX 4 16
4 MRX 16 X
5 MIC TX 4 4
6 MTX EDCA0 4 8
7 MTX EDCA1 4 16
8 MTX EDCA2 4 16
9 MTX EDCA3 4 16
10 MTX MNG 4 8
11 Security RX 4 16
12 MIC RX 4 4
13 Reserved X X
14 Reserved X X
15 Trash can X 32
#define GET_FF0_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x0000001f ) >> 0)
#define GET_FF1_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x000001e0 ) >> 5)
#define GET_FF3_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x00003800 ) >> 11)
#define GET_FF5_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x000e0000 ) >> 17)
#define GET_FF6_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x00700000 ) >> 20)
#define GET_FF7_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x03800000 ) >> 23)
#define GET_FF8_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0x1c000000 ) >> 26)
#define GET_FF9_CNT (((REG32(ADR_RD_IN_FFCNT1)) & 0xe0000000 ) >> 29)
#define GET_FF10_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x00000007 ) >> 0)
#define GET_FF11_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x00000038 ) >> 3)
#define GET_FF12_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x000001c0 ) >> 6)
#define GET_FF13_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x00000600 ) >> 9)
#define GET_FF14_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x00001800 ) >> 11)
#define GET_FF15_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x00006000 ) >> 13)
#define GET_FF4_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x000f8000 ) >> 15)
#define GET_FF2_CNT (((REG32(ADR_RD_IN_FFCNT2)) & 0x00700000 ) >> 20)
//==============================================================================================
printf("\n[TAG] MCU - HCI - SEC - RX - MIC - TX0 - TX1 - TX2 - TX3 - TX4 - SEC - MIC - TSH\n");
printf("OUTPUT %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d\n",
GET_FFO0_CNT, GET_FFO1_CNT, GET_FFO3_CNT, GET_FFO4_CNT, GET_FFO5_CNT, GET_FFO6_CNT,
GET_FFO7_CNT, GET_FFO8_CNT, GET_FFO9_CNT, GET_FFO10_CNT, GET_FFO11_CNT, GET_FFO12_CNT, GET_FFO15_CNT);
printf("INPUT %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d\n",
GET_FF0_CNT, GET_FF1_CNT, GET_FF3_CNT, GET_FF4_CNT, GET_FF5_CNT, GET_FF6_CNT,
GET_FF7_CNT, GET_FF8_CNT, GET_FF9_CNT, GET_FF10_CNT, GET_FF11_CNT, GET_FF12_CNT, GET_FF15_CNT);
printf("TX[%d]RX[%d]AVA[%d]\n",GET_TX_ID_ALC_LEN,GET_RX_ID_ALC_LEN,GET_AVA_TAG);
*/
u32 value, value1, value2;
u32 tx_len = 0, rx_len = 0, ava_status = 0;
u32 id0 = 0, id1 = 0, id2 = 0, id3 = 0;
//-----------------------------
SSV_READ_FFOUT_CNT(sc->sh, &value, &value1, &value2);
snprintf_res(cmd_data, "\n[TAG] MCU - HCI - SEC - RX - MIC - TX0 - TX1 - TX2 - TX3 - TX4 - SEC - MIC - TSH\n");
snprintf_res(cmd_data, "OUTPUT %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d\n",
SSV_GET_FFOUT_CNT(sc->sh, value, M_ENG_CPU),
SSV_GET_FFOUT_CNT(sc->sh, value, M_ENG_HWHCI),
SSV_GET_FFOUT_CNT(sc->sh, value, M_ENG_ENCRYPT),
SSV_GET_FFOUT_CNT(sc->sh, value, M_ENG_MACRX),
SSV_GET_FFOUT_CNT(sc->sh, value, M_ENG_MIC),
SSV_GET_FFOUT_CNT(sc->sh, value1, M_ENG_TX_EDCA0),
SSV_GET_FFOUT_CNT(sc->sh, value1, M_ENG_TX_EDCA1),
SSV_GET_FFOUT_CNT(sc->sh, value1, M_ENG_TX_EDCA2),
SSV_GET_FFOUT_CNT(sc->sh, value1, M_ENG_TX_EDCA3),
SSV_GET_FFOUT_CNT(sc->sh, value1, M_ENG_TX_MNG),
SSV_GET_FFOUT_CNT(sc->sh, value1, M_ENG_ENCRYPT_SEC),
SSV_GET_FFOUT_CNT(sc->sh, value2, M_ENG_MIC_SEC),
SSV_GET_FFOUT_CNT(sc->sh, value2, M_ENG_TRASH_CAN));
//-----------------------------
SSV_READ_IN_FFCNT(sc->sh, &value, &value1);
snprintf_res(cmd_data, "INPUT %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d\n",
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_CPU),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_HWHCI),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_ENCRYPT),
SSV_GET_IN_FFCNT(sc->sh, value1, M_ENG_MACRX),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_MIC),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_TX_EDCA0),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_TX_EDCA1),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_TX_EDCA2),
SSV_GET_IN_FFCNT(sc->sh, value, M_ENG_TX_EDCA3),
SSV_GET_IN_FFCNT(sc->sh, value1, M_ENG_TX_MNG),
SSV_GET_IN_FFCNT(sc->sh, value1, M_ENG_ENCRYPT_SEC),
SSV_GET_IN_FFCNT(sc->sh, value1, M_ENG_MIC_SEC),
SSV_GET_IN_FFCNT(sc->sh, value1, M_ENG_TRASH_CAN));
//-----------------------------
SSV_READ_ID_LEN_THRESHOLD(sc->sh, &tx_len, &rx_len);
SSV_READ_TAG_STATUS(sc->sh, &ava_status);
snprintf_res(cmd_data, "TX[%d]RX[%d]AVA[%d]\n", tx_len, rx_len, ava_status);
SSV_READ_ALLID_MAP(sc->sh, &id0, &id1, &id2, &id3);
snprintf_res(cmd_data, "ALLID_MAP [%08x %08x %08x %08x]\n", id3, id2, id1, id0);
SSV_READ_TXID_MAP(sc->sh, &id0, &id1, &id2, &id3);
snprintf_res(cmd_data, "TXID_MAP [%08x %08x %08x %08x]\n", id3, id2, id1, id0);
SSV_READ_RXID_MAP(sc->sh, &id0, &id1, &id2, &id3);
snprintf_res(cmd_data, "RXID_MAP [%08x %08x %08x %08x]\n", id3, id2, id1, id0);
#endif
return 0;
}
static int ssv_cmd_mib(struct ssv_softc *sc, int argc, char *argv[])
{
SSV_CMD_MIB(sc, argc, argv);
return 0;
}
static int ssv_cmd_power_saving(struct ssv_softc *sc, int argc, char *argv[])
{
SSV_CMD_POWER_SAVING(sc, argc, argv);
return 0;
}
static int ssv_cmd_sdio(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 addr, value;
char *endp;
int ret=0;
struct ssv6xxx_hci_info *hci = &sc->sh->hci;
struct ssv6xxx_hwif_ops *ifops = hci->if_ops;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/**
* (1) sdio reg r [sdio_addr]
* (2) sdio reg w [sdio_addr] [value]
*/
if ((argc == 4) && (!strcmp(argv[1], "reg")) && (!strcmp(argv[2], "r"))) {
addr = simple_strtoul(argv[3], &endp, 16);
if (!ifops->cmd52_read){
snprintf_res(cmd_data, "The interface doesn't provide cmd52 read\n");
return 0;
}
ret = ifops->cmd52_read(hci->dev, addr, &value);
if (ret >= 0) {
snprintf_res(cmd_data, " ==> %x\n", value);
return 0;
}
} else if ((argc ==5) && (!strcmp(argv[1], "reg")) && (!strcmp(argv[2], "w"))){
addr = simple_strtoul(argv[3], &endp, 16);
value = simple_strtoul(argv[4], &endp, 16);
if (!ifops->cmd52_write){
snprintf_res(cmd_data, "The interface doesn't provide cmd52 write\n");
return 0;
}
ret = ifops->cmd52_write(hci->dev, addr, value);
if (ret >= 0) {
snprintf_res(cmd_data, " ==> write done.\n");
return 0;
}
}
snprintf_res(cmd_data, "sdio cmd52 fail: %d\n", ret);
#endif
return 0;
}
#define CLI_VERSION "0.09"
static int ssv_cmd_version (struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 regval;
char chip_id[24] = "";
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
//CLI version
snprintf_res(cmd_data, "CLI version: %s \n", CLI_VERSION);
//CHIP TAG
snprintf_res(cmd_data, "CHIP TAG: %llx \n", sc->sh->chip_tag);
//CHIP ID
ssv_cmd_get_chip_id(sc, chip_id);
snprintf_res(cmd_data, "CHIP ID: %s \n", chip_id);
snprintf_res(cmd_data, "# current Software mac version: %d\n", ssv_root_version);
snprintf_res(cmd_data, "COMPILER DATE %s \n", COMPILERDATE);
SSV_GET_FW_VERSION(sc->sh, &regval);
snprintf_res(cmd_data, "Firmware image version: %d\n", regval);
#else
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
snprintf_res(cmd_data, "# current Software mac version: %d\n", ssv_root_version);
#endif
return 0;
}
static int ssv_cmd_tool(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 addr, value, count, len;
char *endp;
int s, retval;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/* tool [r|w] [address] [value|word-count] */
if ((argc == 4) && (strcmp(argv[1], "w") == 0)) {
/* reg w <address> <word_value> */
addr = simple_strtoul(argv[2], &endp, 16);
value = simple_strtoul(argv[3], &endp, 16);
if (SMAC_REG_WRITE(sc->sh, addr, value)) ;
snprintf_res(cmd_data, "ok");
return 0;
}
if (( (argc == 4) || (argc == 3)) && (strcmp(argv[1], "r") == 0)) {
/* reg r <address> <word_count> */
count = (argc==3)? 1: simple_strtoul(argv[3], &endp, 10);
addr = simple_strtoul(argv[2], &endp, 16);
//snprintf_res("ADDRESS: 0x%08x\n", addr);
for(s=0; s<count; s++, addr+=4) {
if (SMAC_REG_READ(sc->sh, addr, &value)) ;
snprintf_res(cmd_data, "%08x\n", value);
//if (((s+1)&0x07) == 0)
// snprintf_res("\n");
}
//snprintf_res("\n");
return 0;
}
if ((argc == 3) && (strcmp(argv[1], "auto_gen_nullpkt") == 0)) {
/* tool auto_gen_nullpkt <txq> */
value = simple_strtoul(argv[2], &endp, 10);
retval = SSV_AUTO_GEN_NULLPKT(sc->sh, value);
if (!retval)
snprintf_res(cmd_data, "done to auto generate null frame\n");
else
snprintf_res(cmd_data, "Not suppout the tool\n");
return 0;
}
if ((argc == 3) && (strcmp(argv[1], "dump_pbuf") == 0)) {
/* tool dump_pbuf <id> */
value = simple_strtoul(argv[2], &endp, 10);
/* step 1, pbuf len*/
addr = 0x80000000 | (value << 16);
SMAC_REG_READ(sc->sh, addr, &len);
len &= 0xffff;
snprintf_res(cmd_data, "\n pbuf id=%d, len=%d\n\n", value, len);
/* step 2, dump pbuf context */
if (len > 1024)
len = 1024;
for(s=0; s<len; s+=4, addr+=4) {
if (SMAC_REG_READ(sc->sh, addr, &value));
if((s+4)%32 == 0)
snprintf_res(cmd_data, " %08x\n", value);
else
snprintf_res(cmd_data, " %08x", value);
}
return 0;
}
#endif
return 0;
}
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static int txtput_thread_m2(void *data)
{
#define Q_DELAY_MS 20
struct sk_buff *skb = NULL;
int qlen = 0, max_qlen, q_delay_urange[2];
struct ssv_softc *sc = data;
struct SKB_info_st *skb_info = NULL;
/* Suppose the max sdio tput is 200Mbps
* max_qlen = 200Mbps / 8 / size_per_frame_in_byte * delay_in_sec
*/
max_qlen = (200 * 1000 / 8 * Q_DELAY_MS) / sc->ssv_txtput.size_per_frame;
q_delay_urange[0] = Q_DELAY_MS * 1000;
q_delay_urange[1] = q_delay_urange[0] + 1000;
printk("max_qlen: %d\n", max_qlen);
while (!kthread_should_stop() && sc->ssv_txtput.loop_times > 0) {
sc->ssv_txtput.loop_times--;
skb = ssv_skb_alloc(sc, sc->ssv_txtput.size_per_frame);
if (skb == NULL) {
printk("ssv command txtput_generate_m2 "
"ssv_skb_alloc fail!!!\n");
goto end;
}
skb_reserve(skb, sizeof(struct SKB_info_st));
skb_info = (struct SKB_info_st *)skb->head;
skb_info->txtput_frame = true;
skb_put(skb, sc->ssv_txtput.size_per_frame);
SSV_TXTPUT_SET_DESC(sc->sh, skb);
qlen = sc->sh->hci.hci_ops->hci_tx(sc->sh->hci.hci_ctrl, skb, 0, false, 0);
if (qlen >= max_qlen) {
//printk("%s: qlen=%d\n", __func__, qlen);
usleep_range(q_delay_urange[0], q_delay_urange[1]);
}
}
//ssv_skb_free(skb);
end:
sc->ssv_txtput.txtput_tsk = NULL;
return 0;
}
int txtput_generate_m2(struct ssv_softc *sc, u32 size_per_frame, u32 loop_times)
{
sc->ssv_txtput.size_per_frame = size_per_frame;
sc->ssv_txtput.loop_times = loop_times;
sc->ssv_txtput.txtput_tsk = kthread_run(txtput_thread_m2, sc, "txtput_thread_m2");
return 0;
}
static int txtput_tsk_cleanup(struct ssv_softc *sc)
{
int ret = 0;
if (sc->ssv_txtput.txtput_tsk) {
printk("Stopping txtput task...\n");
ret = kthread_stop(sc->ssv_txtput.txtput_tsk);
while (sc->ssv_txtput.txtput_tsk != NULL) {
msleep(1);
}
printk("txtput task is stopped.\n");
}
return ret;
}
#endif
static int ssv_cmd_txtput(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
char *endp;
u32 size_per_frame, loop_times;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if ( (argc == 2) && (!strcmp(argv[1], "stop"))) {
txtput_tsk_cleanup(sc);
return 0;
}
if (argc != 3) {
snprintf_res(cmd_data, "* txtput stop\n");
snprintf_res(cmd_data, "* txtput [size] [frames]\n");
snprintf_res(cmd_data, " EX: txtput 14000 9999 \n");
return 0;
}
size_per_frame = simple_strtoul(argv[1], &endp, 10);
loop_times = simple_strtoul(argv[2], &endp, 10);
snprintf_res(cmd_data, "size & frames: %d & %d\n", size_per_frame, loop_times);
//already in progress
if (sc->ssv_txtput.txtput_tsk) {
snprintf_res(cmd_data, "txtput already in progress\n");
return 0;
}
txtput_generate_m2(sc, size_per_frame + TXPB_OFFSET, loop_times);
#endif
return 0;
}
#define MAX_FRM_SIZE 2304
static int ssv_cmd_rxtput(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct sk_buff *skb;
struct cfg_host_cmd *host_cmd;
struct sdio_rxtput_cfg cmd_rxtput_cfg;
char *endp;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if (argc != 3) {
snprintf_res(cmd_data, "rxtput [size] [frames]\n");
return 0;
}
cmd_rxtput_cfg.size_per_frame = simple_strtoul(argv[1], &endp, 10);
cmd_rxtput_cfg.total_frames = simple_strtoul(argv[2], &endp, 10);
if (cmd_rxtput_cfg.size_per_frame > MAX_FRM_SIZE) {
snprintf_res(cmd_data, "Frame size too large!!\n");
return 0 ;
}
snprintf_res(cmd_data, "size & frames: %d& %d\n",
cmd_rxtput_cfg.size_per_frame, cmd_rxtput_cfg.total_frames);
skb = ssv_skb_alloc(sc, HOST_CMD_HDR_LEN + sizeof(struct sdio_rxtput_cfg));
if(skb == NULL) {
printk("ssv command ssv_skb_alloc fail!!!\n");
return 0;
}
skb->data_len = HOST_CMD_HDR_LEN + sizeof(struct sdio_rxtput_cfg);
skb->len = skb->data_len;
host_cmd = (struct cfg_host_cmd *)skb->data;
memset(host_cmd, 0x0, sizeof(struct cfg_host_cmd));
host_cmd->c_type = HOST_CMD;
host_cmd->h_cmd = (u8)SSV6XXX_HOST_CMD_RX_TPUT;
host_cmd->len = skb->data_len;
memcpy(host_cmd->un.dat32, &cmd_rxtput_cfg, sizeof(struct sdio_rxtput_cfg));
if (HCI_SEND_CMD(sc->sh, skb) == 0) {
snprintf_res(cmd_data, "## hci cmd was sent successfully\n");
} else {
snprintf_res(cmd_data, "## hci cmd was sent failed\n");
}
#endif
return 0;
}
static int ssv_cmd_check(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 size,i,j,x,y,id,value,address,id_value;
char *endp;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
u32 id_base_address[4];
SSV_GET_RD_ID_ADR(sc->sh, &id_base_address[0]);
if (argc != 2) {
snprintf_res(cmd_data, "check [packet size]\n");
return 0;
}
snprintf_res(cmd_data, " id address %x %x %x %x \n", id_base_address[0],
id_base_address[1], id_base_address[2], id_base_address[3]);
size = simple_strtoul(argv[1], &endp, 10);
size = size >> 2;
for (x = 0; x < 4; x++) {
if (SMAC_REG_READ(sc->sh, id_base_address[x], &id_value));
for (y = 0; y < 32 && id_value; y++, id_value>>=1) {
if (id_value & 0x1) {
id = 32*x + y;
address = 0x80000000 + (id << 16);
{
printk(" ");
for (i = 0; i < size; i += 8){
if(SMAC_REG_READ(sc->sh, address, &value));
printk("\n%08X:%08X", address,value);
address += 4;
for (j = 1; j < 8; j++){
if(SMAC_REG_READ(sc->sh, address, &value));
printk(" %08X", value);
address += 4;
}
}
printk("\n");
}
}
}
}
#endif
return 0;
}
static int ssv_cmd_directack(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if ((argc == 2) && (!strcmp(argv[1], "show"))) {
snprintf_res(cmd_data, ">> act status = %s\n",
((sc->sc_flags & SC_OP_DIRECTLY_ACK) ? "direct complete" : "delay complete"));
snprintf_res(cmd_data, ">> tx_frame in q = %d\n", atomic_read(&sc->tx_frame));
return 0;
} else {
snprintf_res(cmd_data, "\n directack [show]\n");
return 0;
}
#endif
return 0;
}
static int ssv_cmd_flowctl(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if ((argc == 2) && (!strcmp(argv[1], "show"))) {
snprintf_res(cmd_data, ">> flowctl = %d\n", sc->sh->cfg.flowctl);
snprintf_res(cmd_data, ">> flowctl_low_threshold = %d\n", sc->sh->cfg.flowctl_low_threshold);
snprintf_res(cmd_data, ">> flowctl_high_threshold = %d\n", sc->sh->cfg.flowctl_high_threshold);
snprintf_res(cmd_data, ">> flowctl_hci_cnt = %d\n", sc->flowctl_hci_cnt);
snprintf_res(cmd_data, ">> flowctl_frame_cnt = %d\n", sc->flowctl_frame_cnt);
snprintf_res(cmd_data, ">> tx_ack_ctl_q = %u\n", skb_queue_len(&sc->tx_ack_ctl_q));
snprintf_res(cmd_data, ">> ieee80211_txq_status %s\n", ((sc->sc_flags & SC_OP_FLOWCTL) ? "stop" : "start"));
} else {
snprintf_res(cmd_data, ">> flowctl [show]\n");
}
#endif
return 0;
}
static int ssv_cmd_txrx_skb_q(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
struct ssv6xxx_hci_ctrl *hci_ctrl = sc->sh->hci.hci_ctrl;
int txqid;
char *endp;
if ((argc == 2) && (!strcmp(argv[1], "show"))) {
snprintf_res(cmd_data, ">> rx_skb_q = %u\n", skb_queue_len(&sc->rx_skb_q));
for(txqid=0; txqid<SSV_SW_TXQ_NUM; txqid++) {
snprintf_res(cmd_data, ">> sw_txq[%d] = %u\n", txqid, skb_queue_len(&hci_ctrl->sw_txq[txqid].qhead));
}
snprintf_res(cmd_data, ">> rx_threshold = %d\n", sc->sh->cfg.rx_threshold);
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "rx_threshold"))) {
sc->sh->cfg.rx_threshold = simple_strtoul(argv[2], &endp, 10);
snprintf_res(cmd_data, ">> Set rx_threshold = %d\n", sc->sh->cfg.rx_threshold);
return 0;
} else {
snprintf_res(cmd_data, "\n txrx_skb_q [show|rx_threshold] [value] \n");
return 0;
}
#endif
return 0;
}
static int ssv_cmd_log(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
u32 log_hex = 0;
int log_size = 0, total_log_size;
if ((argc == 3) && (!strcmp(argv[1], "tx_desc"))) {
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_TX_DESC;
} else {
sc->log_ctrl &= ~(LOG_TX_DESC);
}
snprintf_res(cmd_data, " log tx_desc %s\n", ((sc->log_ctrl & LOG_TX_DESC) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "rx_desc"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_RX_DESC;
} else {
sc->log_ctrl &= ~(LOG_RX_DESC);
}
snprintf_res(cmd_data, " log rx_desc %s\n", ((sc->log_ctrl & LOG_RX_DESC) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "tx_frame"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_TX_FRAME;
} else {
sc->log_ctrl &= ~(LOG_TX_FRAME);
}
snprintf_res(cmd_data, " log tx_frame %s\n", ((sc->log_ctrl & LOG_TX_FRAME) ? "enable": "disable"));
} else if((argc == 4) && (!strcmp(argv[1], "ampdu"))){
if (!strcmp(argv[2], "ssn")){
if(!strcmp(argv[3], "enable")){
sc->log_ctrl |= LOG_AMPDU_SSN;
} else {
sc->log_ctrl &= ~(LOG_AMPDU_SSN);
}
snprintf_res(cmd_data, " log ampdu ssn %s\n", ((sc->log_ctrl & LOG_AMPDU_SSN) ? "enable": "disable"));
} else if (!strcmp(argv[2], "dbg")){
if(!strcmp(argv[3], "enable")){
sc->log_ctrl |= LOG_AMPDU_DBG;
} else {
sc->log_ctrl &= ~(LOG_AMPDU_DBG);
}
snprintf_res(cmd_data, " log ampdu dbg %s\n", ((sc->log_ctrl & LOG_AMPDU_DBG) ? "enable": "disable"));
}else if (!strcmp(argv[2], "err")){
if(!strcmp(argv[3], "enable")){
sc->log_ctrl |= LOG_AMPDU_ERR;
} else {
sc->log_ctrl &= ~(LOG_AMPDU_ERR);
}
snprintf_res(cmd_data, " log ampdu err %s\n", ((sc->log_ctrl & LOG_AMPDU_ERR) ? "enable": "disable"));
}else{
snprintf_res(cmd_data, " Invalid command!!\n");
return 0;
}
}else if ((argc == 3) && (!strcmp(argv[1], "beacon"))) {
if (!strcmp(argv[2], "enable")) {
sc->log_ctrl |= LOG_BEACON;
} else {
sc->log_ctrl &= ~(LOG_BEACON);
}
snprintf_res(cmd_data, " log beacon%s\n", ((sc->log_ctrl & LOG_BEACON) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "rate_control"))) {
if (!strcmp(argv[2], "enable")) {
sc->log_ctrl |= LOG_RATE_CONTROL;
} else {
sc->log_ctrl &= ~(LOG_RATE_CONTROL);
}
snprintf_res(cmd_data, " log rate control %s\n", ((sc->log_ctrl & LOG_RATE_CONTROL) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "rate_report"))) {
if (!strcmp(argv[2], "enable")) {
sc->log_ctrl |= LOG_RATE_REPORT;
} else {
sc->log_ctrl &= ~(LOG_RATE_REPORT);
}
snprintf_res(cmd_data, " log rate report %s\n", ((sc->log_ctrl & LOG_RATE_REPORT) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "hci"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_HCI;
} else {
sc->log_ctrl &= ~(LOG_HCI);
}
snprintf_res(cmd_data, " log hci %s\n", ((sc->log_ctrl & LOG_HCI) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "hwif"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_HWIF;
sc->sh->priv->dbg_control = true;
} else {
sc->log_ctrl &= ~(LOG_HWIF);
sc->sh->priv->dbg_control = false;
}
snprintf_res(cmd_data, " log hwif %s\n", ((sc->log_ctrl & LOG_HWIF) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "flash_bin"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_FLASH_BIN;
} else {
sc->log_ctrl &= ~(LOG_FLASH_BIN);
}
snprintf_res(cmd_data, " log flash_bin %s\n", ((sc->log_ctrl & LOG_FLASH_BIN) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "flowctl"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_FLOWCTL;
} else {
sc->log_ctrl &= ~(LOG_FLOWCTL);
}
snprintf_res(cmd_data, " log flowctl %s\n", ((sc->log_ctrl & LOG_FLOWCTL) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "hex"))) {
if (1 != sscanf(argv[2], "%x", &log_hex)) {
snprintf_res(cmd_data, " log hex hexstring\n");
} else {
sc->log_ctrl = log_hex;
}
snprintf_res(cmd_data, " log ctrl %d\n", sc->log_ctrl);
} else if ((argc == 3) && (!strcmp(argv[1], "log_to_ram"))) {
if (!strcmp(argv[2], "enable")) {
sc->cmd_data.log_to_ram = true;
} else {
sc->cmd_data.log_to_ram = false;
}
snprintf_res(cmd_data, " log_to_ram %s\n", (sc->cmd_data.log_to_ram ? "enable" : "disable"));
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "ram_size"))) {
if (1 == sscanf(argv[2], "%d", &log_size)) {
if (sc->cmd_data.dbg_log.data) {
kfree(sc->cmd_data.dbg_log.data);
memset(&sc->cmd_data.dbg_log, 0, sizeof(struct ssv_dbg_log));
}
if (log_size != 0) {
if (sc->cmd_data.dbg_log.data)
kfree(sc->cmd_data.dbg_log.data);
total_log_size = log_size * 1024;
sc->cmd_data.dbg_log.data = (char *)kzalloc(total_log_size, GFP_KERNEL);
if (sc->cmd_data.dbg_log.data == NULL) {
snprintf_res(cmd_data, " Fail to alloc dbg_log_size %d Kbytes\n", log_size);
return 0;
}
sc->cmd_data.dbg_log.size = 0;
sc->cmd_data.dbg_log.totalsize = total_log_size;
sc->cmd_data.dbg_log.top = sc->cmd_data.dbg_log.data;
sc->cmd_data.dbg_log.tail = sc->cmd_data.dbg_log.data;
sc->cmd_data.dbg_log.end = &(sc->cmd_data.dbg_log.data[total_log_size]);
}
snprintf_res(cmd_data, " alloc dbg_log_size %d Kbytes\n", log_size);
} else {
snprintf_res(cmd_data, " log ram_size [size] Kbytes\n");
}
return 0;
} else if ((argc == 3) && (!strcmp(argv[1], "regw"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_REGW;
} else {
sc->log_ctrl &= ~(LOG_REGW);
}
snprintf_res(cmd_data, " log regw %s\n", ((sc->log_ctrl & LOG_REGW) ? "enable": "disable"));
} else if ((argc == 3) && (!strcmp(argv[1], "krack"))){
if(!strcmp(argv[2], "enable")){
sc->log_ctrl |= LOG_KRACK;
} else {
sc->log_ctrl &= ~(LOG_KRACK);
}
snprintf_res(cmd_data, " log krack %s\n", ((sc->log_ctrl & LOG_KRACK) ? "enable": "disable"));
} else {
snprintf_res(cmd_data, " log log_to_ram [enable | disable]\n");
snprintf_res(cmd_data, " log ram_size [size] kb\n");
snprintf_res(cmd_data, " log [category] [param] [enablel | disable]\n\n");
snprintf_res(cmd_data, " category: tx_desc, tx_frame, rx_desc, ampdu, beacon\n");
snprintf_res(cmd_data, " rate_control, rate_report, hci, hwif, regw, krack\n\n");
snprintf_res(cmd_data, " ampdu param: ssn, dbg, err\n");
return 0;
}
snprintf_res(cmd_data, " log_ctrl 0x%x\n", sc->log_ctrl);
#endif
return 0;
}
static int ssv_cmd_chan(struct ssv_softc *sc, int argc, char *argv[])
{
char *endp;
u32 ch;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
struct ieee80211_supported_band *sband;
struct ieee80211_channel *channel;
enum nl80211_channel_type type = NL80211_CHAN_HT20;
bool support_chan = false;
int i, band;
if ((argc == 2) || (argc == 3)) {
// fixed channel for debug mode
if (argc == 2) {
if (!strcmp(argv[1], "fixed") || !strcmp(argv[1], "auto")) {
if (!strcmp(argv[1], "fixed"))
sc->sc_flags |= SC_OP_CHAN_FIXED;
if (!strcmp(argv[1], "auto"))
sc->sc_flags &= ~SC_OP_CHAN_FIXED;
snprintf_res(cmd_data, "\n %s channel fixed\n", ((sc->sc_flags & SC_OP_CHAN_FIXED) ? "Force" : "Clear"));
return 0;
}
}
ch = simple_strtoul(argv[1], &endp, 0);
if (ch < 1) {
snprintf_res(cmd_data, "\n Channel syntax error.\n");
return 0;
}
// chanel bandwidth
if (argc == 3) {
if (!strcmp(argv[2], "bw40")) {
if ((ch == 3) || (ch == 4) || (ch == 5) || (ch == 6) ||
(ch == 7) || (ch == 8) || (ch == 9) || (ch == 10) ||
(ch == 11) || (ch == 38) || (ch == 42) || (ch == 46) ||
(ch == 50) || (ch == 54) || (ch == 58) || (ch == 62) ||
(ch == 102) || (ch == 106) || (ch == 110) || (ch == 114) ||
(ch == 118) || (ch == 122) || (ch == 126) || (ch == 130) ||
(ch == 134) || (ch == 138) || (ch == 142) || (ch == 151) ||
(ch == 155) || (ch == 159)) {
type = NL80211_CHAN_HT40PLUS;
ch = ch - 2; // find center chan
} else {
snprintf_res(cmd_data, "\n Channel syntax error.\n");
return 0;
}
} else if (!strcmp(argv[2], "+")) {
if ((ch >= 8) && (ch <= 13)) {
snprintf_res(cmd_data, "\n Channel syntax error.\n");
return 0;
}
type = NL80211_CHAN_HT40PLUS;
} else if (!strcmp(argv[2], "-")) {
if ((ch >= 1) && (ch <= 4)) {
snprintf_res(cmd_data, "\n Channel syntax error.\n");
return 0;
}
type = NL80211_CHAN_HT40MINUS;
} else {
snprintf_res(cmd_data, "\n Channel syntax error.\n");
return 0;
}
}
if (argc == 2)
type = NL80211_CHAN_HT20;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0)
for (band = 0; band < NUM_NL80211_BANDS; band++) {
#else
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
#endif
if ((band == INDEX_80211_BAND_5GHZ) && !(sc->sh->cfg.hw_caps & SSV6200_HW_CAP_5GHZ))
continue;
sband = &sc->sbands[band];
for (i = 0; i < sband->n_channels; i++) {
channel = &sband->channels[i];
if (ch == channel->hw_value)
support_chan = true;
}
}
if (support_chan){
struct ieee80211_channel chan, *pchan;
memset(&chan, 0 , sizeof( struct ieee80211_channel));
chan.hw_value = ch;
pchan = &chan;
snprintf_res(cmd_data, "\n switch to ch %d by command...\n", ch);
HAL_SET_CHANNEL(sc, pchan, type, false);
snprintf_res(cmd_data, "\n DONE!!\n");
}
else
snprintf_res(cmd_data, "\n invalid ch %d\n", ch);
} else {
snprintf_res(cmd_data, "\n ch [chan_number] [chan_type]\n");
}
return 0;
}
static int ssv_cmd_cali(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
if((argc == 2) || (argc == 3)) {
HAL_CMD_CALI(sc->sh, argc, argv);
} else {
snprintf_res(&sc->cmd_data,"\n cali [do|show|dpd(show |enable|disable)] \n");
}
#endif
return 0;
}
static int ssv_cmd_init(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
if (!strcmp(argv[1], "mac")) {
/* force RX reset to avoid pbuf allocating out-of-order address */
SSV_PHY_ENABLE(sc->sh, false);
// init mac hw
HAL_INIT_MAC(sc->sh);
SSV_PHY_ENABLE(sc->sh, true);
snprintf_res(&sc->cmd_data, "\n reload mac DONE\n");
}else {
snprintf_res(&sc->cmd_data, "\n init [mac]\n");
}
#endif
return 0;
}
static int ssv_cmd_rc(struct ssv_softc *sc, int argc, char *argv[])
{
HAL_CMD_RC(sc->sh, argc, argv);
return 0;
}
static int ssv_cmd_hwinfo(struct ssv_softc *sc, int argc, char *argv[])
{
HAL_CMD_HWINFO(sc->sh, argc, argv);
return 0;
}
static int ssv_cmd_txgen(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
u32 count = 0, rate = 0;
int i;
if (argc != 3) {
snprintf_res(cmd_data, "\n ./cli tx_gen [count] [rate]\n");
return 0;
}
__string2u32(argv[1], &count, 0);
__string2u32(argv[2], &rate, 0);
for (i = 0; i < count; i++) {
HAL_CMD_TXGEN(sc->sh, (u8)(rate & 0x000000ff));
mdelay(1);
}
snprintf_res(cmd_data, "\n tx_gen %d times done \n", count);
#endif
return 0;
}
static int ssv_cmd_rf(struct ssv_softc *sc, int argc, char *argv[])
{
HAL_CMD_RF(sc->sh, argc, argv);
return 0;
}
static int ssv_cmd_hwq_limit(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
if ((argc == 3)&&(!strcmp(argv[1], "bk")||!strcmp(argv[1], "be")||!strcmp(argv[1], "vi")||!strcmp(argv[1], "vo")||!strcmp(argv[1], "mng"))) {
HAL_CMD_HWQ_LIMIT(sc->sh, argc, argv);
} else {
snprintf_res(cmd_data, "%s [bk|be|vi|vo|mng] [queue limit]\n\n", argv[0]);
}
#endif
return 0;
}
static int ssv_cmd_efuse(struct ssv_softc *sc, int argc, char *argv[])
{
HAL_CMD_EFUSE(sc->sh, argc, argv);
return 0;
}
#ifdef CONFIG_ENABLE_HOST_THERMAL
static int ssv_cmd_get_temp(struct ssv_softc *sc, int argc, char *argv[])
{
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
int val = 0;
HAL_GET_TEMP(sc->sh, &val);
snprintf_res(cmd_data, "ssv_cmd_get_temp val = %d\n\n", val);
return 0;
}
static int ssv_cmd_temp_calibration(struct ssv_softc *sc, int argc, char *argv[])
{
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
int val = 0;
HAL_GET_TEMP(sc->sh, &val);
SSV_DO_TEMPERATURE_COMPENSATION(sc->sh);
snprintf_res(cmd_data, "sstar_cmd_get_temp val = %d\n\n", val);
return 0;
}
#endif
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static int _ssv6xxx_tx_opertaion(struct ssv_softc *sc, ssv6xxx_tx_ops ops, u32 val)
{
struct sk_buff *skb = NULL;
struct cfg_host_cmd *host_cmd = NULL;
int ret = 0;
skb = dev_alloc_skb(HOST_CMD_HDR_LEN + sizeof(u32));
if (skb == NULL) {
printk("%s(): Fail to alloc cmd buffer.\n", __FUNCTION__);
return -1;
}
skb_put(skb, HOST_CMD_HDR_LEN + sizeof(u32));
host_cmd = (struct cfg_host_cmd *)skb->data;
memset(host_cmd, 0x0, sizeof(struct cfg_host_cmd)+sizeof(u32));
host_cmd->c_type = HOST_CMD;
host_cmd->h_cmd = (u8)SSV6XXX_HOST_CMD_TX_OPS;
host_cmd->sub_h_cmd = (u32)ops;
host_cmd->un.dat32[0] = val;
host_cmd->blocking_seq_no = (((u16)SSV6XXX_HOST_CMD_TX_OPS << 16)|(u16)ops);
host_cmd->len = HOST_CMD_HDR_LEN + sizeof(u32);
ret = HCI_SEND_CMD(sc->sh, skb);
return 0;
}
#endif
static int ssv_cmd_fwtxops(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
char *endp;
/**
* fwtxops [wait_num|wait_time|chk_point] <val>
* (1) fwtxops wait_num <num>
* (2) fwtxops wait_time <time_in_us>
* (3) fwtxops wait_time_ht40 <time_in_us>
* (4) fwtxops chk_pooint <val>
*/
if ((argc == 3) && (!strcmp(argv[1], "wait_num")))
{
snprintf_res(cmd_data, " call cmd fwtxops wait_num %s\n", argv[2]);
_ssv6xxx_tx_opertaion(sc, SSV6XXX_TX_CMD_WAIT_NUM, (u32)simple_strtoul(argv[2], &endp, 0));
} else if ((argc == 3) && (!strcmp(argv[1], "wait_time"))) {
snprintf_res(cmd_data, " call cmd fwtxops wait_time %s\n", argv[2]);
_ssv6xxx_tx_opertaion(sc, SSV6XXX_TX_CMD_WAIT_TIME, (u32)simple_strtoul(argv[2], &endp, 0));
} else if ((argc == 3) && (!strcmp(argv[1], "chk_point"))) {
snprintf_res(cmd_data, " call cmd fwtxops chk_point %s\n", argv[2]);
_ssv6xxx_tx_opertaion(sc, SSV6xxx_TX_CMD_CHECK_POINT, (u32)simple_strtoul(argv[2], &endp, 0));
} else if ((argc == 3) && (!strcmp(argv[1], "wait_time_ht40"))) {
snprintf_res(cmd_data, " call cmd fwtxops wait_time_ht40 %s\n", argv[2]);
_ssv6xxx_tx_opertaion(sc, SSV6XXX_TX_CMD_WAIT_TIME_HT40, (u32)simple_strtoul(argv[2], &endp, 0));
} else if ((argc == 3) && (!strcmp(argv[1], "chk_hwq_num"))) {
snprintf_res(cmd_data, " call cmd fwtxops check hw queue number %s\n", argv[2]);
_ssv6xxx_tx_opertaion(sc, SSV6XXX_TX_CMD_CHECK_HWQ_NUM, (u32)simple_strtoul(argv[2], &endp, 0));
} else {
snprintf_res(cmd_data, " fwtxops wait_num <num>\n\n");
snprintf_res(cmd_data, " fwtxops wait_time <time_in_us>\n\n");
snprintf_res(cmd_data, " fwtxops wait_time_ht40 <time_in_us>\n\n");
snprintf_res(cmd_data, " fwtxops chk_point <val>\n\n");
}
#endif
return 0;
}
static int ssv_cmd_restart(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static u32 u32Cnt = 0;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
//char *endp;
/**
* re_test
*/
snprintf_res(cmd_data, " re_test, %u times\n\n", ++u32Cnt);
queue_work(sc->config_wq, &sc->hw_restart_work);
#endif
return 0;
}
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
static int _ssv6xxx_adapt_opertaion(struct ssv_softc *sc, ssv6xxx_adaptive_ops ops, struct ssv6xxx_adaptive_param *param)
{
struct sk_buff *skb = NULL;
struct cfg_host_cmd *host_cmd = NULL;
int ret = 0;
skb = ssv_skb_alloc(sc, HOST_CMD_HDR_LEN + sizeof(struct ssv6xxx_adaptive_param));
if(skb == NULL)
{
printk("%s:_skb_alloc fail!!!\n", __func__);
return -1;
}
skb->data_len = HOST_CMD_HDR_LEN + sizeof(struct ssv6xxx_adaptive_param);
skb->len = skb->data_len;
host_cmd = (struct cfg_host_cmd *)skb->data;
memset(host_cmd, 0x0, sizeof(struct cfg_host_cmd)+sizeof(struct ssv6xxx_adaptive_param));
host_cmd->c_type = HOST_CMD;
host_cmd->h_cmd = (u8)SSV6XXX_HOST_CMD_ADAPTIVE;
host_cmd->sub_h_cmd = (u32)ops;
if(NULL != param)
{
memcpy(host_cmd->un.dat32, param, sizeof(struct ssv6xxx_adaptive_param));
}
host_cmd->blocking_seq_no = (((u16)SSV6XXX_HOST_CMD_ADAPTIVE << 16)|(u16)ops);
host_cmd->len = HOST_CMD_HDR_LEN + sizeof(struct ssv6xxx_adaptive_param);
ret = HCI_SEND_CMD(sc->sh, skb);
return 0;
}
#endif
static int ssv_cmd_adapt(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/**
* AT+ADAPT [0|1]
*/
if ((argc == 2) && (!strcmp(argv[1], "1"))) {
snprintf_res(cmd_data, " call cmd AT+ADAPT 1\n");
sc->bAdapt = true;
cancel_work_sync(&sc->mib_edca_work);
_ssv6xxx_adapt_opertaion(sc, SSV6XXX_ADAPTIVE_OPS_ENABLE, NULL);
} else if ((argc == 2) && (!strcmp(argv[1], "0"))) {
snprintf_res(cmd_data, " call cmd AT+ADAPT 0\n");
_ssv6xxx_adapt_opertaion(sc, SSV6XXX_ADAPTIVE_OPS_DISABLE, NULL);
sc->bAdapt = false;
} else {
snprintf_res(cmd_data, " AT+ADAPT [0|1]\n\n");
snprintf_res(cmd_data, " - 0: Disable adaptive test\n\n");
snprintf_res(cmd_data, " - 1: Enable adaptive test\n\n");
}
#endif
return 0;
}
static int ssv_cmd_set_adapt(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
struct ssv6xxx_adaptive_param param = {0};
char *endp;
/**
* AT+SET_ADAP <interval> <hit count> <total count> <threshold>
*/
if (argc == 5)
{
snprintf_res(cmd_data, " call cmd AT+SET_ADAPT %s %s %s %s\n", argv[1], argv[2], argv[3], argv[4]);
param.interval = (u32)simple_strtoul(argv[1], &endp, 0);
param.hit_count = (u32)simple_strtoul(argv[2], &endp, 0);
param.total_count = (u32)simple_strtoul(argv[3], &endp, 0);
param.threshold = (u32)simple_strtoul(argv[4], &endp, 0);
_ssv6xxx_adapt_opertaion(sc, SSV6XXX_ADAPTIVE_OPS_SET, &param);
} else {
snprintf_res(cmd_data, " AT+SET_ADAPT <interval> <hit count> <total count> <threshold>\n\n");
}
#endif
return 0;
}
static int ssv_cmd_regr(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 addr, value, cnt;
int s, i;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/* regr [address],[value] */
if (argc == 2) {
s = sscanf(argv[1], "%x,%d", &addr, &cnt);
if (s != 2) {
s = sscanf(argv[1], "%x", &addr);
if (s == 1) {
cnt = 1;
} else {
snprintf_res(cmd_data, " => regr [address],[cnt]\n");
return 0;
}
}
for(i = 0; i < cnt; i++, addr += 4) {
if (SMAC_REG_READ(sc->sh, addr, &value)) ;
snprintf_res(cmd_data, "0x%08X = 0x%08X\n", addr, value);
}
return 0;
} else {
snprintf_res(cmd_data, " => regr [address],[value]\n");
return 0;
}
#else
return 0;
#endif
}
static int ssv_cmd_regw(struct ssv_softc *sc, int argc, char *argv[])
{
#ifdef CONFIG_ENABLE_CLI_DBG_TOOL
u32 addr, value;
int s;
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
/* regw [address],[value] */
if (argc == 2) {
s = sscanf(argv[1], "%x,%x", &addr, &value);
if (s != 2) {
snprintf_res(cmd_data, " => regw [address,value]\n");
return 0;
}
if (SMAC_REG_WRITE(sc->sh, addr, value)) ;
snprintf_res(cmd_data, " => write [0x%08x]: 0x%08x\n", addr, value);
return 0;
} else {
snprintf_res(cmd_data, " => regw [address,value]\n");
return 0;
}
#else
return 0;
#endif
}
#ifdef CONFIG_ENABLE_HOST_THERMAL
static int ssv_cmd_disable_host_thermal(struct ssv_softc *sc, int argc, char *argv[])
{
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
char *endp;
if (argc == 2)
{
if ((u32)simple_strtoul(argv[1], &endp, 0) == 1)
{
sc->sh->htc_config.exist = 0;
}
else
{
sc->sh->htc_config.exist = 1;
}
snprintf_res(cmd_data, "sc->sh->htc_config.exist, %u \n\n", sc->sh->htc_config.exist);
}
return 0;
}
static int ssv_cmd_debug_host_thermal(struct ssv_softc *sc, int argc, char *argv[])
{
struct ssv_cmd_data *cmd_data = &sc->cmd_data;
char *endp;
if (argc == 2)
{
sc->sh->cfg.host_thermal_debug = (u32)simple_strtoul(argv[1], &endp, 0);
snprintf_res(cmd_data, "sc->sh->cfg.host_thermal_debug, %d \n\n", sc->sh->cfg.host_thermal_debug);
}
return 0;
}
#endif
struct ssv_cmd_table cmd_table[] = {
{ "help", ssv_cmd_help, "ssv6200 command usage." , 2048},
{ "-h", ssv_cmd_help, "ssv6200 command usage." , 2048},
{ "--help", ssv_cmd_help, "ssv6200 command usage." , 2048},
{ "reg", ssv_cmd_reg, "ssv6200 register read/write." , 4096},
{ "regr", ssv_cmd_regr, "ssv6200 register read" , 4096},
{ "regw", ssv_cmd_regw, "ssv6200 register write" , 256},
{ "cfg", ssv_cmd_cfg, "ssv6200 configuration." , 256},
{ "sta", ssv_cmd_sta, "svv6200 station info." , 4096},
{ "dump", ssv_cmd_dump, "dump ssv6200 tables." , 8192},
{ "hwq", ssv_cmd_hwq, "hardware queue staus" , 512},
{ "irq", ssv_cmd_irq, "get sdio irq status." , 256},
{ "mac", ssv_cmd_mac, "ieee80211 swmac." , 512},
{ "hci", ssv_cmd_hci, "HCI command." , 4096},
{ "sdio", ssv_cmd_sdio, "SDIO command." , 128},
{ "version",ssv_cmd_version,"version information" , 512},
{ "mib", ssv_cmd_mib, "mib counter related" , 2048},
{ "ps", ssv_cmd_power_saving, "power saving test" , 256},
{ "tool", ssv_cmd_tool, "ssv6200 tool register read/write." , 4096},
{ "rxtput", ssv_cmd_rxtput, "test rx sdio throughput" , 128},
{ "txtput", ssv_cmd_txtput, "test tx sdio throughput" , 256},
{ "check", ssv_cmd_check, "dump all allocate packet buffer" , 128},
{ "directack", ssv_cmd_directack, "directly ack control" , 512},
{ "flowctl",ssv_cmd_flowctl,"flow control" , 512},
{ "txrx_skb_q", ssv_cmd_txrx_skb_q, "tx/rx skb queue control" , 512},
{ "log", ssv_cmd_log, "enable debug log" , 256},
{ "ch", ssv_cmd_chan, "change channel by manual" , 128},
{ "cali", ssv_cmd_cali, "calibration for ssv6006" , 4096},
{ "init", ssv_cmd_init, "re-init " , 64},
{ "rc", ssv_cmd_rc, "fix rate set for ssv6006" , 4096},
{ "hwmsg", ssv_cmd_hwinfo, "hw message for ssv6006" , 4096},
{ "txgen", ssv_cmd_txgen, "auto gen tx " , 128},
{ "rf", ssv_cmd_rf, "change parameters for rf tool" , 512},
{ "hwqlimit", ssv_cmd_hwq_limit, "Set software limit for hardware queue" , 512},
{ "efuse", ssv_cmd_efuse, "efuse read/write." , 2048},
{ "fwtxops",ssv_cmd_fwtxops,"set tx ops to fw" , 512},
{ "re_test",ssv_cmd_restart,"restart test" , 512},
#ifdef CONFIG_ENABLE_HOST_THERMAL
{ "temp", ssv_cmd_get_temp, "get temp." , 512},
{ "ctemp", ssv_cmd_temp_calibration, "temp calibration" , 512},
{ "disable_host_thermal",ssv_cmd_disable_host_thermal,"disable_host_thermal", 512},
{ "host_thermal_debug", ssv_cmd_debug_host_thermal,"host_thermal_debug", 512},
#endif
{ "AT+ADAPT", ssv_cmd_adapt, "Enable/Disable adaptive" , 512},
{ "AT+SET_ADAPT", ssv_cmd_set_adapt, "Set adaptive" , 512},
{ NULL, NULL, NULL, 0},
};
int ssv_cmd_submit(struct ssv_cmd_data *cmd_data, char *cmd)
{
struct ssv_cmd_table *sc_tbl;
char *pch, ch;
int ret, bf_size;
char *sg_cmd_buffer;
char *sg_argv[CLI_ARG_SIZE];
u32 sg_argc;
if (cmd_data->cmd_in_proc)
return -1;
sg_cmd_buffer = cmd;
for (sg_argc = 0, ch = 0, pch = sg_cmd_buffer;
(*pch!=0x00) && (sg_argc<CLI_ARG_SIZE); pch++ )
{
// if (*pch == 0x0a || *pch == 0x0d)
// *pch = ' ';
if ( (ch==0) && (*pch!=' ') )
{
ch = 1;
sg_argv[sg_argc] = pch;
}
if ( (ch==1) && (*pch==' ') )
{
*pch = 0x00;
ch = 0;
sg_argc ++;
}
}
if ( ch == 1)
{
sg_argc ++;
}
else if ( sg_argc > 0 )
{
*(pch-1) = ' ';
}
if ( sg_argc > 0 )
{
/* Dispatch command */
for( sc_tbl=cmd_table; sc_tbl->cmd; sc_tbl ++ )
{
if ( !strcmp(sg_argv[0], sc_tbl->cmd) )
{
struct ssv_softc *sc;
struct ssv6xxx_hci_info *hci;
sc = container_of(cmd_data, struct ssv_softc, cmd_data);
hci = &sc->sh->hci;
if ( (sc_tbl->cmd_func_ptr != ssv_cmd_cfg)
&& (!hci->dev || !hci->if_ops || !sc->platform_dev)) {
cmd_data->ssv6xxx_result_buf = (char *)kzalloc(128, GFP_KERNEL);
if (!cmd_data->ssv6xxx_result_buf)
return -EFAULT;
cmd_data->ssv6xxx_result_buf[0] = 0x00;
snprintf_res(cmd_data, "Member of ssv6xxx_ifdebug_info is NULL !\n");
return -1;
}
cmd_data->ssv6xxx_result_buf = (char *)kzalloc(sc_tbl->result_buffer_size, GFP_KERNEL);
if (!cmd_data->ssv6xxx_result_buf)
return -EFAULT;
cmd_data->ssv6xxx_result_buf[0] = 0x00;
cmd_data->rsbuf_len = 0;
cmd_data->rsbuf_size = sc_tbl->result_buffer_size;
cmd_data->cmd_in_proc = true;
down_read(&sc->sta_info_sem);/* START protect sta_info */
ret = sc_tbl->cmd_func_ptr(sc, sg_argc, sg_argv);
up_read(&sc->sta_info_sem);/* END protect sta_info */
if (ret < 0) {
strcpy(cmd_data->ssv6xxx_result_buf, "Invalid command !\n");
}
bf_size = strlen(cmd_data->ssv6xxx_result_buf);
if ((sc_tbl->result_buffer_size -1) <= bf_size){
cmd_data->rsbuf_len = 0;
snprintf_res(cmd_data,
"\nALLOCATED BUFFER %d <= BUFFER USED +1 %d, OVERFLOW!!\n\n",
sc_tbl->result_buffer_size, bf_size+1);
} else {
snprintf_res(cmd_data, "\nALLOCATED BUFFER %d , BUFFER USED %d\n\n",
sc_tbl->result_buffer_size, bf_size);
}
return 0;
}
}
cmd_data->ssv6xxx_result_buf = (char *)kzalloc(64, GFP_KERNEL);
if (!cmd_data->ssv6xxx_result_buf)
return -EFAULT;
cmd_data->ssv6xxx_result_buf[0] = 0x00;
cmd_data->rsbuf_len = 0;
cmd_data->rsbuf_size = 64;
cmd_data->cmd_in_proc = true;
snprintf_res(cmd_data, "Command not found !\n");
return -EFAULT;
} else {
cmd_data->ssv6xxx_result_buf = (char *)kzalloc(64, GFP_KERNEL);
if (!cmd_data->ssv6xxx_result_buf)
return -EFAULT;
cmd_data->ssv6xxx_result_buf[0] = 0x00;
cmd_data->rsbuf_len = 0;
cmd_data->rsbuf_size = 64;
cmd_data->cmd_in_proc = true;
snprintf_res(cmd_data, "./cli -h\n");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink