From 38888ae7327854a4f33d9c55c00fcec5173c0787 Mon Sep 17 00:00:00 2001 From: Alan Chen Date: Fri, 19 Jun 2020 20:19:32 -0700 Subject: [PATCH] qcacld-3.0: Add a sysfs replacement for dl_mode commands As part of WEXT replacement, replace dl_loglevel, dl_mod_loglevel, dl_modoff, dl_modon, dl_report, dl_type, dl_vapoff, dl_vapon with a sysfs file. file path: /sys/class/net/wlanxx/dl_loglevel file path: /sys/class/net/wlanxx/dl_mod_loglevel file path: /sys/class/net/wlanxx/dl_modoff file path: /sys/class/net/wlanxx/dl_modon file path: /sys/class/net/wlanxx/dl_report file path: /sys/class/net/wlanxx/dl_type file path: /sys/class/net/wlanxx/dl_vapoff file path: /sys/class/net/wlanxx/dl_vapon wlanxx is adapter name example: echo 1 > dl_loglevel example: echo 1 > dl_mod_loglevel example: echo 1 > dl_modoff example: echo 1 > dl_modon example: echo 1 > dl_report example: echo 1 > dl_type example: echo 1 > dl_vapoff example: echo 1 > dl_vapon Change-Id: Ic3d748738d0072e42b7ff07177f2ca711b333193 CRs-Fixed: 2715053 --- Kbuild | 4 + configs/default_defconfig | 1 + core/hdd/src/wlan_hdd_sysfs.c | 5 + core/hdd/src/wlan_hdd_sysfs_dl_modes.c | 808 +++++++++++++++++++++++++ core/hdd/src/wlan_hdd_sysfs_dl_modes.h | 114 ++++ 5 files changed, 932 insertions(+) create mode 100644 core/hdd/src/wlan_hdd_sysfs_dl_modes.c create mode 100644 core/hdd/src/wlan_hdd_sysfs_dl_modes.h diff --git a/Kbuild b/Kbuild index a41303195735..cd55e72b865c 100644 --- a/Kbuild +++ b/Kbuild @@ -361,6 +361,9 @@ endif ifeq ($(CONFIG_REMOVE_PKT_LOG), n) HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_sysfs_pktlog.o endif +ifeq ($(CONFIG_WLAN_DL_MODES), y) +HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_sysfs_dl_modes.o +endif HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_sysfs_policy_mgr.o HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_sysfs_dp_aggregation.o endif @@ -2686,6 +2689,7 @@ cppflags-$(CONFIG_WLAN_SYSFS_MEM_STATS) += -DCONFIG_WLAN_SYSFS_MEM_STATS cppflags-$(CONFIG_WLAN_SYSFS_DCM) += -DWLAN_SYSFS_DCM cppflags-$(CONFIG_WLAN_SYSFS_HE_BSS_COLOR) += -DWLAN_SYSFS_HE_BSS_COLOR cppflags-$(CONFIG_WLAN_SYSFS_STA_INFO) += -DWLAN_SYSFS_STA_INFO +cppflags-$(CONFIG_WLAN_DL_MODES) += -DCONFIG_WLAN_DL_MODES ifeq ($(CONFIG_LEAK_DETECTION), y) cppflags-y += \ diff --git a/configs/default_defconfig b/configs/default_defconfig index 2d7dfd24b2a5..159471cb69ea 100644 --- a/configs/default_defconfig +++ b/configs/default_defconfig @@ -224,6 +224,7 @@ ifeq ($(CONFIG_QCOM_TDLS), y) endif CONFIG_WLAN_SYSFS_TEMPERATURE := y CONFIG_WLAN_THERMAL_CFG := y + CONFIG_WLAN_DL_MODES := y endif CONFIG_WLAN_POWER_DEBUG := y diff --git a/core/hdd/src/wlan_hdd_sysfs.c b/core/hdd/src/wlan_hdd_sysfs.c index 826ff69cfacd..51d35d39f443 100644 --- a/core/hdd/src/wlan_hdd_sysfs.c +++ b/core/hdd/src/wlan_hdd_sysfs.c @@ -74,6 +74,7 @@ #include #include #include +#include #define MAX_PSOC_ID_SIZE 10 @@ -665,11 +666,13 @@ hdd_sysfs_create_sta_adapter_root_obj(struct hdd_adapter *adapter) hdd_sysfs_temperature_create(adapter); hdd_sysfs_motion_detection_create(adapter); hdd_sysfs_range_ext_create(adapter); + hdd_sysfs_dl_modes_create(adapter); } static void hdd_sysfs_destroy_sta_adapter_root_obj(struct hdd_adapter *adapter) { + hdd_sysfs_dl_modes_destroy(adapter); hdd_sysfs_range_ext_destroy(adapter); hdd_sysfs_motion_detection_destroy(adapter); hdd_sysfs_temperature_destroy(adapter); @@ -717,11 +720,13 @@ hdd_sysfs_create_sap_adapter_root_obj(struct hdd_adapter *adapter) hdd_sysfs_temperature_create(adapter); hdd_sysfs_range_ext_create(adapter); hdd_sysfs_ipa_create(adapter); + hdd_sysfs_dl_modes_create(adapter); } static void hdd_sysfs_destroy_sap_adapter_root_obj(struct hdd_adapter *adapter) { + hdd_sysfs_dl_modes_destroy(adapter); hdd_sysfs_ipa_destroy(adapter); hdd_sysfs_range_ext_destroy(adapter); hdd_sysfs_temperature_destroy(adapter); diff --git a/core/hdd/src/wlan_hdd_sysfs_dl_modes.c b/core/hdd/src/wlan_hdd_sysfs_dl_modes.c new file mode 100644 index 000000000000..b166243d125c --- /dev/null +++ b/core/hdd/src/wlan_hdd_sysfs_dl_modes.c @@ -0,0 +1,808 @@ +/* + * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved. + * + * 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. + */ + +/** + * DOC: wlan_hdd_sysfs_dl_modes.c + * + * implementation for creating sysfs file dl_modes + */ + +#include +#include +#include "osif_vdev_sync.h" +#include +#include +#include "wmi_unified_param.h" +#include "wma_api.h" + +static int hdd_sysfs_set_dbg(struct hdd_adapter *adapter, + int id, + const char *id_string, + int value) +{ + int errno; + + hdd_debug("%s %d", id_string, value); + errno = wma_cli_set_command(adapter->vdev_id, id, value, DBG_CMD); + if (errno) + hdd_err("Failed to set firmware, errno %d", errno); + + return errno; +} + +#define hdd_sysfs_set_dbg(adapter, id, value) \ + hdd_sysfs_set_dbg(adapter, id, #id, value) + +static ssize_t +__hdd_sysfs_dl_loglevel_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_loglevel: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_LOG_LEVEL, value); + + if (ret) { + hdd_err_rl("failed dl_loglevel: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_loglevel_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_loglevel_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_mod_loglevel_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_mod_loglevel: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_MOD_LOG_LEVEL, value); + + if (ret) { + hdd_err_rl("failed dl_mod_loglevel: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_mod_loglevel_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_mod_loglevel_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_modoff_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_modoff: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_MODULE_DISABLE, value); + + if (ret) { + hdd_err_rl("failed dl_modoff: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_modoff_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_modoff_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_modon_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_modon: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_MODULE_ENABLE, value); + + if (ret) { + hdd_err_rl("failed dl_modon: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_modon_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_modon_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_report_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_report: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_REPORT_ENABLE, value); + + if (ret) { + hdd_err_rl("failed dl_report: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_report_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_report_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_type_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_type: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_TYPE, value); + + if (ret) { + hdd_err_rl("failed dl_type: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_type_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_type_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_vapoff_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_vapoff: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_VAP_DISABLE, value); + + if (ret) { + hdd_err_rl("failed dl_vapoff: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_vapoff_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_vapoff_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static ssize_t +__hdd_sysfs_dl_vapon_store(struct net_device *net_dev, + char const *buf, size_t count) +{ + struct hdd_adapter *adapter = netdev_priv(net_dev); + char buf_local[MAX_SYSFS_USER_COMMAND_SIZE_LENGTH + 1]; + struct hdd_context *hdd_ctx; + char *sptr, *token; + uint32_t value; + int ret; + + if (hdd_validate_adapter(adapter)) { + hdd_err_rl("adapter validate fail"); + return -EINVAL; + } + + hdd_ctx = WLAN_HDD_GET_CTX(adapter); + ret = wlan_hdd_validate_context(hdd_ctx); + if (ret != 0) + return ret; + + if (!wlan_hdd_validate_modules_state(hdd_ctx)) + return -EINVAL; + + ret = hdd_sysfs_validate_and_copy_buf(buf_local, sizeof(buf_local), + buf, count); + + if (ret) { + hdd_err_rl("invalid input"); + return ret; + } + + sptr = buf_local; + hdd_debug("dl_vapon: count %zu buf_local:(%s) net_devname %s", + count, buf_local, net_dev->name); + + /* Get value */ + token = strsep(&sptr, " "); + if (!token) + return -EINVAL; + if (kstrtou32(token, 0, &value)) + return -EINVAL; + + ret = hdd_sysfs_set_dbg(adapter, WMI_DBGLOG_VAP_ENABLE, value); + + if (ret) { + hdd_err_rl("failed dl_vapon: %d", ret); + return ret; + } + + return count; +} + +static ssize_t +hdd_sysfs_dl_vapon_store(struct device *dev, + struct device_attribute *attr, + char const *buf, size_t count) +{ + struct net_device *net_dev = container_of(dev, struct net_device, dev); + struct osif_vdev_sync *vdev_sync; + ssize_t errno_size; + + errno_size = osif_vdev_sync_op_start(net_dev, &vdev_sync); + if (errno_size) + return errno_size; + + errno_size = __hdd_sysfs_dl_vapon_store(net_dev, buf, count); + + osif_vdev_sync_op_stop(vdev_sync); + + return errno_size; +} + +static DEVICE_ATTR(dl_loglevel, 0220, + NULL, hdd_sysfs_dl_loglevel_store); + +static DEVICE_ATTR(dl_mod_loglevel, 0220, + NULL, hdd_sysfs_dl_mod_loglevel_store); + +static DEVICE_ATTR(dl_modoff, 0220, + NULL, hdd_sysfs_dl_modoff_store); + +static DEVICE_ATTR(dl_modon, 0220, + NULL, hdd_sysfs_dl_modon_store); + +static DEVICE_ATTR(dl_report, 0220, + NULL, hdd_sysfs_dl_report_store); + +static DEVICE_ATTR(dl_type, 0220, + NULL, hdd_sysfs_dl_type_store); + +static DEVICE_ATTR(dl_vapoff, 0220, + NULL, hdd_sysfs_dl_vapoff_store); + +static DEVICE_ATTR(dl_vapon, 0220, + NULL, hdd_sysfs_dl_vapon_store); + +static int hdd_sysfs_dl_loglevel_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_loglevel); + if (error) + hdd_err("could not create dl_loglevel sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_loglevel_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_loglevel); +} + +static int hdd_sysfs_dl_mod_loglevel_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, + &dev_attr_dl_mod_loglevel); + if (error) + hdd_err("could not create dl_mod_loglevel sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_mod_loglevel_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_mod_loglevel); +} + +static int hdd_sysfs_dl_modoff_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_modoff); + if (error) + hdd_err("could not create dl_modoff sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_modoff_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_modoff); +} + +static int hdd_sysfs_dl_modon_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_modon); + if (error) + hdd_err("could not create dl_modon sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_modon_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_modon); +} + +static int hdd_sysfs_dl_report_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_report); + if (error) + hdd_err("could not create dl_report sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_report_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_report); +} + +static int hdd_sysfs_dl_type_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_type); + if (error) + hdd_err("could not create dl_type sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_type_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_type); +} + +static int hdd_sysfs_dl_vapoff_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_vapoff); + if (error) + hdd_err("could not create dl_vapoff sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_vapoff_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_vapoff); +} + +static int hdd_sysfs_dl_vapon_create(struct hdd_adapter *adapter) +{ + int error; + + error = device_create_file(&adapter->dev->dev, &dev_attr_dl_vapon); + if (error) + hdd_err("could not create dl_vapon sysfs file"); + + return error; +} + +static void hdd_sysfs_dl_vapon_destroy(struct hdd_adapter *adapter) +{ + device_remove_file(&adapter->dev->dev, &dev_attr_dl_vapon); +} + +void hdd_sysfs_dl_modes_create(struct hdd_adapter *adapter) +{ + hdd_sysfs_dl_loglevel_create(adapter); + hdd_sysfs_dl_mod_loglevel_create(adapter); + hdd_sysfs_dl_modoff_create(adapter); + hdd_sysfs_dl_modon_create(adapter); + hdd_sysfs_dl_report_create(adapter); + hdd_sysfs_dl_type_create(adapter); + hdd_sysfs_dl_vapoff_create(adapter); + hdd_sysfs_dl_vapon_create(adapter); +} + +void hdd_sysfs_dl_modes_destroy(struct hdd_adapter *adapter) +{ + hdd_sysfs_dl_vapon_destroy(adapter); + hdd_sysfs_dl_vapoff_destroy(adapter); + hdd_sysfs_dl_type_destroy(adapter); + hdd_sysfs_dl_report_destroy(adapter); + hdd_sysfs_dl_modon_destroy(adapter); + hdd_sysfs_dl_modoff_destroy(adapter); + hdd_sysfs_dl_mod_loglevel_destroy(adapter); + hdd_sysfs_dl_loglevel_destroy(adapter); +} diff --git a/core/hdd/src/wlan_hdd_sysfs_dl_modes.h b/core/hdd/src/wlan_hdd_sysfs_dl_modes.h new file mode 100644 index 000000000000..a5c956938a33 --- /dev/null +++ b/core/hdd/src/wlan_hdd_sysfs_dl_modes.h @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved. + * + * 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. + */ + +/** + * DOC: wlan_hdd_sysfs_dl_modes.h + * + * implementation for creating sysfs file dl_modes + */ + +#ifndef _WLAN_HDD_SYSFS_DL_MODES_H +#define _WLAN_HDD_SYSFS_DL_MODES_H + +#if defined(WLAN_SYSFS) && defined(CONFIG_WLAN_DL_MODES) +/** + * wlan_hdd_sysfs_dl_modes_create() - API to create motion + * detection sysfs attributes + * @adapter: hdd adapter + * + * This API creates the following sysfs attributes: + * 1. dl_loglevel + * 2. dl_mod_loglevel + * 3. dl_modoff + * 4. dl_modon + * 5. dl_report + * 6. dl_type + * 7. dl_vapoff + * 8. dl_vapon + * + * dl_loglevel: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_loglevel + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_loglevel + * + * dl_mod_loglevel: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_mod_loglevel + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_mod_loglevel + * + * dl_modoff: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_modoff + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > mt_config + * + * dl_modon: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_modon + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_modon + * + * dl_report: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_report + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_report + * + * dl_type: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_type + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_type + * + * dl_vapoff: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_vapoff + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_vapoff + * + * dl_vapon: this file is created per adapter. + * file path: /sys/class/net/wlanxx/dl_vapon + * (wlanxx is adapter name) + * usage: + * echo [arg_0] > dl_vapon + * + * Return: None + */ +void hdd_sysfs_dl_modes_create(struct hdd_adapter *adapter); + +/** + * hdd_sysfs_dl_modes_destroy() - + * API to destroy dl mode sysfs attributes + * @adapter: pointer to adapter + * + * Return: none + */ +void hdd_sysfs_dl_modes_destroy(struct hdd_adapter *adapter); + +#else +static inline void +hdd_sysfs_dl_modes_create(struct hdd_adapter *adapter) +{ +} + +static inline void +hdd_sysfs_dl_modes_destroy(struct hdd_adapter *adapter) +{ +} +#endif +#endif /* #ifndef _WLAN_HDD_SYSFS_DL_MODES_H */