payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
a4015c907c
nt9856x/code/driver/source/net/18211_nvtfmac/nvt_iw.c
payton 543d2da268 1.一次S530代码提交
2023-03-28 15:07:53 +08:00

3432 lines
111 KiB
C
Executable File
Raw Blame History

#include <linux/types.h>
#include <linux/kernel.h>
#include <net/iw_handler.h>
#include <linux/netdevice.h>
#include <linux/workqueue.h>
#include <linux/string.h>
/*AT Support ARP NS offload*/
#include <linux/rcupdate.h>
#include <linux/inetdevice.h>
/*AT Support for IPv6*/
#include <net/ipv6.h>
#include <net/if_inet6.h>
#include <linux/version.h>
#include <linux/if_ether.h>
#include "nvt_wlan_linux.h"
#include "nvt_bus.h"
#include "nvt_icfg.h"
#include "nvt_cfg80211.h"
#include "nvt_fw.h"
#include "nvt_util_dbg.h"
#include "nvt_icfg.h"
#include "nvt_iw.h"
#include "nvt_bus_sdioif.h"
#define NVT_IWPRIV_SETWID_RESP_LEN 16
#define NVT_IWPRIV_GETMIB_CMD_SIZE 32
#define NVT_IWPRIV_GETMIB_RSP_SIZE 512
#define NVT_IWPRIV_SETWID_CMD_SIZE 512
#define NVT_IWPRIV_GETWID_CMD_SIZE 64
/**
* _nvt_iwpriv_mib - MIB attribute entry
* The entry is to describe the related attribute for each "setmib" and
* "getmib" sub commands.
* The usage of "setmib" and "getmib":
*
* iwpriv <net_interface> setmib <sub_cmd>=<value>
* iwpriv <net_interface> getmib <sub_cmd>
*
* <sub_cmd> is a string name and <value> could be a number or a string.
*
* Basically, one <sub_cmd> maps to a WID message. If you specify the WID, we
* will send the WID when the related <sub_cmd> was exectued. You can also
* define your own handler, @setmib_handler, or @getmib_handler, for <sub_cmd>.
* If the handler was defined, we will call the handler directly. You can do
* what you need to do in your defined handlers.
*
* @name: iwpriv sub command name, <sub_cmd>, for "setmib" and "getmib"
* @wid: WID to be used
* @len_field_size: 1 for char, short, int, and string WID. 2 for binary WID
* @req_format: define <value> format, please refer to nvt_iwpriv_mib_req enum
* @resp_format: define response format, please refer to nvt_iwpriv_mib_resp
* enum
* @str_enum: string table for responsed WID value
* @enum_num: size of str_enum table
* @setmib_handler: user defined handler for the setmib sub command.
* This function would get <value> in ascii format.
* return 0 for success and a errno for fail
* @getmib_handler: user defined handler for the getmib sub command.
* If success, return 0, a string for displaying to
* the user, and the length of the string. a errno for
* fail
*
*
*/
struct _nvt_iwpriv_mib {
s8 *name;
u16 wid;
u8 len_field_size;
u8 req_format;
u8 resp_format;
s8 **str_enum;
s8 enum_num;
s32 (*setmib_handler)(struct _nvt_bus *, void *data, u8 *mib_value_str);
s32 (*getmib_handler)(struct _nvt_bus *, void *data, u8 *out_str,
u32 *out_len);
};
/**
* nvt_iwpriv_mib_req - defined the value type of iwpriv sub commands
* @REQ_CHAR_TYPE: char in hex format
* @REQ_SHORT_TYPE: short in hex format
* @REQ_INT_TYPE: int in hex format
* @REQ_STR_TYPE: a string in hex format
* @REQ_ENUM_STR_TYPE: use user defined string. We will compare the value of
* sub command with the enum table
* defined by
* struct _nvt_iwpriv_mib.str_enum, and
* use the matched enum index as WID
* value
* @REQ_RAW_ASCII_TYPE: format example: 1a,1b,1c,1d
*
*/
enum nvt_iwpriv_mib_req {
REQ_CHAR_TYPE = 0,
REQ_SHORT_TYPE,
REQ_INT_TYPE,
REQ_STR_TYPE,
REQ_ENUM_STR_TYPE,
REQ_RAW_ASCII_TYPE,
REQ_TYPE_NUM
};
/**
* nvt_iwpriv_mib_req - defined the display format
* @RSP_FORMAT_HEX: display result in hex format
* @RSP_FORMAT_ENUM_STRING:
* use user defined string. We will use returned WID value as enum index of
* struct _nvt_iwpriv_mib.str_enum to find the corresponding string
* for display
*
* @RSP_FORMAT_STRING: a string
* @RSP_FORMAT_BINARY: binary format, for example: 1a,1b,1c,1d
*
*/
enum nvt_iwpriv_mib_resp {
RSP_FORMAT_HEX = 0,
RSP_FORMAT_ENUM_STRING,
RSP_FORMAT_STRING,
RSP_FORMAT_BINARY,
RSP_FORMAT_NUM
};
static s8 *str_enable_disable[] = {
"Disable",
"Enable"
};
static s8 *str_power_save_mode[] = {
"Disable",
"Min_FAST_PS",
"Max_FAST_PS",
"Min_PSPOOL_PS",
"Max_PSPOOL_PS",
"User_Cfg_PS"
};
static s8 *str_short_gi[] = {
"Long_GI",
"Short_GI-20",
"Short_GI-40",
"Short_GI-20/40"
};
//20160322 nash:
#ifdef BUS_UTILIZATION
static s8 *str_bu_tx_mode[] = {
"var",
"allone",
"allzero",
"seq",
"ran"
};
#endif
static s32 nvt_send_wid_set(struct _nvt_bus *nvt_bus, u16 wid, u8 *wid_val_str);
static s32 nvt_byte_to_hex_str(u8 *wid_start_val, s32 wid_value_byte_len,
u8 data_byte, u8 *out_str, char **headers);
static s8 *str_legacy_mode[] = {
"B_Only",
"G_Only",
"B/G_Mix1",
"B/G_Mix2"
};
#ifdef CONFIG_WIFI_TUNING_PHASE_II
static s32 nvt_tpm_sta_stats(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _nvt_priv *nvt_priv = &nvt_adapter->nvt_priv;
struct _sta_sts_in_ap *sta_sts_in_ap;
nvt_dbg(ERROR, "%s:\n", __func__);
list_for_each_entry(sta_sts_in_ap, &nvt_priv->sta_list_in_ap, list)
{
if (sta_sts_in_ap) {
printk("STA: %02x:%02x:%02x:%02x:%02x:%02x !\n",
sta_sts_in_ap->mac_addr[0], sta_sts_in_ap->mac_addr[1],
sta_sts_in_ap->mac_addr[2], sta_sts_in_ap->mac_addr[3],
sta_sts_in_ap->mac_addr[4], sta_sts_in_ap->mac_addr[5]);
printk("Tput:%d Byte/s, Phy_rate:%d\n",
sta_sts_in_ap->t_put, sta_sts_in_ap->phyrate);
}
}
*outlen = strlen(out_str);
return 0;
}
#endif
static s32 nvt_set_fc_borrow(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_val_str)
{
ulong flags;
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
s32 ret = 0;
spin_lock_irqsave(&tx_info->lock, flags);
if (strcmp(mib_val_str, "1") == 0) {
tx_info->is_credit_borrow = 1;
} else {
tx_info->is_credit_borrow = 0;
}
spin_unlock_irqrestore(&tx_info->lock, flags);
if (nvt_icfg_lock(nvt_bus) < 0) {
ret = -1;
goto next_check;
}
if (nvt_icfg_reset(nvt_bus) < 0) {
ret = -1;
goto next_check;
}
if (nvt_icfg_add(nvt_bus, NVT_ICFG_SET, WID_FC_BORROW,
(u8 *)&(tx_info->is_credit_borrow),
sizeof(tx_info->is_credit_borrow)) < 0) {
ret = -1;
goto next_check;
}
if (nvt_icfg_send_and_get_resp(nvt_bus, NULL, 0) < 0) {
ret = -1;
goto next_check;
}
next_check:
nvt_icfg_unlock(nvt_bus);
return ret;
}
static s32 nvt_get_fc_borrow_flag(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen) {
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%x",
tx_info->is_credit_borrow);
*outlen = strlen(out_str);
return 0;
}
static s32 set_watermark(u32 watermark, bool is_high_watermark,
void *data) {
#ifndef CONFIG_WIFI_TUNING_PHASE_I
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
//struct _nvt_priv nvt_priv = nvt_adapter->nvt_priv;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
if (is_high_watermark) {
tx_info->fc_hi_watermark = watermark;
} else {
tx_info->fc_low_watermark = watermark;
}
#endif
return 0;
}
static s32 get_watermark(bool is_high_watermark, void *data)
{
#ifndef CONFIG_WIFI_TUNING_PHASE_I
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
//struct _nvt_priv nvt_priv = nvt_adapter->nvt_priv;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
if (is_high_watermark) {
return tx_info->fc_hi_watermark;
} else {
return tx_info->fc_low_watermark;
}
#endif
return 0;
}
static s32 nvt_set_hwatermark_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
s32 ret;
u32 watermark = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 16, &watermark);
if (ret < 0) {
return -EINVAL;
}
ret = set_watermark(watermark, true, data);
return ret;
}
static s32 nvt_get_hwatermark_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen) {
u32 watermark = get_watermark(true, data);
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%x", watermark);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_lwatermark_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
s32 ret;
u32 watermark = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 16, &watermark);
if (ret < 0) {
return -EINVAL;
}
ret = set_watermark(watermark, false, data);
return ret;
}
static s32 nvt_get_lwatermark_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen) {
u32 watermark = get_watermark(false, data);
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%x", watermark);
*outlen = strlen(out_str);
return 0;
}
/*handle the set fix rate[for legacy rate or mcs] WID
* iwpriv wlan0 setmib rate=mcs,legacy_rate
* mcs = 0,1,2,3...15
* legacy = 1, 2, 5, 11, 36, 48, 54
*/
static s32 nvt_set_rate_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
u8 const *delim = ",";
char *mcs = strsep((char **)&mib_value_str, delim);
char *legacy = mib_value_str;
u8 const *autorate = "0";
u8 config_mcs = 0xFF;
if (mcs == NULL || legacy == NULL) {
return -EINVAL;
}
if (strcmp(mcs, "FF") == 0 && strcmp(legacy, "FF") != 0) {
return nvt_send_wid_set(nvt_bus, WID_CURRENT_TX_RATE,
(u8 *)legacy);
} else if (strcmp(mcs, "FF") != 0 && strcmp(legacy, "FF") == 0) {
nvt_send_wid_by_numeric(nvt_bus, WID_CURRENT_TX_RATE,
&config_mcs, 1);
return nvt_send_wid_set(nvt_bus, WID_11N_CURRENT_TX_MCS,
(u8 *)mcs);
/*Enable the autorate*/
} else if (strcmp(mcs, "FF") == 0 && strcmp(legacy, "FF") == 0) {
return nvt_send_wid_set(nvt_bus, WID_CURRENT_TX_RATE,
(u8 *)autorate);
} else {
return -EINVAL;
}
return 0;
}
static s32 nvt_get_rate_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
u8 wid_val_pos;
u8 wid_is_autorate;
s32 wid_rate_val;
s32 ret_val;
u8 resp[512] = {0};
u32 buff_size = 512;
wid_val_pos = 0;
/*send wid to get the rate0 info*/
ret_val = nvt_get_wid_value(nvt_bus, WID_RATE_0, resp,
buff_size, &wid_val_pos);
/* check if wid_val_pos is correctly initialized */
if (ret_val < 0) {
return -1;
}
/*if b7 of rate_0 is 1 => ht_type*/
if (resp[wid_val_pos] & 0x0080) {
nvt_if->ht_type = 1;
} else {
nvt_if->ht_type = 0;
}
wid_rate_val = nvt_parse_rate_0(resp[wid_val_pos]);
if (wid_rate_val < 0) {
return -1;
}
/*send wid to get is autorate*/
ret_val = nvt_get_wid_value(nvt_bus, WID_CURRENT_TX_RATE, resp,
buff_size, &wid_val_pos);
if (ret_val < 0) {
return -1;
}
wid_is_autorate = resp[wid_val_pos];
if (nvt_if->ht_type == 0 && !wid_is_autorate) {
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE,
"autorate enable,legacy_rate : %d mbps" ,
wid_rate_val / 1000);
} else if (nvt_if->ht_type == 0 && wid_is_autorate) {
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE,
"autorate disable,legacy_rate : %d mbps"
, wid_rate_val / 1000);
} else if (nvt_if->ht_type == 1 && !wid_is_autorate) {
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE,
"autorate enable,mcs_rate : %x", wid_rate_val);
} else if (nvt_if->ht_type == 1 && wid_is_autorate) {
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE,
"autorate disable,mcs_rate : %x", wid_rate_val);
} else {
return -1;
}
*outlen = strlen(out_str);
return 0;
}
/*** This function get the first IPv4 address from net_device ***/
s32 nvt_get_first_ipv4(struct net_device *data, u8 *ret_addr)
{
struct in_device *in_dev;
struct in_ifaddr *ifa;
rcu_read_lock();
in_dev = rcu_dereference(data->ip_ptr);
if (in_dev != NULL) {
ifa = in_dev->ifa_list;
if (ifa != NULL) {
memcpy(ret_addr, &ifa->ifa_address, 4);
} else {
nvt_dbg(CFG80211, "%s IPv4 is not set\n"
, __func__);
return -1;
}
} else {
nvt_dbg(CFG80211, "%s IPv4 is not set\n", __func__);
return -1;
}
rcu_read_unlock();
return 0;
}
void nvt_get_mac_from_ip(struct net_device *dev, u8 *ret_addr,
u8 *server_ip)
{
struct neighbour *neigh;
__be32 ip = *((__be32 *) (server_ip));
neigh = neigh_lookup(&arp_tbl, &ip, dev);
if (neigh) {
read_lock_bh(&neigh->lock);
memcpy(ret_addr, neigh->ha, dev->addr_len);
read_unlock_bh(&neigh->lock);
neigh_release(neigh);
}
}
struct inet6_dev *__nvt_in6_dev_get(const struct net_device *dev)
{
return rcu_dereference_rtnl(dev->ip6_ptr);
}
//Called by nvt_ipv6_get_lladdr
int __nvt_ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
unsigned char banned_flags)
{
struct inet6_ifaddr *ifp;
int err = -EADDRNOTAVAIL;
list_for_each_entry(ifp, &idev->addr_list, if_list) {
if (ifp->scope == IFA_LINK &&
!(ifp->flags & banned_flags)) {
*addr = ifp->addr;
err = 0;
break;
}
}
return err;
}
/*Get the IPv6 address, since ipv6_get_lladdr does not export
*Add nvt as prefix for the new name
* */
int nvt_ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
unsigned char banned_flags)
{
struct inet6_dev *idev;
int err = -EADDRNOTAVAIL;
rcu_read_lock();
idev = __nvt_in6_dev_get(dev);
if (idev) {
read_lock_bh(&idev->lock);
err = __nvt_ipv6_get_lladdr(idev, addr, banned_flags);
read_unlock_bh(&idev->lock);
}
rcu_read_unlock();
return err;
}
/*** This function get the first IPv6 address from net_device ***/
s32 nvt_get_first_ipv6(struct net_device *data, u8 *ret_addr)
{
struct in6_addr *addr;
addr = kmalloc(sizeof(struct in6_addr), GFP_KERNEL);
if (!addr) {
return -1;
}
nvt_ipv6_get_lladdr(data, addr, 0);
if (addr != NULL && addr->in6_u.u6_addr8 != NULL) {
memcpy(ret_addr, addr->in6_u.u6_addr8, 16);
} else {
kfree(addr);
return -1;
}
kfree(addr);
return 0;
}
static s32 nvt_ka_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
u8 ip_addr[4];
char *ip_addr_str[4];
u16 timeout;
u8 ip_index = 0;
u8 const *delim = ",";
u8 *ka_buf;
u8 i;
s32 ret = 0;
char *ip_index_str = strsep((char **)&mib_value_str, delim);
char *timeout_str = strsep((char **)&mib_value_str, delim);
ip_addr_str[0] = strsep((char **)&mib_value_str, delim);
ip_addr_str[1] = strsep((char **)&mib_value_str, delim);
ip_addr_str[2] = strsep((char **)&mib_value_str, delim);
ip_addr_str[3] = mib_value_str;
for (i = 0; i < 4; i++) {
kstrtou8(ip_addr_str[i], 16, &ip_addr[i]);
}
kstrtou16(timeout_str, 16, &timeout);
kstrtou8(ip_index_str, 16, &ip_index);
/* 1B:ip_addr_index, 2B:timeout, 4B: ip_address */
ka_buf = kzalloc(1 + 2 + 4, GFP_ATOMIC);
if (ka_buf == 0) {
goto fail;
}
ka_buf[0] = ip_index;
*((u16 *)(ka_buf + 1)) = timeout;
memcpy(ka_buf + 3, ip_addr, 4);
/* 7 is the buffer size */
ret = nvt_send_wid_by_numeric(nvt_bus, WID_KEEP_ALIVE_FAIL_OFFLOAD,
ka_buf, 7);
fail:
kfree(ka_buf);
return ret;
}
static s32 nvt_dhcp_renew_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
/** data buffer sent to FW **/
u8 dhcp_to_cnts;
u8 dhcp_pat_int;
u8 s_ip_addr[4];
u8 c_ip_addr[4];
u8 i;
u8 const *delim = ",";
u8 *dhcp_buf;
s32 buf_size;
u32 lease_time;
s32 ret = 0;
char *s_ip_char[4];
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
char *dhcp_timeout_cnts = strsep((char **)&mib_value_str, delim);
char *dhcp_pat_interval = strsep((char **)&mib_value_str, delim);
char *lease_time_char = strsep((char **)&mib_value_str, delim);
s_ip_char[0] = strsep((char **)&mib_value_str, delim);
s_ip_char[1] = strsep((char **)&mib_value_str, delim);
s_ip_char[2] = strsep((char **)&mib_value_str, delim);
s_ip_char[3] = mib_value_str;
for (i = 0; i < 4; i++) {
kstrtou8(s_ip_char[i], 16, &s_ip_addr[i]);
}
kstrtou8(dhcp_timeout_cnts, 16, &dhcp_to_cnts);
kstrtou8(dhcp_pat_interval, 16, &dhcp_pat_int);
kstrtou32(lease_time_char, 16, &lease_time);
nvt_get_first_ipv4((struct net_device *)data, c_ip_addr);
/*** Sanity check ***/
if (dhcp_timeout_cnts == NULL || dhcp_pat_interval == NULL) {
return -EINVAL;
}
//size = 1B:to_cnt, 1B:pat_interval, 4B:lease_time, 6B S_HW
buf_size = 1 + 1 + 4 + 6 + sizeof(struct dhcp_ip) +
sizeof(struct dhcp_udp) +
sizeof(struct dhcp_packet);
//fill the wid value buffer
dhcp_buf = kzalloc(buf_size, GFP_ATOMIC);
if (dhcp_buf == 0) {
goto fail;
}
dhcp_buf[0] = dhcp_to_cnts;
dhcp_buf[1] = dhcp_pat_int;
*((u32 *)(dhcp_buf + 2)) = lease_time;
dhcp_buf += 6;
//get the server mac address from the arp table
nvt_get_mac_from_ip((struct net_device *)data, dhcp_buf,
s_ip_addr);
//check if ARP table is empty
ret = 0;
for (i = 0; i < 6; i++) {
ret |= dhcp_buf[i];
}
if (ret == 0) {
nvt_dbg(ERROR, "%s: ARP Table Empty\n",
__func__);
goto arp_empty;
}
dhcp_buf += 6;
//create dhcp pattern
build_dhcp_renew_pat(dhcp_buf, c_ip_addr, s_ip_addr,
nvt_if->nvt_adapter->mac_addr);
//back to the head of wid value buffer
dhcp_buf -= 12;
ret = nvt_send_wid_by_numeric(nvt_bus, WID_DHCP_RENEW_OFFLOAD,
dhcp_buf, buf_size);
arp_empty:
kfree(dhcp_buf);
return ret;
fail:
return -1;
}
/***** This function set the offload flag and set the IP address *****/
static s32 nvt_set_offload_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
/** data buffer sent to FW **/
u8 *wid_val_buf;
u8 const *delim = ",";
u8 offload_mask = 0;
u8 offload_tmp_bit = 0;
char *arp_offload_flag = strsep((char **)&mib_value_str, delim);
char *ns_offload_flag = mib_value_str;
s32 ret = 0;
/*** Sanity check ***/
if (ns_offload_flag == NULL || arp_offload_flag == NULL) {
return -EINVAL;
}
/*** oring arp flag to offload_mask ***/
kstrtou8(arp_offload_flag, 16, &offload_tmp_bit);
offload_mask |= offload_tmp_bit << 7;
/*** oring ns flag to offload_mask ***/
kstrtou8(ns_offload_flag, 16, &offload_tmp_bit);
offload_mask |= offload_tmp_bit << 6;
/*** turnnig off both flag off ***/
if (offload_mask == 0) {
return nvt_send_wid_by_numeric(nvt_bus, WID_ARP_NS_OFFLOAD,
&offload_mask, 1);
/*** set the ns_offload flag on ***/
} else if (offload_mask == 64) {
wid_val_buf = kzalloc(17, GFP_KERNEL);
if (wid_val_buf == NULL) {
goto fail;
}
*wid_val_buf = offload_mask;
nvt_get_first_ipv6((struct net_device *)data, wid_val_buf + 1);
ret = nvt_send_wid_by_numeric(nvt_bus, WID_ARP_NS_OFFLOAD,
wid_val_buf, 17);
if (ret < 0) {
nvt_dbg(ERROR, "%s: WID_ARP_NS_OFFLOAD fail\n",
__func__);
}
kfree(wid_val_buf);
/*** set the arp_offload flag on ***/
} else if (offload_mask == 128) {
wid_val_buf = kzalloc(5, GFP_KERNEL);
if (wid_val_buf == NULL) {
goto fail;
}
*wid_val_buf = offload_mask;
nvt_get_first_ipv4((struct net_device *)data, wid_val_buf + 1);
ret = nvt_send_wid_by_numeric(nvt_bus, WID_ARP_NS_OFFLOAD,
wid_val_buf, 5);
if (ret < 0) {
nvt_dbg(ERROR, "%s: WID_ARP_NS_OFFLOAD fail\n",
__func__);
}
kfree(wid_val_buf);
/*** set the arp and ns offload flag on ***/
} else if (offload_mask == 192) {
wid_val_buf = kzalloc(21, GFP_KERNEL);
if (wid_val_buf == NULL) {
goto fail;
}
*wid_val_buf = offload_mask;
nvt_get_first_ipv4((struct net_device *)data, wid_val_buf + 1);
nvt_get_first_ipv6((struct net_device *)data, wid_val_buf + 5);
ret = nvt_send_wid_by_numeric(nvt_bus, WID_ARP_NS_OFFLOAD,
wid_val_buf, 21);
if (ret < 0) {
nvt_dbg(ERROR, "%s: WID_ARP_NS_OFFLOAD fail\n",
__func__);
}
kfree(wid_val_buf);
} else {
nvt_dbg(ERROR, "%s: offload_mask is not right\n", __func__);
return -1;
}
return 0;
fail:
return -1;
}
/***** This funtion get the offload flag *****/
static s32 nvt_get_offload_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
bool arp_flag;
bool ns_flag;
s32 ret_val;
u8 offload_mask;
u8 wid_val_pos;
u8 resp[512] = {0};
u32 buff_size = 512;
wid_val_pos = 0;
/*send wid to get the rate0 info*/
ret_val = nvt_get_wid_value(nvt_bus, WID_ARP_NS_OFFLOAD, resp,
buff_size, &wid_val_pos);
if (ret_val < 0) {
return -1;
}
offload_mask = resp[wid_val_pos];
arp_flag = offload_mask & 1<<7;
ns_flag = offload_mask & 1<<6;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE,
"arp_offload_flag : %d ns_offload_flag : %d\n",
arp_flag, ns_flag);
*outlen = strlen(out_str);
return 0;
}
#ifdef CONFIG_PM
static s32 nvt_set_wow_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 10, 0)
struct wireless_dev *wdev = ((struct net_device *)data)->ieee80211_ptr;
struct wiphy *wiphy = wdev->wiphy;
struct cfg80211_wowlan *wow = wiphy->wowlan_config;
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_cfg80211 *nvt_cfg = nvt_if->nvt_adapter->nvt_cfg80211;
if (strcmp(mib_value_str, "1") == 0) {
if (wow != NULL) {
if (nvt_setup_wowlan(nvt_if, nvt_cfg, wow) == 0) {
nvt_dbg(INFO, "enable wow ok\n");
nvt_cfg->wow_enable = 1;
} else {
nvt_dbg(ERROR, "enable wow fail\n");
nvt_cfg->wow_enable = 0;
}
}
} else {
nvt_dbg(INFO, "disable wow\n");
nvt_cfg->wow_enable = 0;
}
#endif
return 0;
}
static s32 nvt_get_wow_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_cfg80211 *nvt_cfg = nvt_if->nvt_adapter->nvt_cfg80211;
if (nvt_cfg->wow_enable == 1) {
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "wowlan enable");
} else {
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "wowlan disable");
}
*outlen = strlen(out_str);
return 0;
}
#endif
#ifdef BUS_UTILIZATION
static s32 nvt_set_bus_utilization_mode(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
s32 i;
s32 elem_num;
if (nvt_bus == NULL) {
nvt_dbg(ERROR, "%s: nvt_bus is NULL!\n", __func__);
return -EPERM;
}
elem_num = sizeof(str_bu_tx_mode) / sizeof(str_bu_tx_mode[0]);
for (i = 0; i < elem_num; i++) {
if (strcmp(mib_value_str, str_bu_tx_mode[i]) == 0) {
nvt_bus->nvt_bu->tx_mode = i;
break;
}
}
if (i == elem_num) {
nvt_dbg(ERROR, "%s: Invalid BU TX mode!!\n", __func__);
}
return 0;
}
static s32 nvt_get_bus_utilization_mode(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
s32 elem_num;
if (nvt_bus == NULL) {
nvt_dbg(ERROR, "%s: nvt_bus is NULL!\n", __func__);
return -EPERM;
}
elem_num = sizeof(str_bu_tx_mode) / sizeof(str_bu_tx_mode[0]);
if (nvt_bus->nvt_bu->tx_mode >= elem_num) {
nvt_dbg(ERROR, "%s: tx mode error\n", __func__);
return -EPERM;
}
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "TX mode=%s\n",
str_bu_tx_mode[nvt_bus->nvt_bu->tx_mode]);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_bu_send_pkt(struct _nvt_bus *nvt_bus)
{
s32 i;
s32 ret;
u32 len;
u32 pkt_len;
u32 tx_hdr_lo = 0;
u32 tx_hdr_hi = 0;
s32 nvt_txhdr_sz = 8;
struct sk_buff *skb;
if (nvt_bus == NULL) {
nvt_dbg(ERROR, "%s: nvt_bus is NULL!\n", __func__);
return -EPERM;
}
// bit19: ethernet frame
tx_hdr_lo |= (0x00080000);
tx_hdr_lo = cpu_to_be32(tx_hdr_lo);
if (nvt_bus->nvt_bu->tx_mode == NVT_BUS_BU_TX_VARIABLE_LEN) {
get_random_bytes(&pkt_len, 2);
pkt_len %= ETH_FRAME_LEN;
//set min frame size as 16 bytes
if (pkt_len < 16) {
pkt_len = 16;
}
len = roundup((pkt_len + nvt_txhdr_sz), NVT_SDIO_F1_BLOCKSIZE);
skb = dev_alloc_skb(len);
if (skb == NULL) {
nvt_dbg(ERROR, "%s: skb alloc fail!\n", __func__);
return -1;
}
} else if (nvt_bus->nvt_bu->tx_mode == NVT_BUS_BU_TX_ALL_ONE) {
pkt_len = roundup((ETH_FRAME_LEN + nvt_txhdr_sz),
NVT_SDIO_F1_BLOCKSIZE);
skb = dev_alloc_skb(pkt_len);
if (skb == NULL) {
nvt_dbg(ERROR, "%s: skb alloc fail!\n", __func__);
return -1;
}
memset(skb->data, 0xFF, pkt_len);
} else if (nvt_bus->nvt_bu->tx_mode == NVT_BUS_BU_TX_ALL_ZERO) {
pkt_len = roundup((ETH_FRAME_LEN + nvt_txhdr_sz),
NVT_SDIO_F1_BLOCKSIZE);
skb = dev_alloc_skb(pkt_len);
if (skb == NULL) {
nvt_dbg(ERROR, "%s: skb alloc fail!\n", __func__);
return -1;
}
memset(skb->data, 0x00, pkt_len);
} else if (nvt_bus->nvt_bu->tx_mode == NVT_BUS_BU_TX_SEQ) {
pkt_len = roundup((ETH_FRAME_LEN + nvt_txhdr_sz),
NVT_SDIO_F1_BLOCKSIZE);
skb = dev_alloc_skb(pkt_len);
if (skb == NULL) {
nvt_dbg(ERROR, "%s: skb alloc fail!\n", __func__);
return -1;
}
for (i = nvt_txhdr_sz; i < pkt_len; i++) {
skb->data[i] = (i - nvt_txhdr_sz) & 0xFF;
}
} else if (nvt_bus->nvt_bu->tx_mode == NVT_BUS_BU_TX_RANDOM) {
pkt_len = roundup((ETH_FRAME_LEN + nvt_txhdr_sz),
NVT_SDIO_F1_BLOCKSIZE);
skb = dev_alloc_skb(pkt_len);
if (skb == NULL) {
nvt_dbg(ERROR, "%s: skb alloc fail!\n", __func__);
return -1;
}
for (i = nvt_txhdr_sz; i < pkt_len; i++) {
skb->data[i] = (i - nvt_txhdr_sz) & 0xFF;
}
} else {
return -1;
}
// bit[23:16]: offset
// bit[15:00]: pkt len (hdr doesn't be included)
tx_hdr_hi = ((pkt_len) & 0xffff);
tx_hdr_hi |= (0x00080000);
tx_hdr_hi = cpu_to_be32(tx_hdr_hi);
skb_put(skb, pkt_len);
memcpy(skb->data, (u8 *)&tx_hdr_lo, 4);
memcpy((skb->data+4), (u8 *)&tx_hdr_hi, 4);
ret = nvt_bus->nvt_wdev_bus_ops.tx_data(nvt_bus, skb);
if (ret) {
nvt_dbg(ERROR, "%s: nvt_bus_txdata fail!\n", __func__);
dev_kfree_skb_any(skb);
return -1;
}
return 0;
}
static s32 nvt_set_bus_utilization_tx(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
s32 i;
s32 ret;
u32 tx_cnt = 0;
if (nvt_bus == NULL) {
nvt_dbg(ERROR, "%s: nvt_bus is NULL!\n", __func__);
return -EPERM;
}
ret = kstrtou32((s8 *)mib_value_str, 10, &tx_cnt);
if (ret) {
return -EINVAL;
}
if (tx_cnt > 10000000) {
return -EINVAL;
}
ret = nvt_bus_bu_tx_on(nvt_bus, true, tx_cnt);
for (i = 0; i < tx_cnt; i++) {
ret = nvt_bu_send_pkt(nvt_bus);
if (ret) {
nvt_dbg(ERROR, "%s: nvt_bu_send_pkt() fail!!\n",
__func__);
return -1;
}
}
return 0;
}
static s32 nvt_set_bus_utilization_rx(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
s32 ret;
s32 rx_cnt = 0;
if (nvt_bus == NULL) {
nvt_dbg(ERROR, "%s: nvt_bus is NULL!\n", __func__);
return -EPERM;
}
ret = kstrtou32((s8 *)mib_value_str, 10, &rx_cnt);
if (ret) {
return -EINVAL;
}
if (rx_cnt > 10000000) {
return -EINVAL;
}
nvt_bus_bu_rx_on(nvt_bus, true, rx_cnt);
return 0;
}
#endif /* #ifdef BUS_UTILIZATION */
static s32 nvt_get_mode(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
u8 bssMode = nvt_if->mode;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "bss mode : %x", bssMode);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_get_umac_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
char *headers[] = {"rxAll", "rxDat", "rxMgm",
"rxCrt", "rxDp", "amsdu", "ampdu",
"rxIsr", "rxEmp", "queRx", "queTx"};
u8 wid_val_pos;
s32 wid_val_byte_len;
u8 resp[512] = {0};
u32 buff_size = 512;
wid_val_pos = 0;
wid_val_byte_len = nvt_get_wid_value(nvt_bus, WID_GET_UMAC_STATS,
resp, buff_size, &wid_val_pos);
if (wid_val_byte_len < 0) {
return -1;
}
nvt_byte_to_hex_str(&resp[wid_val_pos],
wid_val_byte_len, 4, out_str, headers);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_get_lmac_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
u8 val_start_pos;
u8 i;
s32 wid_val_byte_len;
/*data headers*/
char *rx_headers[] = {"rq1", "rq2"};
//char *gmax_tx_done[] = {"gmax_tx_done"};
//char *txqs[] = {"num_tx_q"};
char *tx_ok_drop[10];
//char *err[] = {"err"};
char *error_bits[24];
u8 resp[512] = {0};
u32 buff_size = 512;
val_start_pos = 0;
/* AT 20150810: Format of the byte data read from fw
* ======================================================
* | rx_frame_1 | rx_frame_2 | g_max_tx_done | #Txqs |
* ======================================================
* | 0:3 | 4:7 | 8:8 | 9:10 |
* ======================================================
* | tx_ok_1 | tx_drop_1 | tx_ok_2 | tx_drop_2|
* ======================================================
* | 11:14 | 15:18 | 19:22 | 23:26 |
* ======================================================
* | tx_ok_3 | tx_drop_3 | tx_ok_4 | tx_drop_4|
* ======================================================
* | 27:30 | 31:34 | 35:38 | 39:42 |
* ======================================================
* | tx_ok_5 | tx_drop_5 | Error | err_1 |
* ======================================================
* | 43:46 | 47:50 | 51:51 | 52:56 |
* ======================================================
* | err_2 | err_3 | err_4 | err_5 |
* ======================================================
* | 57:60 | 61:64 | 65:68 | 69:72 |
* ======================================================
* ..... to err_24
*
* */
/*Init the data headers*/
for (i = 0; i < 5; i++) {
tx_ok_drop[2 * i] = kzalloc(10, GFP_KERNEL);
snprintf(tx_ok_drop[2 * i], NVT_IWPRIV_GETMIB_RSP_SIZE,
"txOk%d", i);
tx_ok_drop[2 * i + 1] = kzalloc(10, GFP_KERNEL);
snprintf(tx_ok_drop[2 * i + 1], NVT_IWPRIV_GETMIB_RSP_SIZE,
"txDp%d", i);
}
/*Init the error headers*/
for (i = 0; i < 20; i++) {
error_bits[i] = kzalloc(13, GFP_KERNEL);
snprintf(error_bits[i], NVT_IWPRIV_GETMIB_RSP_SIZE,
"err%d", i);
}
wid_val_byte_len = nvt_get_wid_value(nvt_bus, WID_GET_LMAC_STATS,
resp, buff_size, &val_start_pos);
if (wid_val_byte_len < 0) {
goto fail;
}
/*Starting concat strings */
/*rx_frame_1 and rx_frame_2*/
nvt_byte_to_hex_str(&resp[val_start_pos],
8, 4, out_str, rx_headers);
/*nvt_byte_to_hex_str(&resp[val_start_pos + 8],
1, 1, out_str + 23 * 2, gmax_tx_done);
nvt_byte_to_hex_str(&resp[val_start_pos + 9],
2, 2, out_str + 23 * 3, txqs);*/
/*tx_ok and tx_drop*/
nvt_byte_to_hex_str(&resp[val_start_pos + 11],
40, 4, out_str + 15 * 2, tx_ok_drop);
//nvt_byte_to_hex_str(&resp[val_start_pos + 51],
// 1, 1, out_str + 23 * 14, err);
nvt_byte_to_hex_str(&resp[val_start_pos + 52],
80, 4, out_str + 15 * 12, error_bits);
*outlen = strlen(out_str);
fail:
/*Free the buffers*/
for (i = 0; i < 10; i++) {
kfree(tx_ok_drop[i]);
}
/*Init the error headers*/
for (i = 0; i < 20; i++) {
kfree(error_bits[i]);
}
if (wid_val_byte_len < 0)
return -1;
else
return 0;
}
static s32 nvt_iwpriv_getmib_fver(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *out_len)
{
return nvt_fw_get_ver(nvt_bus, out_str, out_len);
}
static s32 nvt_get_autorate_parameter(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
u8 wid_val_pos;
s32 wid_val_byte_len;
u8 resp[512] = {0};
u16 interval, divitor, remainder;
u32 buff_size = 512;
wid_val_pos = 0;
wid_val_byte_len = nvt_get_wid_value(nvt_bus, WID_AR_PARAMETER,
resp, buff_size, &wid_val_pos);
if (wid_val_byte_len < 0) {
return -1;
}
divitor = resp[wid_val_pos+2];
divitor = divitor << 8;
remainder = resp[wid_val_pos+3];
interval = divitor + remainder;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE,
"%02u,%1u,%05u,%02u,%02u,%1u\n", resp[wid_val_pos],
resp[wid_val_pos+1], interval, resp[wid_val_pos+4],
resp[wid_val_pos+5], resp[wid_val_pos+6]);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_autorate_parameter(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
u8 const *delim = ",";
char *mib_val;
char set_val[14] = {0};
int n = 0, i;
u8 *str_tmp;
s32 ret;
while ((mib_val = strsep((char **)&mib_value_str, delim)) != NULL) {
n += sprintf(set_val+n, "%s", mib_val);
}
str_tmp = kzalloc(strlen(set_val)*3, GFP_KERNEL);
if (str_tmp == NULL) {
nvt_dbg(ERROR, "%s: kzalloc fail\n", __func__);
return -ENOMEM;
}
for (i = 0; i < strlen(set_val); i++) {
if (i == strlen(set_val) - 1) {
snprintf((str_tmp + i*3),
(strlen(set_val) - i) * 3,
"%02x",
*(set_val + i));
} else {
snprintf((str_tmp + i*3),
(strlen(set_val) - i) * 3,
"%02x,",
*(set_val + i));
}
}
ret = nvt_send_wid_set(nvt_bus, WID_AR_PARAMETER, str_tmp);
kfree(str_tmp);
return ret;
}
static s32 nvt_set_channel_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_wlan_conf_ap *wconf_ap = &nvt_if->nvt_wconf_ap;
s32 ret = 0;
u8 acs_channel = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou8(mib_value_str, 10, &acs_channel);
if (ret < 0) {
return -EINVAL;
}
if (acs_channel <= 14) {
nvt_dbg(CFG80211, "%s:acs_channel=%d\n", __func__, acs_channel);
wconf_ap->acs_channel = acs_channel;
} else if ((36 <= acs_channel) && (acs_channel <= 165)) {
nvt_dbg(ERROR, "%s:5G not implement yet\n", __func__);
//wconf->acs_channel = acs_channel;
return -EINVAL;
} else {
nvt_dbg(ERROR, "%s:invalid ch=%d\n", __func__, acs_channel);
return -EINVAL;
}
return ret;
}
static s32 nvt_get_channel_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen) {
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_wlan_conf_ap *wconf_ap = &nvt_if->nvt_wconf_ap;
u8 acs_channel = wconf_ap->acs_channel;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%d", acs_channel);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_acs_mask_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_wlan_conf_ap *wconf_ap = &nvt_if->nvt_wconf_ap;
s32 ret = 0;
u32 acs_mask = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 10, &acs_mask);
if (ret < 0) {
return -EINVAL;
}
if (acs_mask < (1 << 15)) {
nvt_dbg(CFG80211, "%s:ch_mask=0x%x\n", __func__, acs_mask);
wconf_ap->acs_mask = acs_mask;
} else {
nvt_dbg(ERROR, "%s:invalid mask=0x%x\n", __func__, acs_mask);
return -EINVAL;
}
return ret;
#if 0
while ((val = strsep((char **)&mib_value_str, delim)) != NULL) {
ret = kstrtou32(val, 10, &int_val);
if (ret < 0) {
return -EINVAL;
}
nvt_dbg(ERROR, "%s:val=%d, int_val=%d\n", __func__, *val,
int_val);
if ((1 <= int_val) && (int_val <= 14)) {
temp |= (1 << (int_val - 1));
} else if ((36 <= int_val) && (int_val <= 165)) {
nvt_dbg(ERROR, "%s:5G not implement yet\n", __func__);
return -EINVAL;
} else {
nvt_dbg(ERROR, "%s:invalid ch=%d\n", __func__, int_val);
return -EINVAL;
}
}
wconf_ap->acs_mask = temp;
return ret;
#endif
}
static s32 nvt_get_acs_mask_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen) {
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_wlan_conf_ap *wconf_ap = &nvt_if->nvt_wconf_ap;
u32 acs_mask = wconf_ap->acs_mask;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%d", acs_mask);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_wow_scanfrq(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
u8 const *delim = ",";
s32 ret = 0;
u8 *mib_val = NULL;
u8 i = 0;
u8 index = 0;
u32 int_val = 0;
u8 *recover_buf = nvt_if->recover_buf;
if (mib_value_str == NULL) {
return -EINVAL;
}
while ((mib_val = strsep((char **)&mib_value_str, delim)) != NULL) {
ret = kstrtou32(mib_val, 10, &int_val);
if (ret < 0) {
goto fail;
}
//sanity check
switch (i) {
case 0: /*enable */
if (int_val > 1) {
nvt_dbg(ERROR, "%s:invalid enable val=%d\n",
__func__, int_val);
goto fail;
}
recover_buf[index++] = (u8)int_val;
break;
case 1: /* scan duty */
case 6: /* per channel scan timeout */
if (int_val > 65535) {
nvt_dbg(ERROR, "%s:invalid enable val=%d\n",
__func__, int_val);
goto fail;
}
recover_buf[index++] = (u8)int_val & 0xff;
recover_buf[index++] = (u8)(int_val >> 8) & 0xff;
break;
case 4: /* recover timeout MAX timeout value is one day*/
if (int_val > 86400) {
nvt_dbg(ERROR, "%s:invalid enable val=%d\n",
__func__, int_val);
goto fail;
}
recover_buf[index++] = (u8)int_val & 0xff;
recover_buf[index++] = (u8)(int_val >> 8) & 0xff;
recover_buf[index++] = (u8)(int_val >> 16) & 0xff;
recover_buf[index++] = (u8)(int_val >> 24) & 0xff;
break;
case 2: /* scan repeat times */
case 3: /* scan exp */
case 5: /* scan type */
if (int_val > 255) {
nvt_dbg(ERROR, "%s:invalid scan repeat=%d\n",
__func__, int_val);
goto fail;
}
recover_buf[index++] = (u8)int_val;
break;
default:
nvt_dbg(ERROR, "%s:invalid index\n", __func__);
goto fail;
}
i++;
}
if (i == 7) {
return ret;
} else {
nvt_dbg(ERROR, "%s:invalid input parameter number\n",
__func__);
}
fail:
return -EINVAL;
}
static s32 nvt_set_acs_weight_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_wlan_conf_ap *wconf_ap = &nvt_if->nvt_wconf_ap;
u8 const *delim = ",";
s32 ret = 0;
u32 int_val = 0;
u8 *mib_val = NULL;
u8 temp[sizeof(wconf_ap->acs_weight)] = {0};
u8 i = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
while ((mib_val = strsep((char **)&mib_value_str, delim)) != NULL) {
ret = kstrtou32(mib_val, 10, &int_val);
if (ret < 0) {
goto fail;
}
if (int_val > 127) {
nvt_dbg(ERROR, "%s:invalid val=%d\n",
__func__, int_val);
goto fail;
}
if (i == sizeof(wconf_ap->acs_weight)) {
nvt_dbg(ERROR, "%s:over length, need 19\n", __func__);
goto fail;
}
temp[i] = (u8)int_val;
i++;
}
if (i != sizeof(wconf_ap->acs_weight)) {
nvt_dbg(ERROR, "%s:under length, need 19\n", __func__);
goto fail;
}
memcpy(wconf_ap->acs_weight, temp, sizeof(wconf_ap->acs_weight));
return ret;
fail:
wconf_ap->acs_weight[0] = 0xFF;
return -EINVAL;
}
static s32 nvt_get_acs_weight_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen) {
char *headers[] = {" RSSI_1", " RSSI_2", " RSSI_3",
" Coch_1", " Coch_2", " Coch_3", " Coch_4",
" Adj1_1", " Adj1_2", " Adj1_3", " Adj1_4",
" Adj2_1", " Adj2_2", " Adj2_3", " Adj2_4",
" Adj3_1", " Adj3_2", " Adj3_3", " Adj3_4",};
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_wlan_conf_ap *wconf_ap = &nvt_if->nvt_wconf_ap;
u8 i;
char *cur = out_str;
char * const end = out_str + NVT_IWPRIV_GETMIB_RSP_SIZE;
for (i = 0; i < sizeof(wconf_ap->acs_weight); i++) {
if (cur < end) {
cur += snprintf(cur, end-cur, "%s:%d",
headers[i], wconf_ap->acs_weight[i]);
}
}
*outlen = strlen(out_str);
return 0;
}
//The command line arguments are put as follows:
//ARG1:1BYTE:ht or non-ht
//ARG2:1BYTE:rate code
//ARG3:1BYTE:disable
//ARG4:1BYTE:min power level
//ARG5:1BYTE:max power level
//ARG6:1BYTE:power level step
//ARG7:1BYTE:num of no rate changes [MAX-RATE use this param]
//ARG8:1BYTE:back-off-counter-threshold
//ARG9:2BYTE:num_of_pkts_to_select
//ARG10:2BYTE:retry low water mark
//ARG11:2BYTE:retry high water mark
s32 nvt_set_tx_power_adaption_params(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
//start parsing the cmd line arguments
u8 const *delim = ",";
u8 *wid_val_buf;
s32 ret = 0;
u8 ar_pwr_tbl;
u8 r_code;
u8 disable;
u8 min_p_l, max_p_l, p_l_step;
u8 num_of_no_r_changes;
u8 b_off_cnt;
u16 num_of_p_2_sel;
u16 r_l_wmark;
u16 r_h_wmark;
char *ar_tbl_type = strsep((char **)&mib_value_str, delim);
char *rate_code = strsep((char **)&mib_value_str, delim);
char *disable_flag = strsep((char **)&mib_value_str, delim);
char *min_power_level = strsep((char **)&mib_value_str, delim);
char *max_power_level = strsep((char **)&mib_value_str, delim);
char *power_level_step = strsep((char **)&mib_value_str, delim);
char *num_of_no_rate_changes = strsep((char **)&mib_value_str,
delim);
char *back_off_counter_th = strsep((char **)&mib_value_str,
delim);
char *num_of_pkts_to_sel = strsep((char **)&mib_value_str, delim);
char *num_of_retry_low_watermark = strsep((char **)&mib_value_str,
delim);
char *num_of_retry_high_watermark = mib_value_str;
//sanity check
if (!(ar_tbl_type && rate_code && disable_flag && min_power_level &&
max_power_level && power_level_step && num_of_no_rate_changes &&
back_off_counter_th && num_of_pkts_to_sel &&
num_of_retry_low_watermark && num_of_retry_high_watermark)) {
return -EINVAL;
}
//transform the str to u8 or u16
kstrtou8(ar_tbl_type, 16, &ar_pwr_tbl);
kstrtou8(rate_code, 16, &r_code);
kstrtou8(disable_flag, 16, &disable);
kstrtou8(min_power_level, 16, &min_p_l);
kstrtou8(max_power_level, 16, &max_p_l);
kstrtou8(power_level_step, 16, &p_l_step);
kstrtou8(num_of_no_rate_changes, 16, &num_of_no_r_changes);
kstrtou8(back_off_counter_th, 16, &b_off_cnt);
kstrtou16(num_of_pkts_to_sel, 16, &num_of_p_2_sel);
kstrtou16(num_of_retry_low_watermark, 16, &r_l_wmark);
kstrtou16(num_of_retry_high_watermark, 16, &r_h_wmark);
//layout the buffer in big endian fashion if the data size
//larger than one byte
wid_val_buf = kzalloc(14, GFP_KERNEL);
if (wid_val_buf == NULL) {
ret = -1;
goto fail;
}
wid_val_buf[0] = ar_pwr_tbl;
wid_val_buf[1] = r_code;
wid_val_buf[2] = disable;
wid_val_buf[3] = min_p_l;
wid_val_buf[4] = max_p_l;
wid_val_buf[5] = p_l_step;
wid_val_buf[6] = num_of_no_r_changes;
wid_val_buf[7] = b_off_cnt;
wid_val_buf[8] = (num_of_p_2_sel >> 8) & 0xFF;
wid_val_buf[9] = num_of_p_2_sel & 0xFF;
wid_val_buf[10] = (r_l_wmark >> 8) & 0xFF;
wid_val_buf[11] = r_l_wmark & 0xFF;
wid_val_buf[12] = (r_h_wmark >> 8) & 0xFF;
wid_val_buf[13] = r_h_wmark & 0xFF;
ret = nvt_send_wid_by_numeric(nvt_bus, WID_TX_POWER_ADAPTION,
wid_val_buf, 14);
if (ret < 0) {
ret = -1;
goto fail;
}
fail:
kfree(wid_val_buf);
return ret;
}
static s32 nvt_set_dtim_scalar_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
s32 ret = 0;
u32 temp_val = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 10, &temp_val);
if (ret < 0) {
return -EINVAL;
}
if (temp_val == 0) {
return -EINVAL;
}
nvt_if->skip_dtim_scalar = temp_val;
nvt_dbg(CFG80211, "%s, dtim_scalar=%d\n",
__func__, nvt_if->skip_dtim_scalar);
return ret;
}
static s32 nvt_get_dtim_scalar_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
u32 temp_val = nvt_if->skip_dtim_scalar;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%d", temp_val);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_dtim_time_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
s32 ret = 0;
u32 temp_val = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 10, &temp_val);
if (ret < 0) {
return -EINVAL;
}
if (temp_val == 0) {
return -EINVAL;
}
nvt_if->skip_dtim_time = temp_val;
nvt_dbg(CFG80211, "%s, dtim_time=%d\n",
__func__, nvt_if->skip_dtim_time);
return ret;
}
static s32 nvt_get_dtim_time_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
u32 temp_val = nvt_if->skip_dtim_time;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%d", temp_val);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_ignore_bcn_bitmap_handler(struct _nvt_bus *nvt_bus,
void *data, u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
s32 ret = 0;
u32 temp_val = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 10, &temp_val);
if (ret < 0) {
return -EINVAL;
}
nvt_if->ignore_bcn_bitmap = temp_val;
nvt_dbg(CFG80211, "%s:ignore_bcn_bitmap=%d\n",
__func__, nvt_if->ignore_bcn_bitmap);
return ret;
}
static s32 nvt_get_ignore_bcn_bitmap_handler(struct _nvt_bus *nvt_bus,
void *data, u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
u32 temp_val = nvt_if->ignore_bcn_bitmap;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%d", temp_val);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_queue_cnt_handler(struct _nvt_bus *nvt_bus,
void *data, u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
s32 ret;
u32 max_qcnt = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 10, &max_qcnt);
if (ret < 0) {
return -EINVAL;
}
tx_info->max_qcnt = max_qcnt;
return ret;
}
static s32 nvt_get_queue_cnt_handler(struct _nvt_bus *nvt_bus,
void *data, u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
u32 temp_val = tx_info->max_qcnt;
snprintf(out_str, NVT_IWPRIV_GETMIB_RSP_SIZE, "%d", temp_val);
*outlen = strlen(out_str);
return 0;
}
static s32 nvt_set_testmode_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *mib_value_str)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
s32 ret;
u32 testmode = 0;
if (mib_value_str == NULL) {
return -EINVAL;
}
ret = kstrtou32(mib_value_str, 10, &testmode);
if (ret < 0) {
return -EINVAL;
}
if (testmode < 0) {
return -EINVAL;
}
memset(&tx_info->nvt_tx_test, 0, sizeof(struct _nvt_tx_test));
tx_info->nvt_tx_test.tx_test_mode = testmode;
return ret;
}
static s32 nvt_get_testmode_handler(struct _nvt_bus *nvt_bus, void *data,
u8 *out_str, u32 *outlen)
{
struct _nvt_if *nvt_if = netdev_priv((struct net_device *)data);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
struct _nvt_tx_test nvt_tx_test = tx_info->nvt_tx_test;
char *headers[] = {" TESTMODE", " TOTAL_CNT", " ENQUE_CNT",
" ENQUE_DROP_CNT", " DEQUE_CNT", " DEQUE_DROP_CNT",
" START_TIME", " END_TIME",
" ENQ_VO", " ENQ_VI", " ENQ_BE", " ENQ_BK",
" CRED_VO", " CRED_VI", " CRED_BE", " CRED_BK",
" CRED_PUB"};
char *cur = out_str;
char * const end = out_str + NVT_IWPRIV_GETMIB_RSP_SIZE;
cur += snprintf(cur, end-cur, "%s:%d",
headers[0], nvt_tx_test.tx_test_mode);
cur += snprintf(cur, end-cur, "%s:%d",
headers[1], nvt_tx_test.tx_total_cnt);
cur += snprintf(cur, end-cur, "%s:%d",
headers[2], nvt_tx_test.tx_enque_cnt);
cur += snprintf(cur, end-cur, "%s:%d",
headers[3], nvt_tx_test.rx_enque_drop_cnt);
cur += snprintf(cur, end-cur, "%s:%d",
headers[4], nvt_tx_test.tx_deque_cnt);
cur += snprintf(cur, end-cur, "%s:%d",
headers[5], nvt_tx_test.tx_deque_drop_cnt);
cur += snprintf(cur, end-cur, "%s:%lu",
headers[6], nvt_tx_test.start_time);
cur += snprintf(cur, end-cur, "%s:%lu",
headers[7], nvt_tx_test.end_time);
cur += snprintf(cur, end-cur, "%s:%d",
headers[8], tx_info->fifo_enqpkt[NV_TX_FIFO_AC_VO]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[9], tx_info->fifo_enqpkt[NV_TX_FIFO_AC_VI]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[10], tx_info->fifo_enqpkt[NV_TX_FIFO_AC_BE]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[11], tx_info->fifo_enqpkt[NV_TX_FIFO_AC_BK]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[12], tx_info->fifo_credit[NV_TX_FIFO_AC_VO]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[13], tx_info->fifo_credit[NV_TX_FIFO_AC_VI]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[14], tx_info->fifo_credit[NV_TX_FIFO_AC_BE]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[15], tx_info->fifo_credit[NV_TX_FIFO_AC_BK]);
cur += snprintf(cur, end-cur, "%s:%d",
headers[16], tx_info->fifo_credit[NV_TX_FIFO_PUBLIC]);
*outlen = strlen(out_str);
return 0;
}
static struct _nvt_iwpriv_mib mib_cmd_tbl[] = {
{"pwm", WID_POWER_MANAGEMENT, /* name, wid */
1, /* len_field_size */
REQ_CHAR_TYPE, /* req_format */
RSP_FORMAT_ENUM_STRING, /* resp_format */
str_power_save_mode, /* str_enum */
6, /* enum_num */
NULL, /* setmib_handler */
NULL}, /* getmib_handler */
{"fc", WID_FC_ENABLE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
#ifdef CONFIG_WIFI_TUNING_PHASE_II
{"tpm_start", WID_TP_MONITOR,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"tpm_interval", WID_TP_MIN_INTERVAL,
1,
REQ_INT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"tpm_sta_stats", 0xFFFF,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
NULL,
0,
NULL,
nvt_tpm_sta_stats},
#endif
{"fcb", 0xFFFF,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
nvt_set_fc_borrow,
nvt_get_fc_borrow_flag},
{"sgi", WID_11N_SHORT_GI_ENABLE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_short_gi,
4,
NULL,
NULL},
{"rxrdy", WID_ACS_RXRDY_THRESH,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"rts", WID_RTS_THRESHOLD,
1,
REQ_SHORT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"scan_ch_time", WID_AP_SCAN_STAY_CH_TIME,
1,
REQ_SHORT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"scan_resume_time", WID_AP_RESUME_STAY_CH_TIME,
1,
REQ_SHORT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"ochan", WID_CURR_OPER_CHANNEL,
1,
REQ_SHORT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"ht40", WID_2040_ENABLE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_enable_disable,
2,
NULL,
NULL},
{"20/40", WID_2040_COEXISTENCE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_enable_disable,
2,
NULL,
NULL},
{"qos", WID_QOS_ENABLE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_enable_disable,
2,
NULL,
NULL},
{"gmode", WID_11G_OPERATING_MODE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_legacy_mode,
4,
NULL,
NULL},
{"nmode", WID_11N_ENABLE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_enable_disable,
2,
NULL,
NULL},
{"tx_rate", WID_CURRENT_TX_RATE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"mcs", WID_11N_CURRENT_TX_MCS,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"ctxbw", WID_11N_CURRENT_TX_BW,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_ENUM_STRING,
str_enable_disable,
2,
NULL,
NULL},
{"pream", WID_PREAMBLE,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"rfrag", WID_RECEIVED_FRAGMENT_COUNT,
1,
REQ_INT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"pact", WID_11N_P_ACTION_REQ,
1,
REQ_STR_TYPE,
RSP_FORMAT_STRING,
NULL,
0,
NULL,
NULL},
{"umac", 0xFFFF,
0,
0,
0,
NULL,
0,
NULL,
nvt_get_umac_handler},
{"lmac", 0xFFFF,
0,
0,
0,
NULL,
0,
NULL,
nvt_get_lmac_handler},
{"mode", 0xFFFF,
0,
0,
0,
NULL,
0,
NULL,
nvt_get_mode},
{"rate", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_rate_handler,
nvt_get_rate_handler},
{"hwater", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_hwatermark_handler,
nvt_get_hwatermark_handler},
{"lwater", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_lwatermark_handler,
nvt_get_lwatermark_handler},
{"fver", 0xFFFF,
0,
0,
0,
NULL,
0,
NULL,
nvt_iwpriv_getmib_fver},
/* control firmware UART mode */
{"fuart", WID_UART_MODE,
1,
REQ_INT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
/* control firmware debug level */
{"fdbg", WID_DBG_LEVEL,
1,
REQ_INT_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"offload", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_offload_handler,
nvt_get_offload_handler},
{"dhcp_renew", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_dhcp_renew_handler,
0},
{"keep_alive_offload", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_ka_handler,
0},
#ifdef CONFIG_PM
{"wow", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_wow_handler,
nvt_get_wow_handler},
#endif
//20160406 Wade: autorate parameter
{"autorate", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_autorate_parameter,
nvt_get_autorate_parameter},
{"tx_power_adapt", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_tx_power_adaption_params,
0},
{"scanfrq", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_wow_scanfrq,
NULL},
#ifdef BUS_UTILIZATION
//20160322 nash:
{"butxmode", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_bus_utilization_mode,
nvt_get_bus_utilization_mode},
//20160122 nash: bus utilization
{"butx", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_bus_utilization_tx,
NULL},
{"burx", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_bus_utilization_rx,
NULL},
#endif
{"channel", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_channel_handler,
nvt_get_channel_handler},
{"autoch_maskmap_2g", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_acs_mask_handler,
nvt_get_acs_mask_handler},
{"acs_weight", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_acs_weight_handler,
nvt_get_acs_weight_handler},
{"dtim_scalar", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_dtim_scalar_handler,
nvt_get_dtim_scalar_handler},
{"dtim_time", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_dtim_time_handler,
nvt_get_dtim_time_handler},
{"ignore_bcn_bitmap", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_ignore_bcn_bitmap_handler,
nvt_get_ignore_bcn_bitmap_handler},
{"gfield", WID_ENABLE_GREENFIELD,
1,
REQ_CHAR_TYPE,
RSP_FORMAT_HEX,
NULL,
0,
NULL,
NULL},
{"qcnt", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_queue_cnt_handler,
nvt_get_queue_cnt_handler},
{"testmode", 0xFFFF,
0,
0,
0,
NULL,
0,
nvt_set_testmode_handler,
nvt_get_testmode_handler},
{NULL, 0xFFFF,
0,
0,
0,
NULL,
0,
NULL,
NULL}
};
/**
* nvt_byte_to_hex_str - transform the byte array to the human
* readable hex
* @wid_start_val: this is the pointer pointed to the started
* byte address of the started wid value
* @byte_len: how many bytes are in the byte array
* [CAUTION:]Only counts for the real value!
*
* @data_byte: for short this value is 2, for int this value
* is 4. In the nutshell, how many bytes are bundle for one
* hex value.
* @header_str: is the header name for each of the data
* [CAUTION]I assume each header len will not exceed 5byte!
*/
static s32 nvt_byte_to_hex_str(u8 *wid_start_val, s32 byte_len,
u8 data_byte, u8 *out_str, char **header_str)
{
s32 i;
s32 j;
s32 remain_byte;
u32 wid_val;
for (i = 0; data_byte * i < byte_len; i++) {
wid_val = 0;
remain_byte = byte_len - data_byte * i;
if (remain_byte > data_byte) {
remain_byte = data_byte;
}
for (j = 0; j < remain_byte; j++) {
wid_val += (*(wid_start_val + data_byte * i
+ remain_byte - j - 1)) << (8 * j);
}
snprintf(out_str + 15 * i, NVT_IWPRIV_GETMIB_RSP_SIZE,
"%5s:%08x\n", header_str[i], wid_val);
}
return 0;
}
s32 nvt_parse_rate_0(u8 wid_val)
{
s32 retval;
/*test b7 => HT or non-HT*/
if (wid_val & 0x0080) {
retval = (0x0001 & wid_val) + (0x0002 & wid_val) +
(0x0004 & wid_val);
/*non-HT*/
} else {
wid_val = (0x0001 & wid_val) + (0x0002 & wid_val) +
(0x0004 & wid_val) + (0x0008 & wid_val);
/*b rate*/
if (wid_val == 4) {
retval = 1000;
} else if (wid_val == 1 || wid_val == 5) {
retval = 2000;
} else if (wid_val == 2 || wid_val == 6) {
retval = 5500;
} else if (wid_val == 3 || wid_val == 7) {
retval = 11000;
/*g rate*/
} else if (wid_val == 11) {
retval = 6000;
} else if (wid_val == 15) {
retval = 9000;
} else if (wid_val == 10) {
retval = 12000;
} else if (wid_val == 14) {
retval = 18000;
} else if (wid_val == 9) {
retval = 24000;
} else if (wid_val == 13) {
retval = 36000;
} else if (wid_val == 8) {
retval = 48000;
} else if (wid_val == 12) {
retval = 54000;
} else {
nvt_dbg(ERROR, "%s: input rate is wrong!\n", __func__);
retval = -1;
}
}
return retval;
}
/**
* nvt_parse_strdata_to_array -parse ascii string to byte buffer
* @str: input ascii string
* @wid: WID
* @ret_data: returned byte buffer
*
*
* Return: parsed data length or a negative value for fail
*/
static s32 nvt_parse_strdata_to_array(u8 *str, u16 wid, u8 *ret_data)
{
s32 ret;
s32 index;
u8 const *delim = ",";
u8 *token;
u8 val;
if (str == NULL || ret_data == NULL) {
return -EPERM;
}
index = 0;
while (1) {
token = strsep((char **)&str, delim);
if (token == NULL) {
if (wid < NVT_ICFG_SHORT_WID_START) {
if (index != 1) {
return -EINVAL;
}
} else if (wid < NVT_ICFG_INT_WID_START) {
if (index != 2) {
return -EINVAL;
}
} else if (wid < NVT_ICFG_STR_WID_START) {
if (index != 4) {
return -EINVAL;
}
}
return index;
}
ret = kstrtou8(token, 16, &val);
if (ret < 0) {
nvt_dbg(ERROR, "%s: input string error\n", __func__);
return -EINVAL;
}
*(ret_data + index) = val;
index++;
}
//20150803 nash: original design (supprot much data handling for display)
#if 0
s32 ret;
u8 val_8;
u16 val_16;
u32 val_32;
u8 *token;
u8 const *delim = ",";
u32 index;
s8 *pch;
if (str == NULL || ret_data == NULL) {
return -EPERM;
}
if (wid < NVT_ICFG_SHORT_WID_START) {
ret = kstrtou8(str, 16, &val_8);
if (ret < 0) {
return -EINVAL;
}
*ret_data = val_8;
return 1;
} else if (wid < NVT_ICFG_INT_WID_START) {
ret = kstrtou16(str, 16, &val_16);
if (ret < 0) {
return -EINVAL;
}
val_16 = cpu_to_le16(val_16);
memcpy(ret_data, &val_16, 2);
return 2;
} else if (wid < NVT_ICFG_STR_WID_START) {
ret = kstrtou32(str, 16, &val_32);
if (ret < 0) {
return -EINVAL;
}
val_32 = cpu_to_le32(val_32);
memcpy(ret_data, &val_32, 4);
return 4;
} else if (wid < NVT_ICFG_BIN_WID_START) {
pch = strchr(str, ',');
/* Support input argument, "01,02,03", for example
* for string WID
*/
if (pch != NULL) {
if ((u8 *)pch - str == 0) {
nvt_dbg(INFO, "%s: string start with ,\n",
__func__);
return -EINVAL;
}
index = 0;
while (1) {
token = strsep((char **)&str, delim);
if (token == NULL) {
break;
}
ret = kstrtou8(token, 16, &val_8);
if (ret < 0) {
return -EINVAL;
}
*(ret_data + index) = val_8;
index++;
}
return index;
} else {
memcpy(ret_data, str, strlen(str));
return strlen(str);
}
} else if (wid < NVT_ICFG_MAX_WID_START) {
index = 0;
while (1) {
token = strsep((char **)&str, delim);
if (token == NULL) {
break;
}
ret = kstrtou8(token, 16, &val_8);
if (ret < 0) {
return -EINVAL;
}
*(ret_data + index) = val_8;
index++;
}
return index;
} else {
return -EPERM;
}
#endif
}
void nvt_init_fw_by_wids(struct _nvt_bus *nvt_bus, enum nl80211_iftype type)
{
s32 ret;
u8 fc_enabled = 1;
u8 monitor = 0;
u8 start_op = DO_RESET;
u8 streaming_mode = 1;
if ((type == NL80211_IFTYPE_STATION) ||
(type == NL80211_IFTYPE_P2P_CLIENT) ||
(type == NL80211_IFTYPE_AP) ||
(type == NL80211_IFTYPE_AP_VLAN) ||
(type == NL80211_IFTYPE_P2P_GO)) {
/* set monitor disabled */
ret = nvt_send_wid_by_numeric(nvt_bus, WID_MONITOR_ENABLE,
(u8 *)&monitor, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
ret = nvt_send_wid_by_numeric(nvt_bus, WID_START_OP,
(u8 *)&start_op, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
/* set flow control enabled */
ret = nvt_send_wid_by_numeric(nvt_bus, WID_FC_ENABLE,
&fc_enabled, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
/* set streaming mode */
if (nvt_data_mode == stream_mode) {
streaming_mode = 1;
if ((nvt_bus->nvt_adapter->nvt_fw_cap.extra_cap_1 &
FW_CAPABILITY_STREAMING_MODE)) {
nvt_dbg(ERROR, "%s: streaming mode\n", __func__);
ret = nvt_send_wid_by_numeric(nvt_bus, WID_DATA_MODE,
&streaming_mode, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n",
__func__);
}
} else {
nvt_dbg(ERROR, "%s: Streaming Mode is Unsupported\n",
__func__);
}
} else {
streaming_mode = 0;
nvt_dbg(ERROR, "%s: data mode\n", __func__);
ret = nvt_send_wid_by_numeric(nvt_bus, WID_DATA_MODE,
&streaming_mode, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
}
} else if (type == NL80211_IFTYPE_MONITOR) {
monitor = 1;
fc_enabled = 0;
/* set monitor enabled */
ret = nvt_send_wid_by_numeric(nvt_bus, WID_MONITOR_ENABLE,
(u8 *)&monitor, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
ret = nvt_send_wid_by_numeric(nvt_bus, WID_START_OP,
(u8 *)&start_op, 1);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
/* set flow control disabled */
ret = nvt_send_wid_by_numeric(nvt_bus, WID_FC_ENABLE,
&fc_enabled, 0);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
}
}
return;
}
/*AT add for sending the numerical data*/
s32 nvt_send_wid_by_numeric(struct _nvt_bus *nvt_bus, u16 wid,
u8 *wid_val_data, s32 num_of_byte)
{
s32 ret;
if (nvt_bus == NULL || wid_val_data == NULL) {
return -EINVAL;
}
nvt_icfg_lock(nvt_bus);
ret = nvt_icfg_reset(nvt_bus);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
goto fail;
}
ret = nvt_icfg_add(nvt_bus, NVT_ICFG_SET, wid, wid_val_data,
num_of_byte);
if (ret < 0) {
goto fail;
}
ret = nvt_icfg_send_and_get_resp(nvt_bus, NULL, 0);
if (ret < 0) {
nvt_dbg(ERROR, "%s: send WID fail\n", __func__);
ret = -EPERM;
goto fail;
}
fail:
nvt_icfg_unlock(nvt_bus);
return ret;
}
/**
* nvt_send_wid_set -send SET WID message
* @nvt_bus: nvt bus structure
* @wid: WID
* @wid_val_str: WID value in ascii string
*
* Return: 0:success, a negative value for fail
*/
static s32 nvt_send_wid_set(struct _nvt_bus *nvt_bus, u16 wid,
u8 *wid_val_str)
{
s32 ret;
u8 *wid_val_buff;
wid_val_buff = kzalloc(NVT_IWPRIV_SETWID_CMD_SIZE, GFP_KERNEL);
ret = nvt_parse_strdata_to_array(wid_val_str, wid, wid_val_buff);
/*ret is the number of bytes for the data*/
if (ret < 0) {
goto fail;
}
ret = nvt_send_wid_by_numeric(nvt_bus, wid, wid_val_buff, ret);
if (ret < 0) {
nvt_dbg(ERROR, "%s: nvt_send_wid_set fail\n",
__func__);
}
fail:
kfree(wid_val_buff);
return ret;
}
static s32 nvt_parse_setmib(struct _nvt_bus *nvt_bus,
struct net_device *dev, s8 *mib_cmd, s8 *mib_value)
{
s32 i;
s32 ret;
u8 *buff;
u8 char_val;
u16 short_val;
//20151221 nash: coverity#48993
u32 int_val = 0;
u8 *str_tmp;
u32 str_tmp_len = 32;
struct _nvt_iwpriv_mib *mib_entry = NULL;
for (i = 0; mib_cmd_tbl[i].name != NULL; i++) {
if (strcmp(mib_cmd_tbl[i].name, mib_cmd) == 0) {
mib_entry = &mib_cmd_tbl[i];
break;
}
}
if (mib_entry == NULL) {
nvt_dbg(ERROR, "%s: no mib cmd matched!\n", __func__);
return -EINVAL;
}
/* Run user specify handler */
if (mib_entry->wid == 0xFFFF) {
if (mib_entry->setmib_handler != NULL) {
return mib_entry->setmib_handler(nvt_bus, dev,
mib_value);
} else {
return -EPERM;
}
}
switch (mib_entry->req_format) {
case REQ_CHAR_TYPE:
ret = kstrtou8(mib_value, 16, &char_val);
if (ret < 0) {
return -EINVAL;
}
str_tmp = kzalloc(str_tmp_len, GFP_KERNEL);
//20151221 nash: ocverity#48957
if (str_tmp == NULL) {
nvt_dbg(ERROR, "%s: kzalloc fail\n", __func__);
return -ENOMEM;
}
//20151221 nash: coverity#48977
snprintf(str_tmp, str_tmp_len, "%x", char_val);
ret = nvt_send_wid_set(nvt_bus, mib_entry->wid, str_tmp);
kfree(str_tmp);
return ret;
case REQ_SHORT_TYPE:
ret = kstrtou16(mib_value, 16, &short_val);
if (ret < 0) {
return -EINVAL;
}
str_tmp = kzalloc(str_tmp_len, GFP_KERNEL);
if (str_tmp == NULL) {
nvt_dbg(ERROR, "%s: kzalloc fail\n", __func__);
return -ENOMEM;
}
//20151221 nash: coverity#48977
snprintf(str_tmp, str_tmp_len, "%x,%x",
short_val & 0x00FF, (short_val >> 8));
ret = nvt_send_wid_set(nvt_bus, mib_entry->wid, str_tmp);
kfree(str_tmp);
return ret;
case REQ_INT_TYPE:
ret = kstrtou32(mib_value, 16, &int_val);
if (ret < 0) {
return -EINVAL;
}
str_tmp = kzalloc(str_tmp_len, GFP_KERNEL);
//20151221 nash: coverity#48977
if (str_tmp == NULL) {
nvt_dbg(ERROR, "%s: kzalloc fail\n", __func__);
return -ENOMEM;
}
snprintf(str_tmp, str_tmp_len,
"%x,%x,%x,%x",
int_val & 0xFF,
(int_val >> 8) & 0xFF,
(int_val >> 16) & 0xFF,
(int_val >> 24) & 0xFF);
ret = nvt_send_wid_set(nvt_bus, mib_entry->wid, str_tmp);
kfree(str_tmp);
return ret;
case REQ_STR_TYPE:
str_tmp = kzalloc(strlen(mib_value)*3, GFP_KERNEL);
if (str_tmp == NULL) {
nvt_dbg(ERROR, "%s: kzalloc fail\n", __func__);
return -ENOMEM;
}
for (i = 0; i < strlen(mib_value); i++) {
if (i == strlen(mib_value) - 1) {
//20151221 nash: coverity#48977
snprintf((str_tmp + i*3),
(strlen(mib_value) - i) * 3,
"%02x",
*(mib_value + i));
} else {
//20151221 nash: coverity#48977
snprintf((str_tmp + i*3),
(strlen(mib_value) - i) * 3,
"%02x,",
*(mib_value + i));
}
}
ret = nvt_send_wid_set(nvt_bus, mib_entry->wid, str_tmp);
kfree(str_tmp);
return ret;
case REQ_RAW_ASCII_TYPE:
return nvt_send_wid_set(nvt_bus, mib_entry->wid, mib_value);
case REQ_ENUM_STR_TYPE:
/* get wid value */
for (i = 0; i < mib_entry->enum_num; i++) {
if (strcmp(mib_entry->str_enum[i], mib_value) == 0) {
break;
}
}
if (i >= mib_entry->enum_num) {
return -EINVAL;
}
buff = kzalloc(str_tmp_len, GFP_KERNEL);
if (buff == NULL) {
return -EPERM;
}
//20151221 nash: coverity#48977
snprintf(buff, str_tmp_len, "%x", i);
ret = nvt_send_wid_set(nvt_bus, mib_entry->wid, buff);
kfree(buff);
return ret;
default:
return -EPERM;
}
}
static s32 nvt_iwpriv_setmib(struct net_device *dev,
struct iw_request_info *info, struct iw_point *wrq, char *extra)
{
s8 *mib_cmd;
s8 *mib_value;
u8 const *delim = "=";
struct _nvt_if *nvt_if = netdev_priv(dev);
struct _nvt_bus *nvt_bus = nvt_if->nvt_adapter->nvt_bus;
mib_cmd = strsep(&extra, delim);
if (mib_cmd == NULL) {
return -EINVAL;
}
mib_value = strsep(&extra, delim);
if (mib_value == NULL) {
return -EINVAL;
}
return nvt_parse_setmib(nvt_bus, dev, mib_cmd, mib_value);
}
static s32 nvt_iwpriv_getmib(struct net_device *dev,
struct iw_request_info *info, struct iw_point *wrq, char *extra)
{
s32 i;
s32 ret;
u8 *cmd;
u8 *resp_buff;
u32 wid_len;
u32 wid_val;
struct _nvt_iwpriv_mib *mib_entry;
struct _nvt_if *nvt_if = netdev_priv(dev);
struct _nvt_bus *nvt_bus = nvt_if->nvt_adapter->nvt_bus;
cmd = kzalloc(NVT_IWPRIV_GETMIB_CMD_SIZE, GFP_KERNEL);
if (cmd == NULL) {
return -EPERM;
}
copy_from_user(cmd, wrq->pointer, wrq->length);
mib_entry = NULL;
for (i = 0; mib_cmd_tbl[i].name != NULL; i++) {
if (strcmp(mib_cmd_tbl[i].name, cmd) == 0) {
mib_entry = &mib_cmd_tbl[i];
}
}
kfree(cmd);
if (mib_entry == NULL) {
return -EINVAL;
}
/* Run by handler if specified */
if (mib_entry->wid == 0xFFFF) {
if (mib_entry->getmib_handler != NULL) {
return mib_entry->getmib_handler(nvt_bus, dev, extra,
(u32 *)&wrq->length);
} else {
return -EPERM;
}
}
/* Send a WID message */
//20151221 nash: coverity#48924
ret = nvt_icfg_lock(nvt_bus);
//20170109 nash: coverity#24344
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg lock fail\n", __func__);
return -1;
}
ret = nvt_icfg_reset(nvt_bus);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg reset fail\n", __func__);
ret = -EPERM;
goto fail_and_unlock;
}
ret = nvt_icfg_add(nvt_bus, NVT_ICFG_GET, mib_entry->wid, NULL, 0);
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg add fail\n", __func__);
ret = -EPERM;
goto fail_and_unlock;
}
resp_buff = kzalloc(NVT_IWPRIV_GETMIB_RSP_SIZE, GFP_KERNEL);
if (resp_buff == NULL) {
nvt_dbg(ERROR, "%s: resp buff alloc fail\n", __func__);
ret = -EPERM;
goto fail_and_unlock;
}
ret = nvt_icfg_send_and_get_resp(nvt_bus, resp_buff,
NVT_IWPRIV_GETMIB_RSP_SIZE);
if (ret < 0) {
nvt_dbg(ERROR, "%s: get resp fail\n", __func__);
ret = -EPERM;
kfree(resp_buff);
goto fail_and_unlock;
}
/* Parse result */
wid_len = 0;
for (i = 0; i < mib_entry->len_field_size; i++) {
wid_len += ((resp_buff[NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + i]) << (8 * i));
}
ret = 0;
switch (mib_entry->resp_format) {
case RSP_FORMAT_HEX:
wid_val = 0;
for (i = 0; i < wid_len; i++) {
wid_val += ((resp_buff[NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE +
mib_entry->len_field_size + i]) << (8 * i));
}
//20151221 nash: coverity#48975
snprintf(extra, NVT_IWPRIV_GETMIB_RSP_SIZE, "%x", wid_val);
wrq->length = strlen(extra);
break;
case RSP_FORMAT_ENUM_STRING:
wid_val = 0;
for (i = 0; i < wid_len; i++) {
wid_val <<= 8;
wid_val += ((resp_buff[NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE +
mib_entry->len_field_size + i]) << (8 * i));
}
if (wid_val >= mib_entry->enum_num) {
ret = -EPERM;
break;
}
//20151221 nash: coverity#48975
snprintf(extra, NVT_IWPRIV_GETMIB_RSP_SIZE, "%s(%x)",
mib_entry->str_enum[wid_val], wid_val);
wrq->length = strlen(extra);
break;
case RSP_FORMAT_STRING:
case RSP_FORMAT_BINARY:
for (i = 0; i < wid_len; i++) {
//20151221 nash: coverity#48975
snprintf((extra + i * 3), NVT_IWPRIV_GETMIB_RSP_SIZE,
"%02x ", *(resp_buff +
NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE +
mib_entry->len_field_size + i));
}
wrq->length = strlen(extra);
break;
default:
ret = -EPERM;
break;
}
kfree(resp_buff);
fail_and_unlock:
nvt_icfg_unlock(nvt_bus);
return ret;
}
static s32 nvt_iwpriv_setwid(struct net_device *dev,
struct iw_request_info *info, struct iw_point *wrq, char *extra)
{
s32 ret;
u8 const *delim = ",";
u8 *token;
u16 wid;
struct _nvt_if *nvt_if = netdev_priv(dev);
struct _nvt_bus *nvt_bus = nvt_if->nvt_adapter->nvt_bus;
nvt_dbg(INFO, "%s: %s\n", __func__, extra);
token = strsep(&extra, delim);
ret = kstrtou16(token, 16, &wid);
if (ret < 0) {
return -EINVAL;
}
token = strsep(&extra, "");
if (token == NULL) {
nvt_dbg(ERROR, "%s: no wid value\n", __func__);
return -EINVAL;
}
return nvt_send_wid_set(nvt_bus, wid, token);
}
static s32 nvt_iwpriv_getwid(struct net_device *dev,
struct iw_request_info *info, struct iw_point *wrq, char *extra)
{
s32 i;
s32 ret;
u32 wid = 0;
s32 total_len;
u8 *resp_buff;
u8 *wid_value = NULL;
u32 wid_len = 0;
struct _nvt_if *nvt_if = netdev_priv(dev);
struct _nvt_bus *nvt_bus = nvt_if->nvt_adapter->nvt_bus;
copy_from_user((u8 *)&wid, wrq->pointer, wrq->length);
ret = kstrtoul((char *)&wid, 16, (unsigned long *)&wid);
if (ret < 0) {
return -EINVAL;
}
if (wid >= NVT_ICFG_MAX_WID_START) {
nvt_dbg(ERROR, "%s: unknown WID\n", __func__);
return -EINVAL;
}
/* Send and get response */
//20151221 nash: coverity#48925
ret = nvt_icfg_lock(nvt_bus);
//20170109 nash: coverity#24345
if (ret < 0) {
nvt_dbg(ERROR, "%s: icfg lock fail\n", __func__);
return -1;
}
ret = nvt_icfg_reset(nvt_bus);
if (ret < 0) {
nvt_dbg(ERROR, "%s: reset wid msg buffer fail\n", __func__);
ret = -EPERM;
goto fail_and_unlock;
}
ret = nvt_icfg_add(nvt_bus, NVT_ICFG_GET, wid, NULL, 0);
if (ret < 0) {
nvt_dbg(ERROR, "%s: add wid fail\n", __func__);
ret = -EPERM;
goto fail_and_unlock;
}
resp_buff = kzalloc(NVT_IWPRIV_GETWID_CMD_SIZE*2, GFP_KERNEL);
if (resp_buff == NULL) {
ret = -EPERM;
goto fail_and_unlock;
}
total_len = nvt_icfg_send_and_get_resp(nvt_bus, resp_buff,
NVT_IWPRIV_GETWID_CMD_SIZE*2);
if (total_len < 0) {
nvt_dbg(ERROR, "%s: send wid fail\n", __func__);
ret = -EPERM;
goto fail_and_free;
}
nvt_icfg_unlock(nvt_bus);
if (wid < NVT_ICFG_BIN_WID_START) {
wid_len = resp_buff[NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE];
wid_value = (resp_buff + NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 1);
} else if (wid < NVT_ICFG_MAX_WID_START) {
wid_len = resp_buff[NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE];
wid_len += resp_buff[NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 1] << 8;
wid_value = (resp_buff + NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 2);
}
for (i = 0; i < wid_len; i++) {
//20151221 nash: coverity#48976
snprintf((extra + i * 3), NVT_IWPRIV_GETMIB_RSP_SIZE,
"%02x ", *(wid_value + i));
}
wrq->length = strlen(extra);
kfree(resp_buff);
return ret;
//20150803 nash: original design (supprot much data handling for display)
#if 0
/* Dispaly result */
/* char, short, and int WID */
if (wid < NVT_ICFG_STR_WID_START) {
wid_len = resp_buff[NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE];
wid_value = (resp_buff + NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 1);
for (i = 0; i < wid_len; i++) {
sprintf((extra + i * 2), "%02x",
*(wid_value + wid_len - 1 - i));
}
wrq->length = wid_len * 2;
/* Special case for get MAC address */
} else if (wid == WID_MAC_ADDR) {
wid_len = resp_buff[NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE];
wid_value = (resp_buff + NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 1);
for (i = 0; i < wid_len; i++) {
sprintf((extra + i * 3), "%02x:", *(wid_value + i));
}
wrq->length = wid_len * 3;
/* String WID */
} else if (wid < NVT_ICFG_BIN_WID_START) {
wid_len = resp_buff[NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE];
wid_value = (resp_buff + NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 1);
memcpy(extra, wid_value, wid_len);
wrq->length = wid_len;
/* Binary WID */
} else if (wid < NVT_ICFG_MAX_WID_START) {
wid_len = resp_buff[NVT_ICFG_MSG_HDR_LEN + NVT_ICFG_WID_SIZE];
wid_len += resp_buff[NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 1] << 8;
wid_value = (resp_buff + NVT_ICFG_MSG_HDR_LEN +
NVT_ICFG_WID_SIZE + 2);
for (i = 0; i < wid_len; i++) {
sprintf((extra + i * 3), "%02x,", *(wid_value + i));
}
wrq->length = wid_len * 3;
}
ret = 0;
#endif
fail_and_free:
kfree(resp_buff);
fail_and_unlock:
nvt_icfg_unlock(nvt_bus);
return ret;
}
static s32 nvt_iwpriv_set_fw_download(struct net_device *dev,
struct iw_request_info *info, struct iw_param *rrq, char *extra)
{
struct _nvt_if *nvt_if = netdev_priv(dev);
nvt_if->fw_download_type = rrq->value;
nvt_dbg(INFO, "%s: mode=%d\n", __func__, nvt_if->fw_download_type);
schedule_work(&nvt_if->setfwdownload_work);
return 0;
}
#if 1 /* tx statistic */
static s32 nvt_iwpriv_shwmm(struct net_device *dev,
struct iw_request_info *info, struct iw_point *wrq, char *extra)
{
struct _nvt_if *nvt_if = netdev_priv(dev);
struct _nvt_adapter *nvt_adapter = nvt_if->nvt_adapter;
//struct _nvt_priv *nvt_priv = &nvt_adapter->nvt_priv;
struct _tx_info *tx_info = nvt_adapter->nvt_priv.tx_info;
struct _nvt_bus *nvt_bus = nvt_adapter->nvt_bus;
EDCA_STATS_T stats[4];
s8 fifo;
printk("%s:\n", __func__);
printk("fc:%d BK BE VI VO\n",
tx_info->fcmode);
printk("=========================================================\n");
printk(" enq: ");
for (fifo = NV_TX_FIFO_AC_BK; fifo >= 0; fifo--) {
stats[fifo].en = tx_info->stats[fifo].en;
printk("%-9d ", tx_info->stats[fifo].en);
}
printk("\n");
printk(" deq: ");
for (fifo = NV_TX_FIFO_AC_BK; fifo >= 0; fifo--) {
stats[fifo].out = tx_info->stats[fifo].out;
printk("%-9d ", tx_info->stats[fifo].out);
}
printk("\n");
printk(" remain: ");
for (fifo = NV_TX_FIFO_AC_BK; fifo >= 0; fifo--) {
printk("%-9d ", tx_info->fifo_enqpkt[fifo]);
}
printk("\n");
printk(" deq_sz: ");
for (fifo = NV_TX_FIFO_AC_BK; fifo >= 0; fifo--) {
stats[fifo].out_sz = tx_info->stats[fifo].out_sz;
printk("%-9x ", tx_info->stats[fifo].out_sz);
}
printk("\n");
printk(" drop: ");
for (fifo = NV_TX_FIFO_AC_BK; fifo >= 0; fifo--) {
stats[fifo].drop = tx_info->stats[fifo].drop;
printk("%-9d ", tx_info->stats[fifo].drop);
}
printk("\n");
printk("\n");
printk(" Bus ok fail\n");
printk("=========================================================\n");
printk(" pkt tx: %-9llu %-9llu\n",
nvt_bus->statistic.pkt_tx_cnt,
nvt_bus->statistic.pkt_tx_err_cnt);
printk(" pkt rx: %-9llu %-9llu\n",
nvt_bus->statistic.pkt_rx_cnt,
nvt_bus->statistic.pkt_rx_err_cnt);
printk("ctrl tx: %-9llu %-9llu\n",
nvt_bus->statistic.ctl_tx_cnt,
nvt_bus->statistic.ctl_tx_err_cnt);
printk("ctrl rx: %-9llu %-9llu\n",
nvt_bus->statistic.ctl_rx_cnt,
nvt_bus->statistic.ctl_rx_err_cnt);
return 0;
}
#endif
//#ifdef CONFIG_WIFI_TUNING_PHASE_II
#if 0
static s32 nvt_iwpriv_wifi_tuning(struct net_device *dev,
struct iw_request_info *info, struct iw_param *rrq, char *extra)
{
s32 ret = 0;
s8 *mib_cmd;
s8 *mib_value;
u8 const *delim = "=";
unsigned int interval, start;
u32 buff_size = 256;
//int skfd = 0;
//struct _nvt_if *nvt_if = netdev_priv(dev);
//struct _nvt_bus *nvt_bus = nvt_if->nvt_adapter->nvt_bus;
struct iwreq wrq;
struct _wifi_tuning_cmd wifi_tuning_cmd;
mib_cmd = strsep(&extra, delim);
if (mib_cmd == NULL) {
return -EINVAL;
}
nvt_dbg(ERROR, "%s: mib_cmd:%s\n", __func__, mib_cmd);
mib_value = strsep(&extra, delim);
if (mib_value == NULL) {
return -EINVAL;
}
nvt_dbg(ERROR, "%s: mib_value:%s\n", __func__, mib_value);
wifi_tuning_cmd.buf = kzalloc(buff_size, GFP_KERNEL);
if (wifi_tuning_cmd.buf == NULL) {
nvt_dbg(ERROR, "ERROR: malloc fail\n");
ret = -1;
goto buf_create_failed;
}
if (strcmp("start", mib_cmd) == 0) {
sscanf((const char *)mib_value, "%d", &start);
nvt_dbg(ERROR, "start:%d\n", start);
wifi_tuning_cmd.type = WIFI_TUNING_SET;
wifi_tuning_cmd.cmd_code.set = WIFI_TUNING_SET_START;
wifi_tuning_cmd.buf_len = 1;
*((u8 *)wifi_tuning_cmd.buf) = (u8)start;
} else if (strcmp("interval", mib_cmd) == 0) {
sscanf((const char *)mib_value, "%d", &interval);
nvt_dbg(ERROR, "interval:%d\n", interval);
wifi_tuning_cmd.type = WIFI_TUNING_SET;
wifi_tuning_cmd.cmd_code.set = WIFI_TUNING_SET_INTERVAL;
wifi_tuning_cmd.buf_len = 4;
*((unsigned int *)wifi_tuning_cmd.buf) = interval;
} else {
ret = -1;
goto cmd_code_failed;
}
cmd_code_failed:
kfree(wifi_tuning_cmd.buf);
buf_create_failed:
return ret;
}
#endif
static const iw_handler nvt_iw_handler[] = {
(iw_handler) NULL, /* SIOCSIWCOMMIT */
(iw_handler) NULL, /* SIOCGIWNAME */
(iw_handler) NULL, /* SIOCSIWN`WID */
(iw_handler) NULL, /* SIOCGIWNWID */
(iw_handler) NULL, /* SIOCSIWFREQ */
(iw_handler) NULL, /* SIOCGIWFREQ */
(iw_handler) NULL, /* SIOCSIWMODE */
(iw_handler) NULL, /* SIOCGIWMODE */
(iw_handler) NULL, /* SIOCSIWSENS */
(iw_handler) NULL, /* SIOCGIWSENS */
(iw_handler) NULL, /* SIOCSIWRANGE */
(iw_handler) NULL, /* SIOCGIWRANGE */
(iw_handler) NULL, /* SIOCSIWPRIV */
(iw_handler) NULL, /* SIOCGIWPRIV */
(iw_handler) NULL, /* SIOCSIWSTATS */
(iw_handler) NULL, /* SIOCGIWSTATS */
(iw_handler) NULL, /* SIOCSIWSPY */
(iw_handler) NULL, /* SIOCGIWSPY */
(iw_handler) NULL, /* -- hole -- */
(iw_handler) NULL, /* -- hole -- */
(iw_handler) NULL, /* SIOCSIWAP */
(iw_handler) NULL, /* SIOCGIWAP */
(iw_handler) NULL, /* -- hole -- */
(iw_handler) NULL, /* SIOCGIWAPLIST */
(iw_handler) NULL, /* SIOCSIWSCAN */
(iw_handler) NULL, /* SIOCGIWSCAN */
(iw_handler) NULL, /* SIOCSIWESSID */
(iw_handler) NULL, /* SIOCGIWESSID */
(iw_handler) NULL, /* SIOCSIWNICKN */
(iw_handler) NULL, /* SIOCGIWNICKN */
(iw_handler) NULL, /* -- hole -- */
(iw_handler) NULL, /* -- hole -- */
(iw_handler) NULL, /* SIOCSIWRATE */
(iw_handler) NULL, /* SIOCGIWRATE */
(iw_handler) NULL, /* SIOCSIWRTS */
(iw_handler) NULL, /* SIOCGIWRTS */
(iw_handler) NULL, /* SIOCSIWFRAG */
(iw_handler) NULL, /* SIOCGIWFRAG */
(iw_handler) NULL, /* SIOCSIWTXPOW */
(iw_handler) NULL, /* SIOCGIWTXPOW */
(iw_handler) NULL, /* SIOCSIWRETRY */
(iw_handler) NULL, /* SIOCGIWRETRY */
(iw_handler) NULL, /* SIOCSIWENCODE */
(iw_handler) NULL, /* SIOCGIWENCODE */
(iw_handler) NULL, /* SIOCSIWPOWER */
(iw_handler) NULL, /* SIOCGIWPOWER */
};
static const iw_handler nvt_priv_handler[] = {
(iw_handler) nvt_iwpriv_setmib,
(iw_handler) nvt_iwpriv_getmib,
(iw_handler) nvt_iwpriv_setwid,
(iw_handler) nvt_iwpriv_getwid,
(iw_handler) nvt_iwpriv_set_fw_download,
#if 1 /* tx statistic */
(iw_handler) nvt_iwpriv_shwmm,
#endif
};
static const struct iw_priv_args nvt_priv_args[] = {
{SIOCIWFIRSTPRIV,
IW_PRIV_TYPE_CHAR | 1024,
0,
"setmib"},
{SIOCIWFIRSTPRIV + 1,
IW_PRIV_TYPE_CHAR | NVT_IWPRIV_GETMIB_CMD_SIZE,
IW_PRIV_TYPE_CHAR | NVT_IWPRIV_GETMIB_RSP_SIZE,
"getmib" },
{SIOCIWFIRSTPRIV + 2,
IW_PRIV_TYPE_CHAR | NVT_IWPRIV_SETWID_CMD_SIZE,
0,
"setwid" },
{SIOCIWFIRSTPRIV + 3,
IW_PRIV_TYPE_CHAR | NVT_IWPRIV_GETWID_CMD_SIZE,
IW_PRIV_TYPE_CHAR | NVT_IWPRIV_GETWID_CMD_SIZE,
"getwid" },
{SIOCIWFIRSTPRIV + 4,
IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
IW_PRIV_TYPE_NONE,
"set_fw_download" },
#if 1 /* tx statistic */
{SIOCIWFIRSTPRIV + 5,
IW_PRIV_TYPE_NONE,
IW_PRIV_TYPE_NONE,
"shwmm" },
#endif
};
static const struct iw_handler_def nvt_iw_handlers = {
.num_standard = ARRAY_SIZE(nvt_iw_handler),
.num_private = ARRAY_SIZE(nvt_priv_handler),
.num_private_args = ARRAY_SIZE(nvt_priv_args),
.standard = (iw_handler *)nvt_iw_handler,
.private = (iw_handler *)nvt_priv_handler,
.private_args = (struct iw_priv_args *)nvt_priv_args,
};
/**
* nvt_iw_register_handler - iw_handler registration for net_device
* @handler: iw_handler_def structure
*
*
* Return: 0:success, -1:fail
*/
s32 nvt_iw_register_handler(struct net_device *ndev)
{
ndev->wireless_handlers = &nvt_iw_handlers;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink