// SPDX-License-Identifier: GPL-2.0
|
|
/******************************************************************************
|
*
|
* Copyright (C) 2020 SeekWave Technology Co.,Ltd.
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of version 2 of the GNU General Public License as
|
* published by the Free Software Foundation;
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
******************************************************************************/
|
|
#include <net/cfg80211.h>
|
#include <net/genetlink.h>
|
|
#include "skw_vendor.h"
|
#include "skw_cfg80211.h"
|
#include "skw_core.h"
|
#include "skw_iface.h"
|
#include "skw_util.h"
|
#include "skw_regd.h"
|
#include "version.h"
|
|
const struct nla_policy
|
skw_set_country_policy[SKW_SET_COUNTRY_RULES] = {
|
[SKW_ATTR_SET_COUNTRY] = {.type = NLA_STRING},
|
};
|
|
const struct nla_policy
|
skw_get_valid_channels_policy[SKW_GET_VALID_CHANNELS_RULES] = {
|
[SKW_ATTR_GET_VALID_CHANNELS] = {.type = NLA_U32},
|
};
|
|
const struct nla_policy
|
skw_get_version_policy[SKW_GET_VERSION_RULES] = {
|
[SKW_ATTR_VERSION_DRIVER] = {.type = NLA_U32},
|
[SKW_ATTR_VERSION_FIRMWARE] = {.type = NLA_U32},
|
};
|
|
#if 0
|
static int skw_vendor_dbg_reset_logging(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
int ret = SKW_OK;
|
|
skw_dbg("Enter\n");
|
|
return ret;
|
}
|
|
static int skw_vendor_set_p2p_rand_mac(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
int type;
|
//struct skw_iface *iface = netdev_priv(wdev->netdev);
|
u8 mac_addr[6] = {0};
|
|
skw_dbg("set skw mac addr\n");
|
type = nla_type(data);
|
|
if (type == SKW_ATTR_DRIVER_RAND_MAC) {
|
memcpy(mac_addr, nla_data(data), 6);
|
skw_dbg("mac:%pM\n", mac_addr);
|
}
|
|
return 0;
|
}
|
|
static int skw_vendor_set_rand_mac_oui(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
char *oui = nla_data(data);
|
struct skw_iface *iface = SKW_WDEV_TO_IFACE(wdev);
|
|
if (!oui || (nla_len(data) != DOT11_OUI_LEN))
|
return -EINVAL;
|
|
skw_dbg("%02x:%02x:%02x\n", oui[0], oui[1], oui[2]);
|
|
memcpy(iface->rand_mac_oui, oui, DOT11_OUI_LEN);
|
|
return 0;
|
}
|
#endif
|
|
static int skw_vendor_cmd_reply(struct wiphy *wiphy, const void *data, int len)
|
{
|
struct sk_buff *skb;
|
int err;
|
|
/* Alloc the SKB for vendor_event */
|
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, len);
|
if (unlikely(!skb)) {
|
skw_err("skb alloc failed");
|
return -ENOMEM;
|
}
|
|
/* Push the data to the skb */
|
err = nla_put_nohdr(skb, len, data);
|
if (err) {
|
kfree_skb(skb);
|
return -EINVAL;
|
}
|
|
return cfg80211_vendor_cmd_reply(skb);
|
}
|
|
static int skw_vendor_start_logging(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
skw_dbg("inst: %d\n", SKW_WDEV_TO_IFACE(wdev)->id);
|
|
return 0;
|
}
|
|
static int skw_vendor_get_wake_reason_stats(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
skw_dbg("inst: %d\n", SKW_WDEV_TO_IFACE(wdev)->id);
|
|
return 0;
|
}
|
|
static int skw_vendor_get_apf_capabilities(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
struct sk_buff *skb;
|
|
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, NLMSG_DEFAULT_SIZE);
|
if (!skb)
|
return -ENOMEM;
|
|
if (nla_put_u32(skb, SKW_ATTR_APF_VERSION, 4) ||
|
nla_put_u32(skb, SKW_ATTR_APF_MAX_LEN, 1024)) {
|
kfree_skb(skb);
|
return -ENOMEM;
|
}
|
|
return cfg80211_vendor_cmd_reply(skb);
|
}
|
|
static int skw_vendor_get_ring_buffer_data(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
skw_dbg("inst: %d\n", SKW_WDEV_TO_IFACE(wdev)->id);
|
|
return 0;
|
}
|
|
static int skw_vendor_get_firmware_dump(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
skw_dbg("inst: %d\n", SKW_WDEV_TO_IFACE(wdev)->id);
|
|
return 0;
|
}
|
|
static int skw_vendor_select_tx_power_scenario(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
skw_dbg("inst: %d\n", SKW_WDEV_TO_IFACE(wdev)->id);
|
|
return 0;
|
}
|
|
static int skw_vendor_set_latency_mode(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
skw_dbg("inst: %d\n", SKW_WDEV_TO_IFACE(wdev)->id);
|
|
return 0;
|
}
|
|
static int skw_vendor_get_feature_set(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
u32 feature_set = 0;
|
|
/* Hardcoding these values for now, need to get
|
* these values from FW, will change in a later check-in
|
*/
|
feature_set |= WIFI_FEATURE_INFRA;
|
feature_set |= WIFI_FEATURE_INFRA_5G;
|
feature_set |= WIFI_FEATURE_P2P;
|
feature_set |= WIFI_FEATURE_SOFT_AP;
|
feature_set |= WIFI_FEATURE_AP_STA;
|
//feature_set |= WIFI_FEATURE_TDLS;
|
//feature_set |= WIFI_FEATURE_TDLS_OFFCHANNEL;
|
//feature_set |= WIFI_FEATURE_NAN;
|
//feature_set |= WIFI_FEATURE_HOTSPOT;
|
//feature_set |= WIFI_FEATURE_LINK_LAYER_STATS; //TBC
|
//feature_set |= WIFI_FEATURE_RSSI_MONITOR; //TBC with roaming
|
//feature_set |= WIFI_FEATURE_MKEEP_ALIVE; //TBC compare with QUALCOM
|
//feature_set |= WIFI_FEATURE_CONFIG_NDO; //TBC
|
//feature_set |= WIFI_FEATURE_SCAN_RAND;
|
//feature_set |= WIFI_FEATURE_RAND_MAC;
|
//feature_set |= WIFI_FEATURE_P2P_RAND_MAC ;
|
//feature_set |= WIFI_FEATURE_CONTROL_ROAMING;
|
|
skw_dbg("feature: 0x%x\n", feature_set);
|
|
return skw_vendor_cmd_reply(wiphy, &feature_set, sizeof(u32));
|
}
|
|
static int skw_vendor_set_country(struct wiphy *wiphy, struct wireless_dev *wdev,
|
const void *data, int data_len)
|
{
|
char *country = nla_data(data);
|
|
if (nla_type(data) != SKW_ATTR_SET_COUNTRY)
|
skw_warn("attr mismatch, type: %d\n", nla_type(data));
|
|
if (!country || strlen(country) != 2) {
|
skw_err("invalid, country: %s\n", country ? country : "null");
|
|
return -EINVAL;
|
}
|
|
skw_dbg("country: %c%c\n", country[0], country[1]);
|
|
return skw_set_regdom(wiphy, country);
|
}
|
|
static int skw_vendor_get_version(struct wiphy *wiphy, struct wireless_dev *wdev,
|
const void *data, int len)
|
{
|
char version[64] = {0};
|
struct skw_core *skw = wiphy_priv(wiphy);
|
|
switch (nla_type(data)) {
|
case SKW_ATTR_VERSION_DRIVER:
|
strncpy(version, SKW_VERSION, sizeof(version));
|
break;
|
|
case SKW_ATTR_VERSION_FIRMWARE:
|
snprintf(version, sizeof(version), "%s-%s",
|
skw->fw.plat_ver, skw->fw.wifi_ver);
|
break;
|
|
default:
|
skw_err("invalid nla type\n");
|
strcpy(version, "invalid");
|
break;
|
}
|
|
return skw_vendor_cmd_reply(wiphy, version, sizeof(version));
|
}
|
|
static int skw_vendor_get_usable_channels(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
int i, nr, max;
|
struct sk_buff *skb;
|
enum nl80211_band band;
|
struct skw_usable_chan *chans;
|
struct skw_usable_chan_req *req = (struct skw_usable_chan_req *)data;
|
|
skw_dbg("band_mask: 0x%x\n", req->band_mask);
|
|
max = ieee80211_get_num_supported_channels(wiphy);
|
|
chans = SKW_ZALLOC(max * sizeof(*chans), GFP_KERNEL);
|
if (!chans)
|
return -ENOMEM;
|
|
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, NLMSG_DEFAULT_SIZE);
|
if (!skb) {
|
SKW_KFREE(chans);
|
return -ENOMEM;
|
}
|
|
for (nr = 0, band = 0; band < NUM_NL80211_BANDS; band++) {
|
if (!(req->band_mask & BIT(to_skw_band(band))) ||
|
!wiphy->bands[band])
|
continue;
|
|
for (i = 0; i < wiphy->bands[band]->n_channels; i++) {
|
struct ieee80211_channel *chan;
|
|
chan = &wiphy->bands[band]->channels[i];
|
|
if (chan->flags & IEEE80211_CHAN_DISABLED)
|
continue;
|
|
chans[nr].center_freq = chan->center_freq;
|
chans[nr].band_width = SKW_CHAN_WIDTH_20;
|
chans[nr].iface_mode_mask = BIT(SKW_STA_MODE) |
|
BIT(SKW_AP_MODE) |
|
BIT(SKW_GC_MODE) |
|
BIT(SKW_GO_MODE);
|
nr++;
|
}
|
}
|
|
if (nla_put_nohdr(skb, nr * sizeof(*chans), chans)) {
|
SKW_KFREE(chans);
|
kfree_skb(skb);
|
|
return -ENOMEM;
|
}
|
|
SKW_KFREE(chans);
|
|
return cfg80211_vendor_cmd_reply(skb);
|
}
|
|
static int skw_vendor_get_valid_channels(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
int channels[32], size;
|
int i, band, nr_channels;
|
struct sk_buff *skb;
|
|
if (nla_type(data) != SKW_ATTR_GET_VALID_CHANNELS)
|
skw_warn("attr mismatch, type: %d", nla_type(data));
|
|
band = nla_get_u32(data);
|
if (band > NL80211_BAND_5GHZ) {
|
skw_err("invalid band: %d\n", band);
|
return -EINVAL;
|
}
|
|
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, NLMSG_DEFAULT_SIZE);
|
if (!skb)
|
return -ENOMEM;
|
|
nr_channels = wiphy->bands[band]->n_channels;
|
size = nr_channels * sizeof(int);
|
|
for (i = 0; i < nr_channels; i++)
|
channels[i] = wiphy->bands[band]->channels[i].hw_value;
|
|
if (nla_put_u32(skb, SKW_ATTR_VALID_CHANNELS_COUNT, nr_channels) ||
|
nla_put(skb, SKW_ATTR_VALID_CHANNELS_LIST, size, channels)) {
|
kfree_skb(skb);
|
|
return -ENOMEM;
|
}
|
|
return cfg80211_vendor_cmd_reply(skb);
|
}
|
|
static int skw_vendor_get_ring_buffers_status(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
struct sk_buff *skb;
|
struct skw_ring_buff_status status = {
|
.name = "skw_drv",
|
.flags = 0,
|
.ring_id = 0,
|
.ring_buffer_byte_size = 1024,
|
.verbose_level = 0,
|
.written_bytes = 0,
|
.read_bytes = 0,
|
.written_records = 0,
|
};
|
|
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, NLMSG_DEFAULT_SIZE);
|
if (!skb)
|
return -ENOMEM;
|
|
if (nla_put_u32(skb, SKW_ATTR_RING_BUFFERS_COUNT, 1) ||
|
nla_put(skb, SKW_ATTR_RING_BUFFERS_STATUS, sizeof(status), &status)) {
|
kfree_skb(skb);
|
|
return -ENOMEM;
|
}
|
|
return cfg80211_vendor_cmd_reply(skb);
|
}
|
|
static int skw_vendor_get_logger_feature(struct wiphy *wiphy,
|
struct wireless_dev *wdev, const void *data, int len)
|
{
|
u32 features = 0;
|
|
skw_dbg("features: 0x%x\n", features);
|
|
return skw_vendor_cmd_reply(wiphy, &features, sizeof(features));
|
}
|
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 3, 0))
|
#define SKW_VENDOR_CMD(oui, cmd, flag, func, nla_policy, max_attr) \
|
{ \
|
.info = {.vendor_id = oui, .subcmd = cmd}, \
|
.flags = flag, \
|
.doit = func, \
|
.policy = nla_policy, \
|
.maxattr = max_attr, \
|
}
|
#else
|
#define SKW_VENDOR_CMD(oui, cmd, flag, func, nla_policy, max_attr) \
|
{ \
|
.info = {.vendor_id = oui, .subcmd = cmd}, \
|
.flags = flag, \
|
.doit = func, \
|
}
|
#endif
|
|
#define SKW_VENDOR_DEFAULT_FLAGS (WIPHY_VENDOR_CMD_NEED_WDEV | \
|
WIPHY_VENDOR_CMD_NEED_NETDEV)
|
|
static struct wiphy_vendor_command skw_vendor_cmds[] = {
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_VALID_CHANNELS,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_valid_channels,
|
skw_get_valid_channels_policy,
|
SKW_GET_VALID_CHANNELS_RULES),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_FEATURE_SET,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_feature_set,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_VERSION,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_version,
|
skw_get_version_policy,
|
SKW_GET_VERSION_RULES),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_RING_BUFFERS_STATUS,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_ring_buffers_status,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_LOGGER_FEATURE,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_logger_feature,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_APF_CAPABILITIES,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_apf_capabilities,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_USABLE_CHANS,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_usable_channels,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_SET_COUNTRY,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_set_country,
|
skw_set_country_policy, SKW_SET_COUNTRY_RULES),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_START_LOGGING,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_start_logging,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_FIRMWARE_DUMP,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_firmware_dump,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_RING_BUFFER_DATA,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_ring_buffer_data,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_GET_WAKE_REASON_STATS,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_get_wake_reason_stats,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_SELECT_TX_POWER_SCENARIO,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_select_tx_power_scenario,
|
VENDOR_CMD_RAW_DATA, 0),
|
SKW_VENDOR_CMD(OUI_GOOGLE, SKW_VID_SET_LATENCY_MODE,
|
SKW_VENDOR_DEFAULT_FLAGS,
|
skw_vendor_set_latency_mode,
|
VENDOR_CMD_RAW_DATA, 0),
|
};
|
|
static struct nl80211_vendor_cmd_info skw_vendor_events[] = {
|
{
|
.vendor_id = 0,
|
.subcmd = 0,
|
},
|
};
|
|
void skw_vendor_init(struct wiphy *wiphy)
|
{
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
|
wiphy->vendor_commands = skw_vendor_cmds;
|
wiphy->n_vendor_commands = ARRAY_SIZE(skw_vendor_cmds);
|
wiphy->vendor_events = skw_vendor_events;
|
wiphy->n_vendor_events = ARRAY_SIZE(skw_vendor_events);
|
#else
|
skw_dbg("cmd: %d, event: %d\n", ARRAY_SIZE(skw_vendor_cmds),
|
ARRAY_SIZE(skw_vendor_events));
|
#endif
|
}
|
|
void skw_vendor_deinit(struct wiphy *wiphy)
|
{
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
|
wiphy->vendor_commands = NULL;
|
wiphy->n_vendor_commands = 0;
|
#endif
|
}
|
