samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
انشعاب 0
کد مسائل تقاضاهای واکشی Actions Packages پروژه‌ها انتشارها دانشنامه فعالیت
Files
06f5bc45bcb4d1024e7c21dc7a3d71e36ef99b17
android_kernel_samsung_sm86…/cnss2/main.c
Jayachandran Sreekumaran 92d5d3faf6 cnss2: dump_enabled need to be checked before invoking qcom_dump 
Dump_enabled need to be checked before invoking qcom_dump for
pushing the Wlan FW dump to file system. Otherwise SSR gets stuck.

CRs-Fixed: 3805707
Change-Id: I7bd5d0579f71c1b3fa88fc41cd274bc8f432dab5
2024-05-07 06:47:47 -07:00

5745 خطوط
149 KiB
C
خام سرزنش تاریخچه

// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/delay.h>
#include <linux/devcoredump.h>
#include <linux/elf.h>
#include <linux/jiffies.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/pm_wakeup.h>
#include <linux/reboot.h>
#include <linux/rwsem.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/thermal.h>
#include <linux/version.h>
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 14, 0))
#include <linux/panic_notifier.h>
#endif
#if IS_ENABLED(CONFIG_QCOM_MINIDUMP)
#include <soc/qcom/minidump.h>
#endif
#include "cnss_plat_ipc_qmi.h"
#include "cnss_utils.h"
#include "main.h"
#include "bus.h"
#include "debug.h"
#include "genl.h"
#include "reg.h"
#ifdef CONFIG_CNSS_HW_SECURE_DISABLE
#ifdef CONFIG_CNSS_HW_SECURE_SMEM
#include <linux/soc/qcom/smem.h>
#define PERISEC_SMEM_ID 651
#define HW_WIFI_UID 0x508
#else
#include "smcinvoke.h"
#include "smcinvoke_object.h"
#include "IClientEnv.h"
#define HW_STATE_UID 0x108
#define HW_OP_GET_STATE 1
#define HW_WIFI_UID 0x508
#define FEATURE_NOT_SUPPORTED 12
#define PERIPHERAL_NOT_FOUND 10
#endif
#endif
#define CNSS_DUMP_FORMAT_VER 0x11
#define CNSS_DUMP_FORMAT_VER_V2 0x22
#define CNSS_DUMP_MAGIC_VER_V2 0x42445953
#define CNSS_DUMP_NAME "CNSS_WLAN"
#define CNSS_DUMP_DESC_SIZE 0x1000
#define CNSS_DUMP_SEG_VER 0x1
#define FILE_SYSTEM_READY 1
#define FW_READY_TIMEOUT 20000
#define FW_ASSERT_TIMEOUT 5000
#define CNSS_EVENT_PENDING 2989
#define POWER_RESET_MIN_DELAY_MS 100
#define MAX_NAME_LEN 12
#define CNSS_QUIRKS_DEFAULT 0
#ifdef CONFIG_CNSS_EMULATION
#define CNSS_MHI_TIMEOUT_DEFAULT 90000
#define CNSS_MHI_M2_TIMEOUT_DEFAULT 2000
#define CNSS_QMI_TIMEOUT_DEFAULT 90000
#else
#define CNSS_MHI_TIMEOUT_DEFAULT 0
#define CNSS_MHI_M2_TIMEOUT_DEFAULT 25
#define CNSS_QMI_TIMEOUT_DEFAULT 10000
#endif
#define CNSS_BDF_TYPE_DEFAULT CNSS_BDF_ELF
#define CNSS_TIME_SYNC_PERIOD_DEFAULT 900000
#define CNSS_MIN_TIME_SYNC_PERIOD 2000
#define CNSS_DMS_QMI_CONNECTION_WAIT_MS 50
#define CNSS_DMS_QMI_CONNECTION_WAIT_RETRY 200
#define CNSS_DAEMON_CONNECT_TIMEOUT_MS 30000
#define CNSS_CAL_DB_FILE_NAME "wlfw_cal_db.bin"
#define CNSS_CAL_START_PROBE_WAIT_RETRY_MAX 100
#define CNSS_CAL_START_PROBE_WAIT_MS 500
#define CNSS_TIME_SYNC_PERIOD_INVALID 0xFFFFFFFF
enum cnss_cal_db_op {
CNSS_CAL_DB_UPLOAD,
CNSS_CAL_DB_DOWNLOAD,
CNSS_CAL_DB_INVALID_OP,
};
enum cnss_recovery_type {
CNSS_WLAN_RECOVERY = 0x1,
CNSS_PCSS_RECOVERY = 0x2,
};
#ifdef CONFIG_CNSS_SUPPORT_DUAL_DEV
#define CNSS_MAX_DEV_NUM 2
static struct cnss_plat_data *plat_env[CNSS_MAX_DEV_NUM];
static atomic_t plat_env_count;
#else
static struct cnss_plat_data *plat_env;
#endif
static bool cnss_allow_driver_loading;
static struct cnss_fw_files FW_FILES_QCA6174_FW_3_0 = {
"qwlan30.bin", "bdwlan30.bin", "otp30.bin", "utf30.bin",
"utfbd30.bin", "epping30.bin", "evicted30.bin"
};
static struct cnss_fw_files FW_FILES_DEFAULT = {
"qwlan.bin", "bdwlan.bin", "otp.bin", "utf.bin",
"utfbd.bin", "epping.bin", "evicted.bin"
};
struct cnss_driver_event {
struct list_head list;
enum cnss_driver_event_type type;
bool sync;
struct completion complete;
int ret;
void *data;
};
bool cnss_check_driver_loading_allowed(void)
{
return cnss_allow_driver_loading;
}
#ifdef CONFIG_CNSS_SUPPORT_DUAL_DEV
static void cnss_init_plat_env_count(void)
{
atomic_set(&plat_env_count, 0);
}
static void cnss_inc_plat_env_count(void)
{
atomic_inc(&plat_env_count);
}
static void cnss_dec_plat_env_count(void)
{
atomic_dec(&plat_env_count);
}
static int cnss_get_plat_env_count(void)
{
return atomic_read(&plat_env_count);
}
int cnss_get_max_plat_env_count(void)
{
return CNSS_MAX_DEV_NUM;
}
static void cnss_set_plat_priv(struct platform_device *plat_dev,
struct cnss_plat_data *plat_priv)
{
int env_count = cnss_get_plat_env_count();
cnss_pr_dbg("Set plat_priv at %d", env_count);
if (plat_priv) {
plat_priv->plat_idx = env_count;
plat_env[plat_priv->plat_idx] = plat_priv;
cnss_inc_plat_env_count();
}
}
struct cnss_plat_data *cnss_get_plat_priv(struct platform_device
*plat_dev)
{
int i;
if (!plat_dev)
return NULL;
for (i = 0; i < CNSS_MAX_DEV_NUM; i++) {
if (plat_env[i] && plat_env[i]->plat_dev == plat_dev)
return plat_env[i];
}
return NULL;
}
struct cnss_plat_data *cnss_get_first_plat_priv(struct platform_device
*plat_dev)
{
int i;
if (!plat_dev) {
for (i = 0; i < CNSS_MAX_DEV_NUM; i++) {
if (plat_env[i])
return plat_env[i];
}
}
return NULL;
}
static void cnss_clear_plat_priv(struct cnss_plat_data *plat_priv)
{
cnss_pr_dbg("Clear plat_priv at %d", plat_priv->plat_idx);
plat_env[plat_priv->plat_idx] = NULL;
cnss_dec_plat_env_count();
}
static int cnss_set_device_name(struct cnss_plat_data *plat_priv)
{
snprintf(plat_priv->device_name, sizeof(plat_priv->device_name),
"wlan_%d", plat_priv->plat_idx);
return 0;
}
static int cnss_plat_env_available(void)
{
int ret = 0;
int env_count = cnss_get_plat_env_count();
if (env_count >= CNSS_MAX_DEV_NUM) {
cnss_pr_err("ERROR: No space to store plat_priv\n");
ret = -ENOMEM;
}
return ret;
}
struct cnss_plat_data *cnss_get_plat_env(int index)
{
return plat_env[index];
}
struct cnss_plat_data *cnss_get_plat_priv_by_rc_num(int rc_num)
{
int i;
for (i = 0; i < CNSS_MAX_DEV_NUM; i++) {
if (plat_env[i] && plat_env[i]->rc_num == rc_num)
return plat_env[i];
}
return NULL;
}
static inline int
cnss_get_qrtr_node_id(struct cnss_plat_data *plat_priv)
{
return of_property_read_u32(plat_priv->dev_node,
"qcom,qrtr_node_id", &plat_priv->qrtr_node_id);
}
void cnss_get_qrtr_info(struct cnss_plat_data *plat_priv)
{
int ret = 0;
ret = cnss_get_qrtr_node_id(plat_priv);
if (ret) {
cnss_pr_warn("Failed to find qrtr_node_id err=%d\n", ret);
plat_priv->qrtr_node_id = 0;
plat_priv->wlfw_service_instance_id = 0;
} else {
plat_priv->wlfw_service_instance_id = plat_priv->qrtr_node_id +
QRTR_NODE_FW_ID_BASE;
cnss_pr_dbg("service_instance_id=0x%x\n",
plat_priv->wlfw_service_instance_id);
}
}
static inline int
cnss_get_pld_bus_ops_name(struct cnss_plat_data *plat_priv)
{
return of_property_read_string(plat_priv->plat_dev->dev.of_node,
"qcom,pld_bus_ops_name",
&plat_priv->pld_bus_ops_name);
}
#else
static void cnss_init_plat_env_count(void)
{
}
static void cnss_set_plat_priv(struct platform_device *plat_dev,
struct cnss_plat_data *plat_priv)
{
plat_env = plat_priv;
}
struct cnss_plat_data *cnss_get_plat_priv(struct platform_device *plat_dev)
{
return plat_env;
}
static void cnss_clear_plat_priv(struct cnss_plat_data *plat_priv)
{
plat_env = NULL;
}
static int cnss_set_device_name(struct cnss_plat_data *plat_priv)
{
snprintf(plat_priv->device_name, sizeof(plat_priv->device_name),
"wlan");
return 0;
}
static int cnss_plat_env_available(void)
{
return 0;
}
struct cnss_plat_data *cnss_get_plat_priv_by_rc_num(int rc_num)
{
return cnss_bus_dev_to_plat_priv(NULL);
}
void cnss_get_qrtr_info(struct cnss_plat_data *plat_priv)
{
}
static int
cnss_get_pld_bus_ops_name(struct cnss_plat_data *plat_priv)
{
return 0;
}
#endif
void cnss_get_sleep_clk_supported(struct cnss_plat_data *plat_priv)
{
plat_priv->sleep_clk = of_property_read_bool(plat_priv->dev_node,
"qcom,sleep-clk-support");
cnss_pr_dbg("qcom,sleep-clk-support is %d\n",
plat_priv->sleep_clk);
}
void cnss_get_bwscal_info(struct cnss_plat_data *plat_priv)
{
plat_priv->no_bwscale = of_property_read_bool(plat_priv->dev_node,
"qcom,no-bwscale");
}
static inline int
cnss_get_rc_num(struct cnss_plat_data *plat_priv)
{
return of_property_read_u32(plat_priv->plat_dev->dev.of_node,
"qcom,wlan-rc-num", &plat_priv->rc_num);
}
bool cnss_is_dual_wlan_enabled(void)
{
return IS_ENABLED(CONFIG_CNSS_SUPPORT_DUAL_DEV);
}
/**
* cnss_get_mem_seg_count - Get segment count of memory
* @type: memory type
* @seg: segment count
*
* Return: 0 on success, negative value on failure
*/
int cnss_get_mem_seg_count(enum cnss_remote_mem_type type, u32 *seg)
{
struct cnss_plat_data *plat_priv;
plat_priv = cnss_get_plat_priv(NULL);
if (!plat_priv)
return -ENODEV;
switch (type) {
case CNSS_REMOTE_MEM_TYPE_FW:
*seg = plat_priv->fw_mem_seg_len;
break;
case CNSS_REMOTE_MEM_TYPE_QDSS:
*seg = plat_priv->qdss_mem_seg_len;
break;
default:
return -EINVAL;
}
return 0;
}
EXPORT_SYMBOL(cnss_get_mem_seg_count);
/**
* cnss_get_wifi_kobject -return wifi kobject
* Return: Null, to maintain driver comnpatibilty
*/
struct kobject *cnss_get_wifi_kobj(struct device *dev)
{
struct cnss_plat_data *plat_priv;
plat_priv = cnss_get_plat_priv(NULL);
if (!plat_priv)
return NULL;
return plat_priv->wifi_kobj;
}
EXPORT_SYMBOL(cnss_get_wifi_kobj);
/**
* cnss_get_mem_segment_info - Get memory info of different type
* @type: memory type
* @segment: array to save the segment info
* @seg: segment count
*
* Return: 0 on success, negative value on failure
*/
int cnss_get_mem_segment_info(enum cnss_remote_mem_type type,
struct cnss_mem_segment segment[],
u32 segment_count)
{
struct cnss_plat_data *plat_priv;
u32 i;
plat_priv = cnss_get_plat_priv(NULL);
if (!plat_priv)
return -ENODEV;
switch (type) {
case CNSS_REMOTE_MEM_TYPE_FW:
if (segment_count > plat_priv->fw_mem_seg_len)
segment_count = plat_priv->fw_mem_seg_len;
for (i = 0; i < segment_count; i++) {
segment[i].size = plat_priv->fw_mem[i].size;
segment[i].va = plat_priv->fw_mem[i].va;
segment[i].pa = plat_priv->fw_mem[i].pa;
}
break;
case CNSS_REMOTE_MEM_TYPE_QDSS:
if (segment_count > plat_priv->qdss_mem_seg_len)
segment_count = plat_priv->qdss_mem_seg_len;
for (i = 0; i < segment_count; i++) {
segment[i].size = plat_priv->qdss_mem[i].size;
segment[i].va = plat_priv->qdss_mem[i].va;
segment[i].pa = plat_priv->qdss_mem[i].pa;
}
break;
default:
return -EINVAL;
}
return 0;
}
EXPORT_SYMBOL(cnss_get_mem_segment_info);
static int cnss_get_audio_iommu_domain(struct cnss_plat_data *plat_priv)
{
struct device_node *audio_ion_node;
struct platform_device *audio_ion_pdev;
audio_ion_node = of_find_compatible_node(NULL, NULL,
"qcom,msm-audio-ion");
if (!audio_ion_node) {
cnss_pr_err("Unable to get Audio ion node");
return -EINVAL;
}
audio_ion_pdev = of_find_device_by_node(audio_ion_node);
of_node_put(audio_ion_node);
if (!audio_ion_pdev) {
cnss_pr_err("Unable to get Audio ion platform device");
return -EINVAL;
}
plat_priv->audio_iommu_domain =
iommu_get_domain_for_dev(&audio_ion_pdev->dev);
put_device(&audio_ion_pdev->dev);
if (!plat_priv->audio_iommu_domain) {
cnss_pr_err("Unable to get Audio ion iommu domain");
return -EINVAL;
}
return 0;
}
bool cnss_get_audio_shared_iommu_group_cap(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
struct device_node *audio_ion_node;
struct device_node *cnss_iommu_group_node;
struct device_node *audio_iommu_group_node;
if (!plat_priv)
return false;
audio_ion_node = of_find_compatible_node(NULL, NULL,
"qcom,msm-audio-ion");
if (!audio_ion_node) {
cnss_pr_err("Unable to get Audio ion node");
return false;
}
audio_iommu_group_node = of_parse_phandle(audio_ion_node,
"qcom,iommu-group", 0);
of_node_put(audio_ion_node);
if (!audio_iommu_group_node) {
cnss_pr_err("Unable to get audio iommu group phandle");
return false;
}
of_node_put(audio_iommu_group_node);
cnss_iommu_group_node = of_parse_phandle(dev->of_node,
"qcom,iommu-group", 0);
if (!cnss_iommu_group_node) {
cnss_pr_err("Unable to get cnss iommu group phandle");
return false;
}
of_node_put(cnss_iommu_group_node);
if (cnss_iommu_group_node == audio_iommu_group_node) {
plat_priv->is_audio_shared_iommu_group = true;
cnss_pr_info("CNSS and Audio share IOMMU group");
} else {
cnss_pr_info("CNSS and Audio do not share IOMMU group");
}
return plat_priv->is_audio_shared_iommu_group;
}
EXPORT_SYMBOL(cnss_get_audio_shared_iommu_group_cap);
int cnss_set_feature_list(struct cnss_plat_data *plat_priv,
enum cnss_feature_v01 feature)
{
if (unlikely(!plat_priv || feature >= CNSS_MAX_FEATURE_V01))
return -EINVAL;
plat_priv->feature_list |= 1 << feature;
return 0;
}
int cnss_clear_feature_list(struct cnss_plat_data *plat_priv,
enum cnss_feature_v01 feature)
{
if (unlikely(!plat_priv || feature >= CNSS_MAX_FEATURE_V01))
return -EINVAL;
plat_priv->feature_list &= ~(1 << feature);
return 0;
}
int cnss_get_feature_list(struct cnss_plat_data *plat_priv,
u64 *feature_list)
{
if (unlikely(!plat_priv))
return -EINVAL;
*feature_list = plat_priv->feature_list;
return 0;
}
size_t cnss_get_platform_name(struct cnss_plat_data *plat_priv,
char *buf, const size_t buf_len)
{
if (unlikely(!plat_priv || !buf || !buf_len))
return 0;
if (of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"platform-name-required")) {
struct device_node *root;
root = of_find_node_by_path("/");
if (root) {
const char *model;
size_t model_len;
model = of_get_property(root, "model", NULL);
if (model) {
model_len = strlcpy(buf, model, buf_len);
cnss_pr_dbg("Platform name: %s (%zu)\n",
buf, model_len);
return model_len;
}
}
}
return 0;
}
void cnss_pm_stay_awake(struct cnss_plat_data *plat_priv)
{
if (atomic_inc_return(&plat_priv->pm_count) != 1)
return;
cnss_pr_dbg("PM stay awake, state: 0x%lx, count: %d\n",
plat_priv->driver_state,
atomic_read(&plat_priv->pm_count));
pm_stay_awake(&plat_priv->plat_dev->dev);
}
void cnss_pm_relax(struct cnss_plat_data *plat_priv)
{
int r = atomic_dec_return(&plat_priv->pm_count);
WARN_ON(r < 0);
if (r != 0)
return;
cnss_pr_dbg("PM relax, state: 0x%lx, count: %d\n",
plat_priv->driver_state,
atomic_read(&plat_priv->pm_count));
pm_relax(&plat_priv->plat_dev->dev);
}
int cnss_get_fw_files_for_target(struct device *dev,
struct cnss_fw_files *pfw_files,
u32 target_type, u32 target_version)
{
if (!pfw_files)
return -ENODEV;
switch (target_version) {
case QCA6174_REV3_VERSION:
case QCA6174_REV3_2_VERSION:
memcpy(pfw_files, &FW_FILES_QCA6174_FW_3_0, sizeof(*pfw_files));
break;
default:
memcpy(pfw_files, &FW_FILES_DEFAULT, sizeof(*pfw_files));
cnss_pr_err("Unknown target version, type: 0x%X, version: 0x%X",
target_type, target_version);
break;
}
return 0;
}
EXPORT_SYMBOL(cnss_get_fw_files_for_target);
int cnss_get_platform_cap(struct device *dev, struct cnss_platform_cap *cap)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -ENODEV;
if (!cap)
return -EINVAL;
*cap = plat_priv->cap;
cnss_pr_dbg("Platform cap_flag is 0x%x\n", cap->cap_flag);
return 0;
}
EXPORT_SYMBOL(cnss_get_platform_cap);
/**
* cnss_get_fw_cap - Check whether FW supports specific capability or not
* @dev: Device
* @fw_cap: FW Capability which needs to be checked
*
* Return: TRUE if supported, FALSE on failure or if not supported
*/
bool cnss_get_fw_cap(struct device *dev, enum cnss_fw_caps fw_cap)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
bool is_supported = false;
if (!plat_priv)
return is_supported;
if (!plat_priv->fw_caps)
return is_supported;
switch (fw_cap) {
case CNSS_FW_CAP_DIRECT_LINK_SUPPORT:
is_supported = !!(plat_priv->fw_caps &
QMI_WLFW_DIRECT_LINK_SUPPORT_V01);
break;
case CNSS_FW_CAP_CALDB_SEG_DDR_SUPPORT:
is_supported = !!(plat_priv->fw_caps &
QMI_WLFW_CALDB_SEG_DDR_SUPPORT_V01);
break;
default:
cnss_pr_err("Invalid FW Capability: 0x%x\n", fw_cap);
}
cnss_pr_dbg("FW Capability 0x%x is %s\n", fw_cap,
is_supported ? "supported" : "not supported");
return is_supported;
}
EXPORT_SYMBOL(cnss_get_fw_cap);
/**
* cnss_audio_is_direct_link_supported - Check whether Audio can be used for direct link support
* @dev: Device
*
* Return: TRUE if supported, FALSE on failure or if not supported
*/
bool cnss_audio_is_direct_link_supported(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
bool is_supported = false;
if (!plat_priv) {
cnss_pr_err("plat_priv not available to check audio direct link cap\n");
return is_supported;
}
if (cnss_get_audio_iommu_domain(plat_priv) == 0)
is_supported = true;
return is_supported;
}
EXPORT_SYMBOL(cnss_audio_is_direct_link_supported);
void cnss_request_pm_qos(struct device *dev, u32 qos_val)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return;
cpu_latency_qos_add_request(&plat_priv->qos_request, qos_val);
}
EXPORT_SYMBOL(cnss_request_pm_qos);
void cnss_remove_pm_qos(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return;
cpu_latency_qos_remove_request(&plat_priv->qos_request);
}
EXPORT_SYMBOL(cnss_remove_pm_qos);
int cnss_wlan_enable(struct device *dev,
struct cnss_wlan_enable_cfg *config,
enum cnss_driver_mode mode,
const char *host_version)
{
int ret = 0;
struct cnss_plat_data *plat_priv;
if (!dev) {
cnss_pr_err("Invalid dev pointer\n");
return -EINVAL;
}
plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -ENODEV;
if (plat_priv->device_id == QCA6174_DEVICE_ID)
return 0;
if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks))
return 0;
if (!config || !host_version) {
cnss_pr_err("Invalid config or host_version pointer\n");
return -EINVAL;
}
cnss_pr_dbg("Mode: %d, config: %pK, host_version: %s\n",
mode, config, host_version);
if (mode == CNSS_WALTEST || mode == CNSS_CCPM)
goto skip_cfg;
if (plat_priv->device_id == QCN7605_DEVICE_ID)
config->send_msi_ce = true;
ret = cnss_wlfw_wlan_cfg_send_sync(plat_priv, config, host_version);
if (ret)
goto out;
skip_cfg:
ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, mode);
out:
return ret;
}
EXPORT_SYMBOL(cnss_wlan_enable);
int cnss_wlan_disable(struct device *dev, enum cnss_driver_mode mode)
{
int ret = 0;
struct cnss_plat_data *plat_priv;
if (!dev) {
cnss_pr_err("Invalid dev pointer\n");
return -EINVAL;
}
plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -ENODEV;
if (plat_priv->device_id == QCA6174_DEVICE_ID)
return 0;
if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks))
return 0;
ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
cnss_bus_free_qdss_mem(plat_priv);
return ret;
}
EXPORT_SYMBOL(cnss_wlan_disable);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 2, 0))
int cnss_iommu_map(struct iommu_domain *domain,
unsigned long iova, phys_addr_t paddr, size_t size, int prot)
{
return iommu_map(domain, iova, paddr, size, prot);
}
#else
int cnss_iommu_map(struct iommu_domain *domain,
unsigned long iova, phys_addr_t paddr, size_t size, int prot)
{
return iommu_map(domain, iova, paddr, size, prot, GFP_KERNEL);
}
#endif
int cnss_audio_smmu_map(struct device *dev, phys_addr_t paddr,
dma_addr_t iova, size_t size)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
uint32_t page_offset;
if (!plat_priv)
return -ENODEV;
if (!plat_priv->audio_iommu_domain)
return -EINVAL;
if (plat_priv->is_audio_shared_iommu_group)
return 0;
page_offset = iova & (PAGE_SIZE - 1);
if (page_offset + size > PAGE_SIZE)
size += PAGE_SIZE;
iova -= page_offset;
paddr -= page_offset;
return cnss_iommu_map(plat_priv->audio_iommu_domain, iova, paddr,
roundup(size, PAGE_SIZE), IOMMU_READ |
IOMMU_WRITE | IOMMU_CACHE);
}
EXPORT_SYMBOL(cnss_audio_smmu_map);
void cnss_audio_smmu_unmap(struct device *dev, dma_addr_t iova, size_t size)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
uint32_t page_offset;
if (!plat_priv || !plat_priv->audio_iommu_domain ||
plat_priv->is_audio_shared_iommu_group)
return;
page_offset = iova & (PAGE_SIZE - 1);
if (page_offset + size > PAGE_SIZE)
size += PAGE_SIZE;
iova -= page_offset;
iommu_unmap(plat_priv->audio_iommu_domain, iova,
roundup(size, PAGE_SIZE));
}
EXPORT_SYMBOL(cnss_audio_smmu_unmap);
int cnss_get_fw_lpass_shared_mem(struct device *dev, dma_addr_t *iova,
size_t *size)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
uint8_t i;
if (!plat_priv)
return -EINVAL;
for (i = 0; i < plat_priv->fw_mem_seg_len; i++) {
if (plat_priv->fw_mem[i].type ==
QMI_WLFW_MEM_LPASS_SHARED_V01) {
*iova = plat_priv->fw_mem[i].pa;
*size = plat_priv->fw_mem[i].size;
return 0;
}
}
return -EINVAL;
}
EXPORT_SYMBOL(cnss_get_fw_lpass_shared_mem);
int cnss_athdiag_read(struct device *dev, u32 offset, u32 mem_type,
u32 data_len, u8 *output)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
int ret = 0;
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL!\n");
return -EINVAL;
}
if (plat_priv->device_id == QCA6174_DEVICE_ID)
return 0;
if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
cnss_pr_err("Invalid state for athdiag read: 0x%lx\n",
plat_priv->driver_state);
ret = -EINVAL;
goto out;
}
ret = cnss_wlfw_athdiag_read_send_sync(plat_priv, offset, mem_type,
data_len, output);
out:
return ret;
}
EXPORT_SYMBOL(cnss_athdiag_read);
int cnss_athdiag_write(struct device *dev, u32 offset, u32 mem_type,
u32 data_len, u8 *input)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
int ret = 0;
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL!\n");
return -EINVAL;
}
if (plat_priv->device_id == QCA6174_DEVICE_ID)
return 0;
if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
cnss_pr_err("Invalid state for athdiag write: 0x%lx\n",
plat_priv->driver_state);
ret = -EINVAL;
goto out;
}
ret = cnss_wlfw_athdiag_write_send_sync(plat_priv, offset, mem_type,
data_len, input);
out:
return ret;
}
EXPORT_SYMBOL(cnss_athdiag_write);
int cnss_set_fw_log_mode(struct device *dev, u8 fw_log_mode)
{
struct cnss_plat_data *plat_priv;
if (!dev) {
cnss_pr_err("Invalid dev pointer\n");
return -EINVAL;
}
plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -ENODEV;
if (plat_priv->device_id == QCA6174_DEVICE_ID)
return 0;
return cnss_wlfw_ini_send_sync(plat_priv, fw_log_mode);
}
EXPORT_SYMBOL(cnss_set_fw_log_mode);
int cnss_set_pcie_gen_speed(struct device *dev, u8 pcie_gen_speed)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -EINVAL;
if (!plat_priv->fw_pcie_gen_switch) {
cnss_pr_err("Firmware does not support PCIe gen switch\n");
return -EOPNOTSUPP;
}
if (pcie_gen_speed < QMI_PCIE_GEN_SPEED_1_V01 ||
pcie_gen_speed > QMI_PCIE_GEN_SPEED_3_V01)
return -EINVAL;
cnss_pr_dbg("WLAN provided PCIE gen speed: %d\n", pcie_gen_speed);
plat_priv->pcie_gen_speed = pcie_gen_speed;
return 0;
}
EXPORT_SYMBOL(cnss_set_pcie_gen_speed);
static bool cnss_is_aux_support_enabled(struct cnss_plat_data *plat_priv)
{
switch (plat_priv->device_id) {
case PEACH_DEVICE_ID:
if (!plat_priv->fw_aux_uc_support) {
cnss_pr_dbg("FW does not support aux uc capability\n");
return false;
}
break;
default:
cnss_pr_dbg("Host does not support aux uc capability\n");
return false;
}
return true;
}
static int cnss_fw_mem_ready_hdlr(struct cnss_plat_data *plat_priv)
{
int ret = 0;
if (!plat_priv)
return -ENODEV;
set_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state);
ret = cnss_wlfw_tgt_cap_send_sync(plat_priv);
if (ret)
goto out;
cnss_bus_load_tme_patch(plat_priv);
cnss_wlfw_tme_patch_dnld_send_sync(plat_priv,
WLFW_TME_LITE_PATCH_FILE_V01);
if (plat_priv->hds_enabled)
cnss_wlfw_bdf_dnld_send_sync(plat_priv, CNSS_BDF_HDS);
cnss_wlfw_bdf_dnld_send_sync(plat_priv, CNSS_BDF_REGDB);
if (plat_priv->device_id == QCN7605_DEVICE_ID)
plat_priv->ctrl_params.bdf_type = CNSS_BDF_BIN;
ret = cnss_wlfw_bdf_dnld_send_sync(plat_priv,
plat_priv->ctrl_params.bdf_type);
if (ret)
goto out;
if (plat_priv->device_id == QCN7605_DEVICE_ID)
return 0;
ret = cnss_bus_load_m3(plat_priv);
if (ret)
goto out;
ret = cnss_wlfw_m3_dnld_send_sync(plat_priv);
if (ret)
goto out;
if (cnss_is_aux_support_enabled(plat_priv)) {
ret = cnss_bus_load_aux(plat_priv);
if (ret)
goto out;
ret = cnss_wlfw_aux_dnld_send_sync(plat_priv);
if (ret)
goto out;
}
cnss_wlfw_qdss_dnld_send_sync(plat_priv);
return 0;
out:
return ret;
}
static int cnss_request_antenna_sharing(struct cnss_plat_data *plat_priv)
{
int ret = 0;
if (!plat_priv->antenna) {
ret = cnss_wlfw_antenna_switch_send_sync(plat_priv);
if (ret)
goto out;
}
if (test_bit(CNSS_COEX_CONNECTED, &plat_priv->driver_state)) {
ret = coex_antenna_switch_to_wlan_send_sync_msg(plat_priv);
if (ret)
goto out;
}
ret = cnss_wlfw_antenna_grant_send_sync(plat_priv);
if (ret)
goto out;
return 0;
out:
return ret;
}
static void cnss_release_antenna_sharing(struct cnss_plat_data *plat_priv)
{
if (test_bit(CNSS_COEX_CONNECTED, &plat_priv->driver_state))
coex_antenna_switch_to_mdm_send_sync_msg(plat_priv);
}
static int cnss_setup_dms_mac(struct cnss_plat_data *plat_priv)
{
u32 i;
int ret = 0;
struct cnss_plat_ipc_daemon_config *cfg;
ret = cnss_qmi_get_dms_mac(plat_priv);
if (ret == 0 && plat_priv->dms.mac_valid)
goto qmi_send;
/* DTSI property use-nv-mac is used to force DMS MAC address for WLAN.
* Thus assert on failure to get MAC from DMS even after retries
*/
if (plat_priv->use_nv_mac) {
/* Check if Daemon says platform support DMS MAC provisioning */
cfg = cnss_plat_ipc_qmi_daemon_config();
if (cfg) {
if (!cfg->dms_mac_addr_supported) {
cnss_pr_err("DMS MAC address not supported\n");
CNSS_ASSERT(0);
return -EINVAL;
}
}
for (i = 0; i < CNSS_DMS_QMI_CONNECTION_WAIT_RETRY; i++) {
if (plat_priv->dms.mac_valid)
break;
ret = cnss_qmi_get_dms_mac(plat_priv);
if (ret == 0)
break;
msleep(CNSS_DMS_QMI_CONNECTION_WAIT_MS);
}
if (!plat_priv->dms.mac_valid) {
cnss_pr_err("Unable to get MAC from DMS after retries\n");
CNSS_ASSERT(0);
return -EINVAL;
}
}
qmi_send:
if (plat_priv->dms.mac_valid)
ret =
cnss_wlfw_wlan_mac_req_send_sync(plat_priv, plat_priv->dms.mac,
ARRAY_SIZE(plat_priv->dms.mac));
return ret;
}
static int cnss_cal_db_mem_update(struct cnss_plat_data *plat_priv,
enum cnss_cal_db_op op, u32 *size)
{
int ret = 0;
u32 timeout = cnss_get_timeout(plat_priv,
CNSS_TIMEOUT_DAEMON_CONNECTION);
enum cnss_plat_ipc_qmi_client_id_v01 client_id =
CNSS_PLAT_IPC_DAEMON_QMI_CLIENT_V01;
if (op >= CNSS_CAL_DB_INVALID_OP)
return -EINVAL;
if (!plat_priv->cbc_file_download) {
cnss_pr_info("CAL DB file not required as per BDF\n");
return 0;
}
if (*size == 0) {
cnss_pr_err("Invalid cal file size\n");
return -EINVAL;
}
if (!test_bit(CNSS_DAEMON_CONNECTED, &plat_priv->driver_state)) {
cnss_pr_info("Waiting for CNSS Daemon connection\n");
ret = wait_for_completion_timeout(&plat_priv->daemon_connected,
msecs_to_jiffies(timeout));
if (!ret) {
cnss_pr_err("Daemon not yet connected\n");
CNSS_ASSERT(0);
return ret;
}
}
if (!plat_priv->cal_mem->va) {
cnss_pr_err("CAL DB Memory not setup for FW\n");
return -EINVAL;
}
/* Copy CAL DB file contents to/from CAL_TYPE_DDR mem allocated to FW */
if (op == CNSS_CAL_DB_DOWNLOAD) {
cnss_pr_dbg("Initiating Calibration file download to mem\n");
ret = cnss_plat_ipc_qmi_file_download(client_id,
CNSS_CAL_DB_FILE_NAME,
plat_priv->cal_mem->va,
size);
} else {
cnss_pr_dbg("Initiating Calibration mem upload to file\n");
ret = cnss_plat_ipc_qmi_file_upload(client_id,
CNSS_CAL_DB_FILE_NAME,
plat_priv->cal_mem->va,
*size);
}
if (ret)
cnss_pr_err("Cal DB file %s %s failure\n",
CNSS_CAL_DB_FILE_NAME,
op == CNSS_CAL_DB_DOWNLOAD ? "download" : "upload");
else
cnss_pr_dbg("Cal DB file %s %s size %d done\n",
CNSS_CAL_DB_FILE_NAME,
op == CNSS_CAL_DB_DOWNLOAD ? "download" : "upload",
*size);
return ret;
}
static int cnss_cal_mem_upload_to_file(struct cnss_plat_data *plat_priv)
{
if (plat_priv->cal_file_size > plat_priv->cal_mem->size) {
cnss_pr_err("Cal file size is larger than Cal DB Mem size\n");
return -EINVAL;
}
return cnss_cal_db_mem_update(plat_priv, CNSS_CAL_DB_UPLOAD,
&plat_priv->cal_file_size);
}
static int cnss_cal_file_download_to_mem(struct cnss_plat_data *plat_priv,
u32 *cal_file_size)
{
/* To download pass the total size of cal DB mem allocated.
* After cal file is download to mem, its size is updated in
* return pointer
*/
*cal_file_size = plat_priv->cal_mem->size;
return cnss_cal_db_mem_update(plat_priv, CNSS_CAL_DB_DOWNLOAD,
cal_file_size);
}
static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv)
{
int ret = 0;
u32 cal_file_size = 0;
if (!plat_priv)
return -ENODEV;
if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) {
cnss_pr_err("Reboot is in progress, ignore FW ready\n");
return -EINVAL;
}
cnss_pr_dbg("Processing FW Init Done..\n");
del_timer(&plat_priv->fw_boot_timer);
set_bit(CNSS_FW_READY, &plat_priv->driver_state);
clear_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state);
cnss_wlfw_send_pcie_gen_speed_sync(plat_priv);
cnss_send_subsys_restart_level_msg(plat_priv);
if (test_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state)) {
clear_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state);
clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
}
if (test_bit(ENABLE_WALTEST, &plat_priv->ctrl_params.quirks)) {
ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,
CNSS_WALTEST);
} else if (test_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state)) {
cnss_request_antenna_sharing(plat_priv);
cnss_cal_file_download_to_mem(plat_priv, &cal_file_size);
cnss_wlfw_cal_report_req_send_sync(plat_priv, cal_file_size);
plat_priv->cal_time = jiffies;
ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,
CNSS_CALIBRATION);
} else {
ret = cnss_setup_dms_mac(plat_priv);
ret = cnss_bus_call_driver_probe(plat_priv);
}
if (ret && test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state))
goto out;
else if (ret)
goto shutdown;
cnss_vreg_unvote_type(plat_priv, CNSS_VREG_PRIM);
return 0;
shutdown:
cnss_bus_dev_shutdown(plat_priv);
clear_bit(CNSS_FW_READY, &plat_priv->driver_state);
clear_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state);
out:
return ret;
}
static char *cnss_driver_event_to_str(enum cnss_driver_event_type type)
{
switch (type) {
case CNSS_DRIVER_EVENT_SERVER_ARRIVE:
return "SERVER_ARRIVE";
case CNSS_DRIVER_EVENT_SERVER_EXIT:
return "SERVER_EXIT";
case CNSS_DRIVER_EVENT_REQUEST_MEM:
return "REQUEST_MEM";
case CNSS_DRIVER_EVENT_FW_MEM_READY:
return "FW_MEM_READY";
case CNSS_DRIVER_EVENT_FW_READY:
return "FW_READY";
case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START:
return "COLD_BOOT_CAL_START";
case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE:
return "COLD_BOOT_CAL_DONE";
case CNSS_DRIVER_EVENT_REGISTER_DRIVER:
return "REGISTER_DRIVER";
case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER:
return "UNREGISTER_DRIVER";
case CNSS_DRIVER_EVENT_RECOVERY:
return "RECOVERY";
case CNSS_DRIVER_EVENT_FORCE_FW_ASSERT:
return "FORCE_FW_ASSERT";
case CNSS_DRIVER_EVENT_POWER_UP:
return "POWER_UP";
case CNSS_DRIVER_EVENT_POWER_DOWN:
return "POWER_DOWN";
case CNSS_DRIVER_EVENT_IDLE_RESTART:
return "IDLE_RESTART";
case CNSS_DRIVER_EVENT_IDLE_SHUTDOWN:
return "IDLE_SHUTDOWN";
case CNSS_DRIVER_EVENT_IMS_WFC_CALL_IND:
return "IMS_WFC_CALL_IND";
case CNSS_DRIVER_EVENT_WLFW_TWT_CFG_IND:
return "WLFW_TWC_CFG_IND";
case CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM:
return "QDSS_TRACE_REQ_MEM";
case CNSS_DRIVER_EVENT_FW_MEM_FILE_SAVE:
return "FW_MEM_FILE_SAVE";
case CNSS_DRIVER_EVENT_QDSS_TRACE_FREE:
return "QDSS_TRACE_FREE";
case CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA:
return "QDSS_TRACE_REQ_DATA";
case CNSS_DRIVER_EVENT_MAX:
return "EVENT_MAX";
}
return "UNKNOWN";
};
int cnss_driver_event_post(struct cnss_plat_data *plat_priv,
enum cnss_driver_event_type type,
u32 flags, void *data)
{
struct cnss_driver_event *event;
unsigned long irq_flags;
int gfp = GFP_KERNEL;
int ret = 0;
if (!plat_priv)
return -ENODEV;
cnss_pr_dbg("Posting event: %s(%d)%s, state: 0x%lx flags: 0x%0x\n",
cnss_driver_event_to_str(type), type,
flags ? "-sync" : "", plat_priv->driver_state, flags);
if (type >= CNSS_DRIVER_EVENT_MAX) {
cnss_pr_err("Invalid Event type: %d, can't post", type);
return -EINVAL;
}
if (in_interrupt() || irqs_disabled())
gfp = GFP_ATOMIC;
event = kzalloc(sizeof(*event), gfp);
if (!event)
return -ENOMEM;
cnss_pm_stay_awake(plat_priv);
event->type = type;
event->data = data;
init_completion(&event->complete);
event->ret = CNSS_EVENT_PENDING;
event->sync = !!(flags & CNSS_EVENT_SYNC);
spin_lock_irqsave(&plat_priv->event_lock, irq_flags);
list_add_tail(&event->list, &plat_priv->event_list);
spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags);
queue_work(plat_priv->event_wq, &plat_priv->event_work);
if (!(flags & CNSS_EVENT_SYNC))
goto out;
if (flags & CNSS_EVENT_UNKILLABLE)
wait_for_completion(&event->complete);
else if (flags & CNSS_EVENT_UNINTERRUPTIBLE)
ret = wait_for_completion_killable(&event->complete);
else
ret = wait_for_completion_interruptible(&event->complete);
cnss_pr_dbg("Completed event: %s(%d), state: 0x%lx, ret: %d/%d\n",
cnss_driver_event_to_str(type), type,
plat_priv->driver_state, ret, event->ret);
spin_lock_irqsave(&plat_priv->event_lock, irq_flags);
if (ret == -ERESTARTSYS && event->ret == CNSS_EVENT_PENDING) {
event->sync = false;
spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags);
ret = -EINTR;
goto out;
}
spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags);
ret = event->ret;
kfree(event);
out:
cnss_pm_relax(plat_priv);
return ret;
}
/**
* cnss_get_timeout - Get timeout for corresponding type.
* @plat_priv: Pointer to platform driver context.
* @cnss_timeout_type: Timeout type.
*
* Return: Timeout in milliseconds.
*/
unsigned int cnss_get_timeout(struct cnss_plat_data *plat_priv,
enum cnss_timeout_type timeout_type)
{
unsigned int qmi_timeout = cnss_get_qmi_timeout(plat_priv);
switch (timeout_type) {
case CNSS_TIMEOUT_QMI:
return qmi_timeout;
case CNSS_TIMEOUT_POWER_UP:
return (qmi_timeout << 2);
case CNSS_TIMEOUT_IDLE_RESTART:
/* In idle restart power up sequence, we have fw_boot_timer to
* handle FW initialization failure.
* It uses WLAN_MISSION_MODE_TIMEOUT, so setup 3x that time to
* account for FW dump collection and FW re-initialization on
* retry.
*/
return (qmi_timeout + WLAN_MISSION_MODE_TIMEOUT * 3);
case CNSS_TIMEOUT_CALIBRATION:
/* Similar to mission mode, in CBC if FW init fails
* fw recovery is tried. Thus return 2x the CBC timeout.
*/
return (qmi_timeout + WLAN_COLD_BOOT_CAL_TIMEOUT * 2);
case CNSS_TIMEOUT_WLAN_WATCHDOG:
return ((qmi_timeout << 1) + WLAN_WD_TIMEOUT_MS);
case CNSS_TIMEOUT_RDDM:
return CNSS_RDDM_TIMEOUT_MS;
case CNSS_TIMEOUT_RECOVERY:
return RECOVERY_TIMEOUT;
case CNSS_TIMEOUT_DAEMON_CONNECTION:
return qmi_timeout + CNSS_DAEMON_CONNECT_TIMEOUT_MS;
default:
return qmi_timeout;
}
}
unsigned int cnss_get_boot_timeout(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return 0;
}
return cnss_get_timeout(plat_priv, CNSS_TIMEOUT_QMI);
}
EXPORT_SYMBOL(cnss_get_boot_timeout);
int cnss_power_up(struct device *dev)
{
int ret = 0;
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
unsigned int timeout;
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
cnss_pr_dbg("Powering up device\n");
ret = cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_POWER_UP,
CNSS_EVENT_SYNC, NULL);
if (ret)
goto out;
if (plat_priv->device_id == QCA6174_DEVICE_ID)
goto out;
timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_POWER_UP);
reinit_completion(&plat_priv->power_up_complete);
ret = wait_for_completion_timeout(&plat_priv->power_up_complete,
msecs_to_jiffies(timeout));
if (!ret) {
cnss_pr_err("Timeout (%ums) waiting for power up to complete\n",
timeout);
ret = -EAGAIN;
goto out;
}
return 0;
out:
return ret;
}
EXPORT_SYMBOL(cnss_power_up);
int cnss_power_down(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
cnss_pr_dbg("Powering down device\n");
return cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_POWER_DOWN,
CNSS_EVENT_SYNC, NULL);
}
EXPORT_SYMBOL(cnss_power_down);
int cnss_idle_restart(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
unsigned int timeout;
int ret = 0;
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (!mutex_trylock(&plat_priv->driver_ops_lock)) {
cnss_pr_dbg("Another driver operation is in progress, ignore idle restart\n");
return -EBUSY;
}
cnss_pr_dbg("Doing idle restart\n");
reinit_completion(&plat_priv->power_up_complete);
if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) {
cnss_pr_dbg("Reboot or shutdown is in progress, ignore idle restart\n");
ret = -EINVAL;
goto out;
}
ret = cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_IDLE_RESTART,
CNSS_EVENT_SYNC_UNINTERRUPTIBLE, NULL);
if (ret == -EINTR && plat_priv->device_id != QCA6174_DEVICE_ID)
cnss_pr_err("Idle restart has been interrupted but device power up is still in progress");
else if (ret)
goto out;
if (plat_priv->device_id == QCA6174_DEVICE_ID) {
ret = cnss_bus_call_driver_probe(plat_priv);
goto out;
}
timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_IDLE_RESTART);
ret = wait_for_completion_timeout(&plat_priv->power_up_complete,
msecs_to_jiffies(timeout));
if (plat_priv->power_up_error) {
ret = plat_priv->power_up_error;
clear_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state);
cnss_pr_dbg("Power up error:%d, exiting\n",
plat_priv->power_up_error);
goto out;
}
if (!ret) {
/* This exception occurs after attempting retry of FW recovery.
* Thus we can safely power off the device.
*/
cnss_fatal_err("Timeout (%ums) waiting for idle restart to complete\n",
timeout);
ret = -ETIMEDOUT;
cnss_power_down(dev);
CNSS_ASSERT(0);
goto out;
}
if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) {
cnss_pr_dbg("Reboot or shutdown is in progress, ignore idle restart\n");
del_timer(&plat_priv->fw_boot_timer);
ret = -EINVAL;
goto out;
}
/* In non-DRV mode, remove MHI satellite configuration. Switching to
* non-DRV is supported only once after device reboots and before wifi
* is turned on. We do not allow switching back to DRV.
* To bring device back into DRV, user needs to reboot device.
*/
if (test_bit(DISABLE_DRV, &plat_priv->ctrl_params.quirks)) {
cnss_pr_dbg("DRV is disabled\n");
cnss_bus_disable_mhi_satellite_cfg(plat_priv);
}
mutex_unlock(&plat_priv->driver_ops_lock);
return 0;
out:
mutex_unlock(&plat_priv->driver_ops_lock);
return ret;
}
EXPORT_SYMBOL(cnss_idle_restart);
int cnss_idle_shutdown(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (test_bit(CNSS_IN_SUSPEND_RESUME, &plat_priv->driver_state)) {
cnss_pr_dbg("System suspend or resume in progress, ignore idle shutdown\n");
return -EAGAIN;
}
cnss_pr_dbg("Doing idle shutdown\n");
if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state) ||
test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state)) {
cnss_pr_dbg("Recovery in progress. Ignore IDLE Shutdown\n");
return -EBUSY;
}
return cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_IDLE_SHUTDOWN,
CNSS_EVENT_SYNC_UNINTERRUPTIBLE, NULL);
}
EXPORT_SYMBOL(cnss_idle_shutdown);
static int cnss_get_resources(struct cnss_plat_data *plat_priv)
{
int ret = 0;
ret = cnss_get_vreg_type(plat_priv, CNSS_VREG_PRIM);
if (ret < 0) {
cnss_pr_err("Failed to get vreg, err = %d\n", ret);
goto out;
}
ret = cnss_get_clk(plat_priv);
if (ret) {
cnss_pr_err("Failed to get clocks, err = %d\n", ret);
goto put_vreg;
}
ret = cnss_get_pinctrl(plat_priv);
if (ret) {
cnss_pr_err("Failed to get pinctrl, err = %d\n", ret);
goto put_clk;
}
return 0;
put_clk:
cnss_put_clk(plat_priv);
put_vreg:
cnss_put_vreg_type(plat_priv, CNSS_VREG_PRIM);
out:
return ret;
}
static void cnss_put_resources(struct cnss_plat_data *plat_priv)
{
cnss_put_clk(plat_priv);
cnss_put_vreg_type(plat_priv, CNSS_VREG_PRIM);
}
#if IS_ENABLED(CONFIG_ESOC) && IS_ENABLED(CONFIG_MSM_SUBSYSTEM_RESTART)
static int cnss_modem_notifier_nb(struct notifier_block *nb,
unsigned long code,
void *ss_handle)
{
struct cnss_plat_data *plat_priv =
container_of(nb, struct cnss_plat_data, modem_nb);
struct cnss_esoc_info *esoc_info;
cnss_pr_dbg("Modem notifier: event %lu\n", code);
if (!plat_priv)
return NOTIFY_DONE;
esoc_info = &plat_priv->esoc_info;
if (code == SUBSYS_AFTER_POWERUP)
esoc_info->modem_current_status = 1;
else if (code == SUBSYS_BEFORE_SHUTDOWN)
esoc_info->modem_current_status = 0;
else
return NOTIFY_DONE;
if (!cnss_bus_call_driver_modem_status(plat_priv,
esoc_info->modem_current_status))
return NOTIFY_DONE;
return NOTIFY_OK;
}
static int cnss_register_esoc(struct cnss_plat_data *plat_priv)
{
int ret = 0;
struct device *dev;
struct cnss_esoc_info *esoc_info;
struct esoc_desc *esoc_desc;
const char *client_desc;
dev = &plat_priv->plat_dev->dev;
esoc_info = &plat_priv->esoc_info;
esoc_info->notify_modem_status =
of_property_read_bool(dev->of_node,
"qcom,notify-modem-status");
if (!esoc_info->notify_modem_status)
goto out;
ret = of_property_read_string_index(dev->of_node, "esoc-names", 0,
&client_desc);
if (ret) {
cnss_pr_dbg("esoc-names is not defined in DT, skip!\n");
} else {
esoc_desc = devm_register_esoc_client(dev, client_desc);
if (IS_ERR_OR_NULL(esoc_desc)) {
ret = PTR_RET(esoc_desc);
cnss_pr_err("Failed to register esoc_desc, err = %d\n",
ret);
goto out;
}
esoc_info->esoc_desc = esoc_desc;
}
plat_priv->modem_nb.notifier_call = cnss_modem_notifier_nb;
esoc_info->modem_current_status = 0;
esoc_info->modem_notify_handler =
subsys_notif_register_notifier(esoc_info->esoc_desc ?
esoc_info->esoc_desc->name :
"modem", &plat_priv->modem_nb);
if (IS_ERR(esoc_info->modem_notify_handler)) {
ret = PTR_ERR(esoc_info->modem_notify_handler);
cnss_pr_err("Failed to register esoc notifier, err = %d\n",
ret);
goto unreg_esoc;
}
return 0;
unreg_esoc:
if (esoc_info->esoc_desc)
devm_unregister_esoc_client(dev, esoc_info->esoc_desc);
out:
return ret;
}
static void cnss_unregister_esoc(struct cnss_plat_data *plat_priv)
{
struct device *dev;
struct cnss_esoc_info *esoc_info;
dev = &plat_priv->plat_dev->dev;
esoc_info = &plat_priv->esoc_info;
if (esoc_info->notify_modem_status)
subsys_notif_unregister_notifier
(esoc_info->modem_notify_handler,
&plat_priv->modem_nb);
if (esoc_info->esoc_desc)
devm_unregister_esoc_client(dev, esoc_info->esoc_desc);
}
#else
static inline int cnss_register_esoc(struct cnss_plat_data *plat_priv)
{
return 0;
}
static inline void cnss_unregister_esoc(struct cnss_plat_data *plat_priv) {}
#endif
int cnss_enable_dev_sol_irq(struct cnss_plat_data *plat_priv)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
int ret = 0;
if (sol_gpio->dev_sol_gpio < 0 || sol_gpio->dev_sol_irq <= 0)
return 0;
ret = enable_irq_wake(sol_gpio->dev_sol_irq);
if (ret)
cnss_pr_err("Failed to enable device SOL as wake IRQ, err = %d\n",
ret);
return ret;
}
int cnss_disable_dev_sol_irq(struct cnss_plat_data *plat_priv)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
int ret = 0;
if (sol_gpio->dev_sol_gpio < 0 || sol_gpio->dev_sol_irq <= 0)
return 0;
ret = disable_irq_wake(sol_gpio->dev_sol_irq);
if (ret)
cnss_pr_err("Failed to disable device SOL as wake IRQ, err = %d\n",
ret);
return ret;
}
int cnss_get_dev_sol_value(struct cnss_plat_data *plat_priv)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
if (sol_gpio->dev_sol_gpio < 0)
return -EINVAL;
return gpio_get_value(sol_gpio->dev_sol_gpio);
}
static irqreturn_t cnss_dev_sol_handler(int irq, void *data)
{
struct cnss_plat_data *plat_priv = data;
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
if (test_bit(CNSS_POWER_OFF, &plat_priv->driver_state)) {
cnss_pr_dbg("Ignore Dev SOL during device power off");
return IRQ_HANDLED;
}
sol_gpio->dev_sol_counter++;
cnss_pr_dbg("WLAN device SOL IRQ (%u) is asserted #%u, dev_sol_val: %d\n",
irq, sol_gpio->dev_sol_counter,
cnss_get_dev_sol_value(plat_priv));
/* Make sure abort current suspend */
cnss_pm_stay_awake(plat_priv);
cnss_pm_relax(plat_priv);
pm_system_wakeup();
cnss_bus_handle_dev_sol_irq(plat_priv);
return IRQ_HANDLED;
}
static int cnss_init_dev_sol_gpio(struct cnss_plat_data *plat_priv)
{
struct device *dev = &plat_priv->plat_dev->dev;
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
int ret = 0;
sol_gpio->dev_sol_gpio = of_get_named_gpio(dev->of_node,
"wlan-dev-sol-gpio", 0);
if (sol_gpio->dev_sol_gpio < 0)
goto out;
cnss_pr_dbg("Get device SOL GPIO (%d) from device node\n",
sol_gpio->dev_sol_gpio);
ret = gpio_request(sol_gpio->dev_sol_gpio, "wlan_dev_sol_gpio");
if (ret) {
cnss_pr_err("Failed to request device SOL GPIO, err = %d\n",
ret);
goto out;
}
gpio_direction_input(sol_gpio->dev_sol_gpio);
sol_gpio->dev_sol_irq = gpio_to_irq(sol_gpio->dev_sol_gpio);
ret = request_irq(sol_gpio->dev_sol_irq, cnss_dev_sol_handler,
IRQF_TRIGGER_FALLING, "wlan_dev_sol_irq", plat_priv);
if (ret) {
cnss_pr_err("Failed to request device SOL IRQ, err = %d\n", ret);
goto free_gpio;
}
return 0;
free_gpio:
gpio_free(sol_gpio->dev_sol_gpio);
out:
return ret;
}
static void cnss_deinit_dev_sol_gpio(struct cnss_plat_data *plat_priv)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
if (sol_gpio->dev_sol_gpio < 0)
return;
free_irq(sol_gpio->dev_sol_irq, plat_priv);
gpio_free(sol_gpio->dev_sol_gpio);
}
int cnss_set_host_sol_value(struct cnss_plat_data *plat_priv, int value)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
if (sol_gpio->host_sol_gpio < 0)
return -EINVAL;
if (value)
cnss_pr_dbg("Assert host SOL GPIO\n");
gpio_set_value(sol_gpio->host_sol_gpio, value);
return 0;
}
int cnss_get_host_sol_value(struct cnss_plat_data *plat_priv)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
if (sol_gpio->host_sol_gpio < 0)
return -EINVAL;
return gpio_get_value(sol_gpio->host_sol_gpio);
}
static int cnss_init_host_sol_gpio(struct cnss_plat_data *plat_priv)
{
struct device *dev = &plat_priv->plat_dev->dev;
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
int ret = 0;
sol_gpio->host_sol_gpio = of_get_named_gpio(dev->of_node,
"wlan-host-sol-gpio", 0);
if (sol_gpio->host_sol_gpio < 0)
goto out;
cnss_pr_dbg("Get host SOL GPIO (%d) from device node\n",
sol_gpio->host_sol_gpio);
ret = gpio_request(sol_gpio->host_sol_gpio, "wlan_host_sol_gpio");
if (ret) {
cnss_pr_err("Failed to request host SOL GPIO, err = %d\n",
ret);
goto out;
}
gpio_direction_output(sol_gpio->host_sol_gpio, 0);
return 0;
out:
return ret;
}
static void cnss_deinit_host_sol_gpio(struct cnss_plat_data *plat_priv)
{
struct cnss_sol_gpio *sol_gpio = &plat_priv->sol_gpio;
if (sol_gpio->host_sol_gpio < 0)
return;
gpio_free(sol_gpio->host_sol_gpio);
}
static int cnss_init_sol_gpio(struct cnss_plat_data *plat_priv)
{
int ret;
ret = cnss_init_dev_sol_gpio(plat_priv);
if (ret)
goto out;
ret = cnss_init_host_sol_gpio(plat_priv);
if (ret)
goto deinit_dev_sol;
return 0;
deinit_dev_sol:
cnss_deinit_dev_sol_gpio(plat_priv);
out:
return ret;
}
static void cnss_deinit_sol_gpio(struct cnss_plat_data *plat_priv)
{
cnss_deinit_host_sol_gpio(plat_priv);
cnss_deinit_dev_sol_gpio(plat_priv);
}
#if IS_ENABLED(CONFIG_MSM_SUBSYSTEM_RESTART)
static int cnss_subsys_powerup(const struct subsys_desc *subsys_desc)
{
struct cnss_plat_data *plat_priv;
int ret = 0;
if (!subsys_desc->dev) {
cnss_pr_err("dev from subsys_desc is NULL\n");
return -ENODEV;
}
plat_priv = dev_get_drvdata(subsys_desc->dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (!plat_priv->driver_state) {
cnss_pr_dbg("subsys powerup is ignored\n");
return 0;
}
ret = cnss_bus_dev_powerup(plat_priv);
if (ret)
__pm_relax(plat_priv->recovery_ws);
return ret;
}
static int cnss_subsys_shutdown(const struct subsys_desc *subsys_desc,
bool force_stop)
{
struct cnss_plat_data *plat_priv;
if (!subsys_desc->dev) {
cnss_pr_err("dev from subsys_desc is NULL\n");
return -ENODEV;
}
plat_priv = dev_get_drvdata(subsys_desc->dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (!plat_priv->driver_state) {
cnss_pr_dbg("subsys shutdown is ignored\n");
return 0;
}
return cnss_bus_dev_shutdown(plat_priv);
}
void cnss_device_crashed(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
struct cnss_subsys_info *subsys_info;
if (!plat_priv)
return;
subsys_info = &plat_priv->subsys_info;
if (subsys_info->subsys_device) {
set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
subsys_set_crash_status(subsys_info->subsys_device, true);
subsystem_restart_dev(subsys_info->subsys_device);
}
}
EXPORT_SYMBOL(cnss_device_crashed);
static void cnss_subsys_crash_shutdown(const struct subsys_desc *subsys_desc)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(subsys_desc->dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return;
}
cnss_bus_dev_crash_shutdown(plat_priv);
}
static int cnss_subsys_ramdump(int enable,
const struct subsys_desc *subsys_desc)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(subsys_desc->dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (!enable)
return 0;
return cnss_bus_dev_ramdump(plat_priv);
}
static void cnss_recovery_work_handler(struct work_struct *work)
{
}
#else
void cnss_recovery_handler(struct cnss_plat_data *plat_priv)
{
int ret;
set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
if (!plat_priv->recovery_enabled)
panic("subsys-restart: Resetting the SoC wlan crashed\n");
cnss_bus_dev_shutdown(plat_priv);
cnss_bus_dev_ramdump(plat_priv);
/* If recovery is triggered before Host driver registration,
* avoid device power up because eventually device will be
* power up as part of driver registration.
*/
if (!test_bit(CNSS_DRIVER_REGISTER, &plat_priv->driver_state) ||
!test_bit(CNSS_DRIVER_REGISTERED, &plat_priv->driver_state)) {
cnss_pr_dbg("Host driver not registered yet, ignore Device Power Up, 0x%lx\n",
plat_priv->driver_state);
return;
}
msleep(POWER_RESET_MIN_DELAY_MS);
ret = cnss_bus_dev_powerup(plat_priv);
if (ret) {
__pm_relax(plat_priv->recovery_ws);
clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
}
return;
}
static void cnss_recovery_work_handler(struct work_struct *work)
{
struct cnss_plat_data *plat_priv =
container_of(work, struct cnss_plat_data, recovery_work);
cnss_recovery_handler(plat_priv);
}
void cnss_device_crashed(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return;
set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
schedule_work(&plat_priv->recovery_work);
}
EXPORT_SYMBOL(cnss_device_crashed);
#endif /* CONFIG_MSM_SUBSYSTEM_RESTART */
void *cnss_get_virt_ramdump_mem(struct device *dev, unsigned long *size)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
struct cnss_ramdump_info *ramdump_info;
if (!plat_priv)
return NULL;
ramdump_info = &plat_priv->ramdump_info;
*size = ramdump_info->ramdump_size;
return ramdump_info->ramdump_va;
}
EXPORT_SYMBOL(cnss_get_virt_ramdump_mem);
static const char *cnss_recovery_reason_to_str(enum cnss_recovery_reason reason)
{
switch (reason) {
case CNSS_REASON_DEFAULT:
return "DEFAULT";
case CNSS_REASON_LINK_DOWN:
return "LINK_DOWN";
case CNSS_REASON_RDDM:
return "RDDM";
case CNSS_REASON_TIMEOUT:
return "TIMEOUT";
}
return "UNKNOWN";
};
static int cnss_do_recovery(struct cnss_plat_data *plat_priv,
enum cnss_recovery_reason reason)
{
int ret;
plat_priv->recovery_count++;
if (plat_priv->device_id == QCA6174_DEVICE_ID)
goto self_recovery;
if (test_bit(SKIP_RECOVERY, &plat_priv->ctrl_params.quirks)) {
cnss_pr_dbg("Skip device recovery\n");
return 0;
}
/* FW recovery sequence has multiple steps and firmware load requires
* linux PM in awake state. Thus hold the cnss wake source until
* WLAN MISSION enabled. CNSS_TIMEOUT_RECOVERY option should cover all
* time taken in this process.
*/
pm_wakeup_ws_event(plat_priv->recovery_ws,
cnss_get_timeout(plat_priv, CNSS_TIMEOUT_RECOVERY),
true);
switch (reason) {
case CNSS_REASON_LINK_DOWN:
if (!cnss_bus_check_link_status(plat_priv)) {
cnss_pr_dbg("Skip link down recovery as link is already up\n");
return 0;
}
if (test_bit(LINK_DOWN_SELF_RECOVERY,
&plat_priv->ctrl_params.quirks))
goto self_recovery;
if (!cnss_bus_recover_link_down(plat_priv)) {
/* clear recovery bit here to avoid skipping
* the recovery work for RDDM later
*/
clear_bit(CNSS_DRIVER_RECOVERY,
&plat_priv->driver_state);
return 0;
}
break;
case CNSS_REASON_RDDM:
cnss_bus_collect_dump_info(plat_priv, false);
break;
case CNSS_REASON_DEFAULT:
case CNSS_REASON_TIMEOUT:
break;
default:
cnss_pr_err("Unsupported recovery reason: %s(%d)\n",
cnss_recovery_reason_to_str(reason), reason);
break;
}
cnss_bus_device_crashed(plat_priv);
return 0;
self_recovery:
cnss_pr_dbg("Going for self recovery\n");
cnss_bus_dev_shutdown(plat_priv);
if (test_bit(LINK_DOWN_SELF_RECOVERY, &plat_priv->ctrl_params.quirks))
clear_bit(LINK_DOWN_SELF_RECOVERY,
&plat_priv->ctrl_params.quirks);
/* If link down self recovery is triggered before Host driver
* registration, avoid device power up because eventually device
* will be power up as part of driver registration.
*/
if (!test_bit(CNSS_DRIVER_REGISTER, &plat_priv->driver_state) ||
!test_bit(CNSS_DRIVER_REGISTERED, &plat_priv->driver_state)) {
cnss_pr_dbg("Host driver not registered yet, ignore Device Power Up, 0x%lx\n",
plat_priv->driver_state);
return 0;
}
ret = cnss_bus_dev_powerup(plat_priv);
if (ret)
clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
return 0;
}
static int cnss_driver_recovery_hdlr(struct cnss_plat_data *plat_priv,
void *data)
{
struct cnss_recovery_data *recovery_data = data;
int ret = 0;
cnss_pr_dbg("Driver recovery is triggered with reason: %s(%d)\n",
cnss_recovery_reason_to_str(recovery_data->reason),
recovery_data->reason);
if (!plat_priv->driver_state) {
cnss_pr_err("Improper driver state, ignore recovery\n");
ret = -EINVAL;
goto out;
}
if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) {
cnss_pr_err("Reboot is in progress, ignore recovery\n");
ret = -EINVAL;
goto out;
}
if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
cnss_pr_err("Recovery is already in progress\n");
CNSS_ASSERT(0);
ret = -EINVAL;
goto out;
}
if (test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state)) {
cnss_pr_err("Driver unload or idle shutdown is in progress, ignore recovery\n");
ret = -EINVAL;
goto out;
}
switch (plat_priv->device_id) {
case QCA6174_DEVICE_ID:
if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_IDLE_RESTART,
&plat_priv->driver_state)) {
cnss_pr_err("Driver load or idle restart is in progress, ignore recovery\n");
ret = -EINVAL;
goto out;
}
break;
default:
if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
set_bit(CNSS_FW_BOOT_RECOVERY,
&plat_priv->driver_state);
}
break;
}
set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
ret = cnss_do_recovery(plat_priv, recovery_data->reason);
out:
kfree(data);
return ret;
}
int cnss_self_recovery(struct device *dev,
enum cnss_recovery_reason reason)
{
cnss_schedule_recovery(dev, reason);
return 0;
}
EXPORT_SYMBOL(cnss_self_recovery);
void cnss_schedule_recovery(struct device *dev,
enum cnss_recovery_reason reason)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
struct cnss_recovery_data *data;
int gfp = GFP_KERNEL;
if (!test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state))
cnss_bus_update_status(plat_priv, CNSS_FW_DOWN);
if (test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state)) {
cnss_pr_dbg("Driver unload or idle shutdown is in progress, ignore schedule recovery\n");
return;
}
if (in_interrupt() || irqs_disabled())
gfp = GFP_ATOMIC;
data = kzalloc(sizeof(*data), gfp);
if (!data)
return;
data->reason = reason;
cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_RECOVERY,
0, data);
}
EXPORT_SYMBOL(cnss_schedule_recovery);
int cnss_force_fw_assert(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (plat_priv->device_id == QCA6174_DEVICE_ID) {
cnss_pr_info("Forced FW assert is not supported\n");
return -EOPNOTSUPP;
}
if (cnss_bus_is_device_down(plat_priv)) {
cnss_pr_info("Device is already in bad state, ignore force assert\n");
return 0;
}
if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
cnss_pr_info("Recovery is already in progress, ignore forced FW assert\n");
return 0;
}
if (in_interrupt() || irqs_disabled())
cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_FORCE_FW_ASSERT,
0, NULL);
else
cnss_bus_force_fw_assert_hdlr(plat_priv);
return 0;
}
EXPORT_SYMBOL(cnss_force_fw_assert);
int cnss_force_collect_rddm(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
unsigned int timeout;
int ret = 0;
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return -ENODEV;
}
if (plat_priv->device_id == QCA6174_DEVICE_ID) {
cnss_pr_info("Force collect rddm is not supported\n");
return -EOPNOTSUPP;
}
if (cnss_bus_is_device_down(plat_priv)) {
cnss_pr_info("Device is already in bad state, wait to collect rddm\n");
goto wait_rddm;
}
if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
cnss_pr_info("Recovery is already in progress, wait to collect rddm\n");
goto wait_rddm;
}
if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state)) {
cnss_pr_info("Loading/Unloading/idle restart/shutdown is in progress, ignore forced collect rddm\n");
return 0;
}
ret = cnss_bus_force_fw_assert_hdlr(plat_priv);
if (ret)
return ret;
wait_rddm:
reinit_completion(&plat_priv->rddm_complete);
timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_RDDM);
ret = wait_for_completion_timeout(&plat_priv->rddm_complete,
msecs_to_jiffies(timeout));
if (!ret) {
cnss_pr_err("Timeout (%ums) waiting for RDDM to complete\n",
timeout);
ret = -ETIMEDOUT;
} else if (ret > 0) {
ret = 0;
}
return ret;
}
EXPORT_SYMBOL(cnss_force_collect_rddm);
int cnss_qmi_send_get(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
return 0;
return cnss_bus_qmi_send_get(plat_priv);
}
EXPORT_SYMBOL(cnss_qmi_send_get);
int cnss_qmi_send_put(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
return 0;
return cnss_bus_qmi_send_put(plat_priv);
}
EXPORT_SYMBOL(cnss_qmi_send_put);
int cnss_qmi_send(struct device *dev, int type, void *cmd,
int cmd_len, void *cb_ctx,
int (*cb)(void *ctx, void *event, int event_len))
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
int ret;
if (!plat_priv)
return -ENODEV;
if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
return -EINVAL;
plat_priv->get_info_cb = cb;
plat_priv->get_info_cb_ctx = cb_ctx;
ret = cnss_wlfw_get_info_send_sync(plat_priv, type, cmd, cmd_len);
if (ret) {
plat_priv->get_info_cb = NULL;
plat_priv->get_info_cb_ctx = NULL;
}
return ret;
}
EXPORT_SYMBOL(cnss_qmi_send);
int cnss_register_driver_async_data_cb(struct device *dev, void *cb_ctx,
int (*cb)(void *ctx, uint16_t type,
void *event, int event_len))
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -ENODEV;
if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
return -EINVAL;
plat_priv->get_driver_async_data_cb = cb;
plat_priv->get_driver_async_data_ctx = cb_ctx;
return 0;
}
EXPORT_SYMBOL(cnss_register_driver_async_data_cb);
static int cnss_cold_boot_cal_start_hdlr(struct cnss_plat_data *plat_priv)
{
int ret = 0;
u32 retry = 0, timeout;
if (test_bit(CNSS_COLD_BOOT_CAL_DONE, &plat_priv->driver_state)) {
cnss_pr_dbg("Calibration complete. Ignore calibration req\n");
goto out;
} else if (test_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state)) {
cnss_pr_dbg("Calibration in progress. Ignore new calibration req\n");
goto out;
} else if (test_bit(CNSS_WLAN_HW_DISABLED, &plat_priv->driver_state)) {
cnss_pr_dbg("Calibration deferred as WLAN device disabled\n");
goto out;
}
if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) ||
test_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state) ||
test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
cnss_pr_err("WLAN in mission mode before cold boot calibration\n");
CNSS_ASSERT(0);
return -EINVAL;
}
while (retry++ < CNSS_CAL_START_PROBE_WAIT_RETRY_MAX) {
if (test_bit(CNSS_PCI_PROBE_DONE, &plat_priv->driver_state))
break;
msleep(CNSS_CAL_START_PROBE_WAIT_MS);
if (retry == CNSS_CAL_START_PROBE_WAIT_RETRY_MAX) {
cnss_pr_err("Calibration start failed as PCI probe not complete\n");
CNSS_ASSERT(0);
ret = -EINVAL;
goto mark_cal_fail;
}
}
switch (plat_priv->device_id) {
case QCA6290_DEVICE_ID:
case QCA6390_DEVICE_ID:
case QCA6490_DEVICE_ID:
case KIWI_DEVICE_ID:
case MANGO_DEVICE_ID:
case PEACH_DEVICE_ID:
break;
default:
cnss_pr_err("Not supported for device ID 0x%lx\n",
plat_priv->device_id);
ret = -EINVAL;
goto mark_cal_fail;
}
set_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state);
if (test_bit(CNSS_DRIVER_REGISTER, &plat_priv->driver_state)) {
timeout = cnss_get_timeout(plat_priv,
CNSS_TIMEOUT_CALIBRATION);
cnss_pr_dbg("Restarting calibration %ds timeout\n",
timeout / 1000);
if (cancel_delayed_work_sync(&plat_priv->wlan_reg_driver_work))
schedule_delayed_work(&plat_priv->wlan_reg_driver_work,
msecs_to_jiffies(timeout));
}
reinit_completion(&plat_priv->cal_complete);
ret = cnss_bus_dev_powerup(plat_priv);
mark_cal_fail:
if (ret) {
complete(&plat_priv->cal_complete);
clear_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state);
/* Set CBC done in driver state to mark attempt and note error
* since calibration cannot be retried at boot.
*/
plat_priv->cal_done = CNSS_CAL_FAILURE;
set_bit(CNSS_COLD_BOOT_CAL_DONE, &plat_priv->driver_state);
if (plat_priv->device_id == QCA6174_DEVICE_ID ||
plat_priv->device_id == QCN7605_DEVICE_ID) {
if (!test_bit(CNSS_DRIVER_REGISTER, &plat_priv->driver_state))
goto out;
cnss_pr_info("Schedule WLAN driver load\n");
if (cancel_delayed_work_sync(&plat_priv->wlan_reg_driver_work))
schedule_delayed_work(&plat_priv->wlan_reg_driver_work,
0);
}
}
out:
return ret;
}
static int cnss_cold_boot_cal_done_hdlr(struct cnss_plat_data *plat_priv,
void *data)
{
struct cnss_cal_info *cal_info = data;
if (!test_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state) ||
test_bit(CNSS_COLD_BOOT_CAL_DONE, &plat_priv->driver_state))
goto out;
switch (cal_info->cal_status) {
case CNSS_CAL_DONE:
cnss_pr_dbg("Calibration completed successfully\n");
plat_priv->cal_done = true;
break;
case CNSS_CAL_TIMEOUT:
case CNSS_CAL_FAILURE:
cnss_pr_dbg("Calibration failed. Status: %d, force shutdown\n",
cal_info->cal_status);
break;
default:
cnss_pr_err("Unknown calibration status: %u\n",
cal_info->cal_status);
break;
}
cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
cnss_bus_free_qdss_mem(plat_priv);
cnss_release_antenna_sharing(plat_priv);
if (plat_priv->device_id == QCN7605_DEVICE_ID)
goto skip_shutdown;
cnss_bus_dev_shutdown(plat_priv);
msleep(POWER_RESET_MIN_DELAY_MS);
skip_shutdown:
complete(&plat_priv->cal_complete);
clear_bit(CNSS_IN_COLD_BOOT_CAL, &plat_priv->driver_state);
set_bit(CNSS_COLD_BOOT_CAL_DONE, &plat_priv->driver_state);
if (cal_info->cal_status == CNSS_CAL_DONE) {
cnss_cal_mem_upload_to_file(plat_priv);
if (!test_bit(CNSS_DRIVER_REGISTER, &plat_priv->driver_state))
goto out;
cnss_pr_dbg("Schedule WLAN driver load\n");
if (cancel_delayed_work_sync(&plat_priv->wlan_reg_driver_work))
schedule_delayed_work(&plat_priv->wlan_reg_driver_work,
0);
}
out:
kfree(data);
return 0;
}
static int cnss_power_up_hdlr(struct cnss_plat_data *plat_priv)
{
int ret;
ret = cnss_bus_dev_powerup(plat_priv);
if (ret)
clear_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state);
return ret;
}
static int cnss_power_down_hdlr(struct cnss_plat_data *plat_priv)
{
cnss_bus_dev_shutdown(plat_priv);
return 0;
}
static int cnss_qdss_trace_req_mem_hdlr(struct cnss_plat_data *plat_priv)
{
int ret = 0;
ret = cnss_bus_alloc_qdss_mem(plat_priv);
if (ret < 0)
return ret;
return cnss_wlfw_qdss_trace_mem_info_send_sync(plat_priv);
}
static void *cnss_get_fw_mem_pa_to_va(struct cnss_fw_mem *fw_mem,
u32 mem_seg_len, u64 pa, u32 size)
{
int i = 0;
u64 offset = 0;
void *va = NULL;
u64 local_pa;
u32 local_size;
for (i = 0; i < mem_seg_len; i++) {
if (i == QMI_WLFW_MEM_LPASS_SHARED_V01)
continue;
local_pa = (u64)fw_mem[i].pa;
local_size = (u32)fw_mem[i].size;
if (pa == local_pa && size <= local_size) {
va = fw_mem[i].va;
break;
}
if (pa > local_pa &&
pa < local_pa + local_size &&
pa + size <= local_pa + local_size) {
offset = pa - local_pa;
va = fw_mem[i].va + offset;
break;
}
}
return va;
}
static int cnss_fw_mem_file_save_hdlr(struct cnss_plat_data *plat_priv,
void *data)
{
struct cnss_qmi_event_fw_mem_file_save_data *event_data = data;
struct cnss_fw_mem *fw_mem_seg;
int ret = 0L;
void *va = NULL;
u32 i, fw_mem_seg_len;
switch (event_data->mem_type) {
case QMI_WLFW_MEM_TYPE_DDR_V01:
if (!plat_priv->fw_mem_seg_len)
goto invalid_mem_save;
fw_mem_seg = plat_priv->fw_mem;
fw_mem_seg_len = plat_priv->fw_mem_seg_len;
break;
case QMI_WLFW_MEM_QDSS_V01:
if (!plat_priv->qdss_mem_seg_len)
goto invalid_mem_save;
fw_mem_seg = plat_priv->qdss_mem;
fw_mem_seg_len = plat_priv->qdss_mem_seg_len;
break;
default:
goto invalid_mem_save;
}
for (i = 0; i < event_data->mem_seg_len; i++) {
va = cnss_get_fw_mem_pa_to_va(fw_mem_seg, fw_mem_seg_len,
event_data->mem_seg[i].addr,
event_data->mem_seg[i].size);
if (!va) {
cnss_pr_err("Fail to find matching va of pa %pa for mem type: %d\n",
&event_data->mem_seg[i].addr,
event_data->mem_type);
ret = -EINVAL;
break;
}
ret = cnss_genl_send_msg(va, CNSS_GENL_MSG_TYPE_QDSS,
event_data->file_name,
event_data->mem_seg[i].size);
if (ret < 0) {
cnss_pr_err("Fail to save fw mem data: %d\n",
ret);
break;
}
}
kfree(data);
return ret;
invalid_mem_save:
cnss_pr_err("FW Mem type %d not allocated. Invalid save request\n",
event_data->mem_type);
kfree(data);
return -EINVAL;
}
static int cnss_qdss_trace_free_hdlr(struct cnss_plat_data *plat_priv)
{
cnss_bus_free_qdss_mem(plat_priv);
return 0;
}
static int cnss_qdss_trace_req_data_hdlr(struct cnss_plat_data *plat_priv,
void *data)
{
int ret = 0;
struct cnss_qmi_event_fw_mem_file_save_data *event_data = data;
if (!plat_priv)
return -ENODEV;
ret = cnss_wlfw_qdss_data_send_sync(plat_priv, event_data->file_name,
event_data->total_size);
kfree(data);
return ret;
}
static void cnss_driver_event_work(struct work_struct *work)
{
struct cnss_plat_data *plat_priv =
container_of(work, struct cnss_plat_data, event_work);
struct cnss_driver_event *event;
unsigned long flags;
int ret = 0;
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL!\n");
return;
}
cnss_pm_stay_awake(plat_priv);
spin_lock_irqsave(&plat_priv->event_lock, flags);
while (!list_empty(&plat_priv->event_list)) {
event = list_first_entry(&plat_priv->event_list,
struct cnss_driver_event, list);
list_del(&event->list);
spin_unlock_irqrestore(&plat_priv->event_lock, flags);
cnss_pr_dbg("Processing driver event: %s%s(%d), state: 0x%lx\n",
cnss_driver_event_to_str(event->type),
event->sync ? "-sync" : "", event->type,
plat_priv->driver_state);
switch (event->type) {
case CNSS_DRIVER_EVENT_SERVER_ARRIVE:
ret = cnss_wlfw_server_arrive(plat_priv, event->data);
break;
case CNSS_DRIVER_EVENT_SERVER_EXIT:
ret = cnss_wlfw_server_exit(plat_priv);
break;
case CNSS_DRIVER_EVENT_REQUEST_MEM:
ret = cnss_bus_alloc_fw_mem(plat_priv);
if (ret)
break;
ret = cnss_wlfw_respond_mem_send_sync(plat_priv);
break;
case CNSS_DRIVER_EVENT_FW_MEM_READY:
ret = cnss_fw_mem_ready_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_FW_READY:
ret = cnss_fw_ready_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START:
ret = cnss_cold_boot_cal_start_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE:
ret = cnss_cold_boot_cal_done_hdlr(plat_priv,
event->data);
break;
case CNSS_DRIVER_EVENT_REGISTER_DRIVER:
ret = cnss_bus_register_driver_hdlr(plat_priv,
event->data);
break;
case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER:
ret = cnss_bus_unregister_driver_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_RECOVERY:
ret = cnss_driver_recovery_hdlr(plat_priv,
event->data);
break;
case CNSS_DRIVER_EVENT_FORCE_FW_ASSERT:
ret = cnss_bus_force_fw_assert_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_IDLE_RESTART:
set_bit(CNSS_DRIVER_IDLE_RESTART,
&plat_priv->driver_state);
fallthrough;
case CNSS_DRIVER_EVENT_POWER_UP:
ret = cnss_power_up_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_IDLE_SHUTDOWN:
set_bit(CNSS_DRIVER_IDLE_SHUTDOWN,
&plat_priv->driver_state);
fallthrough;
case CNSS_DRIVER_EVENT_POWER_DOWN:
ret = cnss_power_down_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_IMS_WFC_CALL_IND:
ret = cnss_process_wfc_call_ind_event(plat_priv,
event->data);
break;
case CNSS_DRIVER_EVENT_WLFW_TWT_CFG_IND:
ret = cnss_process_twt_cfg_ind_event(plat_priv,
event->data);
break;
case CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM:
ret = cnss_qdss_trace_req_mem_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_FW_MEM_FILE_SAVE:
ret = cnss_fw_mem_file_save_hdlr(plat_priv,
event->data);
break;
case CNSS_DRIVER_EVENT_QDSS_TRACE_FREE:
ret = cnss_qdss_trace_free_hdlr(plat_priv);
break;
case CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA:
ret = cnss_qdss_trace_req_data_hdlr(plat_priv,
event->data);
break;
default:
cnss_pr_err("Invalid driver event type: %d",
event->type);
kfree(event);
spin_lock_irqsave(&plat_priv->event_lock, flags);
continue;
}
spin_lock_irqsave(&plat_priv->event_lock, flags);
if (event->sync) {
event->ret = ret;
complete(&event->complete);
continue;
}
spin_unlock_irqrestore(&plat_priv->event_lock, flags);
kfree(event);
spin_lock_irqsave(&plat_priv->event_lock, flags);
}
spin_unlock_irqrestore(&plat_priv->event_lock, flags);
cnss_pm_relax(plat_priv);
}
#if IS_ENABLED(CONFIG_MSM_SUBSYSTEM_RESTART)
int cnss_register_subsys(struct cnss_plat_data *plat_priv)
{
int ret = 0;
struct cnss_subsys_info *subsys_info;
subsys_info = &plat_priv->subsys_info;
subsys_info->subsys_desc.name = plat_priv->device_name;
subsys_info->subsys_desc.owner = THIS_MODULE;
subsys_info->subsys_desc.powerup = cnss_subsys_powerup;
subsys_info->subsys_desc.shutdown = cnss_subsys_shutdown;
subsys_info->subsys_desc.ramdump = cnss_subsys_ramdump;
subsys_info->subsys_desc.crash_shutdown = cnss_subsys_crash_shutdown;
subsys_info->subsys_desc.dev = &plat_priv->plat_dev->dev;
subsys_info->subsys_device = subsys_register(&subsys_info->subsys_desc);
if (IS_ERR(subsys_info->subsys_device)) {
ret = PTR_ERR(subsys_info->subsys_device);
cnss_pr_err("Failed to register subsys, err = %d\n", ret);
goto out;
}
subsys_info->subsys_handle =
subsystem_get(subsys_info->subsys_desc.name);
if (!subsys_info->subsys_handle) {
cnss_pr_err("Failed to get subsys_handle!\n");
ret = -EINVAL;
goto unregister_subsys;
} else if (IS_ERR(subsys_info->subsys_handle)) {
ret = PTR_ERR(subsys_info->subsys_handle);
cnss_pr_err("Failed to do subsystem_get, err = %d\n", ret);
goto unregister_subsys;
}
return 0;
unregister_subsys:
subsys_unregister(subsys_info->subsys_device);
out:
return ret;
}
void cnss_unregister_subsys(struct cnss_plat_data *plat_priv)
{
struct cnss_subsys_info *subsys_info;
subsys_info = &plat_priv->subsys_info;
subsystem_put(subsys_info->subsys_handle);
subsys_unregister(subsys_info->subsys_device);
}
static void *cnss_create_ramdump_device(struct cnss_plat_data *plat_priv)
{
struct cnss_subsys_info *subsys_info = &plat_priv->subsys_info;
return create_ramdump_device(subsys_info->subsys_desc.name,
subsys_info->subsys_desc.dev);
}
static void cnss_destroy_ramdump_device(struct cnss_plat_data *plat_priv,
void *ramdump_dev)
{
destroy_ramdump_device(ramdump_dev);
}
int cnss_do_ramdump(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info *ramdump_info = &plat_priv->ramdump_info;
struct ramdump_segment segment;
memset(&segment, 0, sizeof(segment));
segment.v_address = (void __iomem *)ramdump_info->ramdump_va;
segment.size = ramdump_info->ramdump_size;
return qcom_ramdump(ramdump_info->ramdump_dev, &segment, 1);
}
int cnss_do_elf_ramdump(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info_v2 *info_v2 = &plat_priv->ramdump_info_v2;
struct cnss_dump_data *dump_data = &info_v2->dump_data;
struct cnss_dump_seg *dump_seg = info_v2->dump_data_vaddr;
struct ramdump_segment *ramdump_segs, *s;
struct cnss_dump_meta_info meta_info = {0};
int i, ret = 0;
ramdump_segs = kcalloc(dump_data->nentries + 1,
sizeof(*ramdump_segs),
GFP_KERNEL);
if (!ramdump_segs)
return -ENOMEM;
s = ramdump_segs + 1;
for (i = 0; i < dump_data->nentries; i++) {
if (dump_seg->type >= CNSS_FW_DUMP_TYPE_MAX) {
cnss_pr_err("Unsupported dump type: %d",
dump_seg->type);
continue;
}
if (meta_info.entry[dump_seg->type].entry_start == 0) {
meta_info.entry[dump_seg->type].type = dump_seg->type;
meta_info.entry[dump_seg->type].entry_start = i + 1;
}
meta_info.entry[dump_seg->type].entry_num++;
s->address = dump_seg->address;
s->v_address = (void __iomem *)dump_seg->v_address;
s->size = dump_seg->size;
s++;
dump_seg++;
}
meta_info.magic = CNSS_RAMDUMP_MAGIC;
meta_info.version = CNSS_RAMDUMP_VERSION;
meta_info.chipset = plat_priv->device_id;
meta_info.total_entries = CNSS_FW_DUMP_TYPE_MAX;
ramdump_segs->v_address = (void __iomem *)(&meta_info);
ramdump_segs->size = sizeof(meta_info);
ret = qcom_elf_ramdump(info_v2->ramdump_dev, ramdump_segs,
dump_data->nentries + 1);
kfree(ramdump_segs);
return ret;
}
#else
static int cnss_panic_handler(struct notifier_block *nb, unsigned long action,
void *data)
{
struct cnss_plat_data *plat_priv =
container_of(nb, struct cnss_plat_data, panic_nb);
cnss_bus_dev_crash_shutdown(plat_priv);
return NOTIFY_DONE;
}
int cnss_register_subsys(struct cnss_plat_data *plat_priv)
{
int ret;
if (!plat_priv)
return -ENODEV;
plat_priv->panic_nb.notifier_call = cnss_panic_handler;
ret = atomic_notifier_chain_register(&panic_notifier_list,
&plat_priv->panic_nb);
if (ret) {
cnss_pr_err("Failed to register panic handler\n");
return -EINVAL;
}
return 0;
}
void cnss_unregister_subsys(struct cnss_plat_data *plat_priv)
{
int ret;
ret = atomic_notifier_chain_unregister(&panic_notifier_list,
&plat_priv->panic_nb);
if (ret)
cnss_pr_err("Failed to unregister panic handler\n");
}
#if IS_ENABLED(CONFIG_QCOM_MEMORY_DUMP_V2)
static void *cnss_create_ramdump_device(struct cnss_plat_data *plat_priv)
{
return &plat_priv->plat_dev->dev;
}
static void cnss_destroy_ramdump_device(struct cnss_plat_data *plat_priv,
void *ramdump_dev)
{
}
#endif
#if IS_ENABLED(CONFIG_QCOM_RAMDUMP)
int cnss_do_ramdump(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info *ramdump_info = &plat_priv->ramdump_info;
struct qcom_dump_segment segment;
struct list_head head;
if (!dump_enabled()) {
cnss_pr_info("Dump collection is not enabled\n");
return 0;
}
INIT_LIST_HEAD(&head);
memset(&segment, 0, sizeof(segment));
segment.va = ramdump_info->ramdump_va;
segment.size = ramdump_info->ramdump_size;
list_add(&segment.node, &head);
return qcom_dump(&head, ramdump_info->ramdump_dev);
}
#else
int cnss_do_ramdump(struct cnss_plat_data *plat_priv)
{
return 0;
}
/* Using completion event inside dynamically allocated ramdump_desc
* may result a race between freeing the event after setting it to
* complete inside dev coredump free callback and the thread that is
* waiting for completion.
*/
DECLARE_COMPLETION(dump_done);
#define TIMEOUT_SAVE_DUMP_MS 30000
#define SIZEOF_ELF_STRUCT(__xhdr) \
static inline size_t sizeof_elf_##__xhdr(unsigned char class) \
{ \
if (class == ELFCLASS32) \
return sizeof(struct elf32_##__xhdr); \
else \
return sizeof(struct elf64_##__xhdr); \
}
SIZEOF_ELF_STRUCT(phdr)
SIZEOF_ELF_STRUCT(hdr)
#define set_xhdr_property(__xhdr, arg, class, member, value) \
do { \
if (class == ELFCLASS32) \
((struct elf32_##__xhdr *)arg)->member = value; \
else \
((struct elf64_##__xhdr *)arg)->member = value; \
} while (0)
#define set_ehdr_property(arg, class, member, value) \
set_xhdr_property(hdr, arg, class, member, value)
#define set_phdr_property(arg, class, member, value) \
set_xhdr_property(phdr, arg, class, member, value)
/* These replace qcom_ramdump driver APIs called from common API
* cnss_do_elf_dump() by the ones defined here.
*/
#define qcom_dump_segment cnss_qcom_dump_segment
#define qcom_elf_dump cnss_qcom_elf_dump
#define dump_enabled cnss_dump_enabled
struct cnss_qcom_dump_segment {
struct list_head node;
dma_addr_t da;
void *va;
size_t size;
};
struct cnss_qcom_ramdump_desc {
void *data;
struct completion dump_done;
};
static ssize_t cnss_qcom_devcd_readv(char *buffer, loff_t offset, size_t count,
void *data, size_t datalen)
{
struct cnss_qcom_ramdump_desc *desc = data;
return memory_read_from_buffer(buffer, count, &offset, desc->data,
datalen);
}
static void cnss_qcom_devcd_freev(void *data)
{
struct cnss_qcom_ramdump_desc *desc = data;
cnss_pr_dbg("Free dump data for dev coredump\n");
complete(&dump_done);
vfree(desc->data);
kfree(desc);
}
static int cnss_qcom_devcd_dump(struct device *dev, void *data, size_t datalen,
gfp_t gfp)
{
struct cnss_qcom_ramdump_desc *desc;
unsigned int timeout = TIMEOUT_SAVE_DUMP_MS;
int ret;
desc = kmalloc(sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
desc->data = data;
reinit_completion(&dump_done);
dev_coredumpm(dev, NULL, desc, datalen, gfp,
cnss_qcom_devcd_readv, cnss_qcom_devcd_freev);
ret = wait_for_completion_timeout(&dump_done,
msecs_to_jiffies(timeout));
if (!ret)
cnss_pr_err("Timeout waiting (%dms) for saving dump to file system\n",
timeout);
return ret ? 0 : -ETIMEDOUT;
}
/* Since the elf32 and elf64 identification is identical apart from
* the class, use elf32 by default.
*/
static void init_elf_identification(struct elf32_hdr *ehdr, unsigned char class)
{
memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
ehdr->e_ident[EI_CLASS] = class;
ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
ehdr->e_ident[EI_VERSION] = EV_CURRENT;
ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
}
int cnss_qcom_elf_dump(struct list_head *segs, struct device *dev,
unsigned char class)
{
struct cnss_qcom_dump_segment *segment;
void *phdr, *ehdr;
size_t data_size, offset;
int phnum = 0;
void *data;
void __iomem *ptr;
if (!segs || list_empty(segs))
return -EINVAL;
data_size = sizeof_elf_hdr(class);
list_for_each_entry(segment, segs, node) {
data_size += sizeof_elf_phdr(class) + segment->size;
phnum++;
}
data = vmalloc(data_size);
if (!data)
return -ENOMEM;
cnss_pr_dbg("Creating ELF file with size %d\n", data_size);
ehdr = data;
memset(ehdr, 0, sizeof_elf_hdr(class));
init_elf_identification(ehdr, class);
set_ehdr_property(ehdr, class, e_type, ET_CORE);
set_ehdr_property(ehdr, class, e_machine, EM_NONE);
set_ehdr_property(ehdr, class, e_version, EV_CURRENT);
set_ehdr_property(ehdr, class, e_phoff, sizeof_elf_hdr(class));
set_ehdr_property(ehdr, class, e_ehsize, sizeof_elf_hdr(class));
set_ehdr_property(ehdr, class, e_phentsize, sizeof_elf_phdr(class));
set_ehdr_property(ehdr, class, e_phnum, phnum);
phdr = data + sizeof_elf_hdr(class);
offset = sizeof_elf_hdr(class) + sizeof_elf_phdr(class) * phnum;
list_for_each_entry(segment, segs, node) {
memset(phdr, 0, sizeof_elf_phdr(class));
set_phdr_property(phdr, class, p_type, PT_LOAD);
set_phdr_property(phdr, class, p_offset, offset);
set_phdr_property(phdr, class, p_vaddr, segment->da);
set_phdr_property(phdr, class, p_paddr, segment->da);
set_phdr_property(phdr, class, p_filesz, segment->size);
set_phdr_property(phdr, class, p_memsz, segment->size);
set_phdr_property(phdr, class, p_flags, PF_R | PF_W | PF_X);
set_phdr_property(phdr, class, p_align, 0);
if (segment->va) {
memcpy(data + offset, segment->va, segment->size);
} else {
ptr = devm_ioremap(dev, segment->da, segment->size);
if (!ptr) {
cnss_pr_err("Invalid coredump segment (%pad, %zu)\n",
&segment->da, segment->size);
memset(data + offset, 0xff, segment->size);
} else {
memcpy_fromio(data + offset, ptr,
segment->size);
}
}
offset += segment->size;
phdr += sizeof_elf_phdr(class);
}
return cnss_qcom_devcd_dump(dev, data, data_size, GFP_KERNEL);
}
/* Saving dump to file system is always needed in this case. */
static bool cnss_dump_enabled(void)
{
return true;
}
#endif /* CONFIG_QCOM_RAMDUMP */
int cnss_do_elf_ramdump(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info_v2 *info_v2 = &plat_priv->ramdump_info_v2;
struct cnss_dump_data *dump_data = &info_v2->dump_data;
struct cnss_dump_seg *dump_seg = info_v2->dump_data_vaddr;
struct qcom_dump_segment *seg;
struct cnss_dump_meta_info meta_info = {0};
struct list_head head;
int i, ret = 0;
if (!dump_enabled()) {
cnss_pr_info("Dump collection is not enabled\n");
return ret;
}
INIT_LIST_HEAD(&head);
for (i = 0; i < dump_data->nentries; i++) {
if (dump_seg->type >= CNSS_FW_DUMP_TYPE_MAX) {
cnss_pr_err("Unsupported dump type: %d",
dump_seg->type);
continue;
}
seg = kcalloc(1, sizeof(*seg), GFP_KERNEL);
if (!seg) {
cnss_pr_err("%s: Failed to allocate mem for seg %d\n",
__func__, i);
continue;
}
if (meta_info.entry[dump_seg->type].entry_start == 0) {
meta_info.entry[dump_seg->type].type = dump_seg->type;
meta_info.entry[dump_seg->type].entry_start = i + 1;
}
meta_info.entry[dump_seg->type].entry_num++;
seg->da = dump_seg->address;
seg->va = dump_seg->v_address;
seg->size = dump_seg->size;
list_add_tail(&seg->node, &head);
dump_seg++;
}
seg = kcalloc(1, sizeof(*seg), GFP_KERNEL);
if (!seg) {
cnss_pr_err("%s: Failed to allocate mem for elf ramdump seg\n",
__func__);
goto skip_elf_dump;
}
meta_info.magic = CNSS_RAMDUMP_MAGIC;
meta_info.version = CNSS_RAMDUMP_VERSION;
meta_info.chipset = plat_priv->device_id;
meta_info.total_entries = CNSS_FW_DUMP_TYPE_MAX;
seg->va = &meta_info;
seg->size = sizeof(meta_info);
list_add(&seg->node, &head);
ret = qcom_elf_dump(&head, info_v2->ramdump_dev, ELF_CLASS);
skip_elf_dump:
while (!list_empty(&head)) {
seg = list_first_entry(&head, struct qcom_dump_segment, node);
list_del(&seg->node);
kfree(seg);
}
return ret;
}
#ifdef CONFIG_CNSS2_SSR_DRIVER_DUMP
/**
* cnss_host_ramdump_dev_release() - callback function for device release
* @dev: device to be released
*
* Return: None
*/
static void cnss_host_ramdump_dev_release(struct device *dev)
{
cnss_pr_dbg("free host ramdump device\n");
kfree(dev);
}
int cnss_do_host_ramdump(struct cnss_plat_data *plat_priv,
struct cnss_ssr_driver_dump_entry *ssr_entry,
size_t num_entries_loaded)
{
struct qcom_dump_segment *seg;
struct cnss_host_dump_meta_info meta_info = {0};
struct list_head head;
int dev_ret = 0;
struct device *new_device;
static const char * const wlan_str[] = {
[CNSS_HOST_WLAN_LOGS] = "wlan_logs",
[CNSS_HOST_HTC_CREDIT] = "htc_credit",
[CNSS_HOST_WMI_TX_CMP] = "wmi_tx_cmp",
[CNSS_HOST_WMI_COMMAND_LOG] = "wmi_command_log",
[CNSS_HOST_WMI_EVENT_LOG] = "wmi_event_log",
[CNSS_HOST_WMI_RX_EVENT] = "wmi_rx_event",
[CNSS_HOST_HAL_SOC] = "hal_soc",
[CNSS_HOST_GWLAN_LOGGING] = "gwlan_logging",
[CNSS_HOST_WMI_DEBUG_LOG_INFO] = "wmi_debug_log_info",
[CNSS_HOST_HTC_CREDIT_IDX] = "htc_credit_history_idx",
[CNSS_HOST_HTC_CREDIT_LEN] = "htc_credit_history_length",
[CNSS_HOST_WMI_TX_CMP_IDX] = "wmi_tx_cmp_idx",
[CNSS_HOST_WMI_COMMAND_LOG_IDX] = "wmi_command_log_idx",
[CNSS_HOST_WMI_EVENT_LOG_IDX] = "wmi_event_log_idx",
[CNSS_HOST_WMI_RX_EVENT_IDX] = "wmi_rx_event_idx",
[CNSS_HOST_HIF_CE_DESC_HISTORY_BUFF] = "hif_ce_desc_history_buff",
[CNSS_HOST_HANG_EVENT_DATA] = "hang_event_data",
[CNSS_HOST_CE_DESC_HIST] = "hif_ce_desc_hist",
[CNSS_HOST_CE_COUNT_MAX] = "hif_ce_count_max",
[CNSS_HOST_CE_HISTORY_MAX] = "hif_ce_history_max",
[CNSS_HOST_ONLY_FOR_CRIT_CE] = "hif_ce_only_for_crit",
[CNSS_HOST_HIF_EVENT_HISTORY] = "hif_event_history",
[CNSS_HOST_HIF_EVENT_HIST_MAX] = "hif_event_hist_max",
[CNSS_HOST_DP_WBM_DESC_REL] = "wbm_desc_rel_ring",
[CNSS_HOST_DP_WBM_DESC_REL_HANDLE] = "wbm_desc_rel_ring_handle",
[CNSS_HOST_DP_TCL_CMD] = "tcl_cmd_ring",
[CNSS_HOST_DP_TCL_CMD_HANDLE] = "tcl_cmd_ring_handle",
[CNSS_HOST_DP_TCL_STATUS] = "tcl_status_ring",
[CNSS_HOST_DP_TCL_STATUS_HANDLE] = "tcl_status_ring_handle",
[CNSS_HOST_DP_REO_REINJ] = "reo_reinject_ring",
[CNSS_HOST_DP_REO_REINJ_HANDLE] = "reo_reinject_ring_handle",
[CNSS_HOST_DP_RX_REL] = "rx_rel_ring",
[CNSS_HOST_DP_RX_REL_HANDLE] = "rx_rel_ring_handle",
[CNSS_HOST_DP_REO_EXP] = "reo_exception_ring",
[CNSS_HOST_DP_REO_EXP_HANDLE] = "reo_exception_ring_handle",
[CNSS_HOST_DP_REO_CMD] = "reo_cmd_ring",
[CNSS_HOST_DP_REO_CMD_HANDLE] = "reo_cmd_ring_handle",
[CNSS_HOST_DP_REO_STATUS] = "reo_status_ring",
[CNSS_HOST_DP_REO_STATUS_HANDLE] = "reo_status_ring_handle",
[CNSS_HOST_DP_TCL_DATA_0] = "tcl_data_ring_0",
[CNSS_HOST_DP_TCL_DATA_0_HANDLE] = "tcl_data_ring_0_handle",
[CNSS_HOST_DP_TX_COMP_0] = "tx_comp_ring_0",
[CNSS_HOST_DP_TX_COMP_0_HANDLE] = "tx_comp_ring_0_handle",
[CNSS_HOST_DP_TCL_DATA_1] = "tcl_data_ring_1",
[CNSS_HOST_DP_TCL_DATA_1_HANDLE] = "tcl_data_ring_1_handle",
[CNSS_HOST_DP_TX_COMP_1] = "tx_comp_ring_1",
[CNSS_HOST_DP_TX_COMP_1_HANDLE] = "tx_comp_ring_1_handle",
[CNSS_HOST_DP_TCL_DATA_2] = "tcl_data_ring_2",
[CNSS_HOST_DP_TCL_DATA_2_HANDLE] = "tcl_data_ring_2_handle",
[CNSS_HOST_DP_TX_COMP_2] = "tx_comp_ring_2",
[CNSS_HOST_DP_TX_COMP_2_HANDLE] = "tx_comp_ring_2_handle",
[CNSS_HOST_DP_REO_DST_0] = "reo_dest_ring_0",
[CNSS_HOST_DP_REO_DST_0_HANDLE] = "reo_dest_ring_0_handle",
[CNSS_HOST_DP_REO_DST_1] = "reo_dest_ring_1",
[CNSS_HOST_DP_REO_DST_1_HANDLE] = "reo_dest_ring_1_handle",
[CNSS_HOST_DP_REO_DST_2] = "reo_dest_ring_2",
[CNSS_HOST_DP_REO_DST_2_HANDLE] = "reo_dest_ring_2_handle",
[CNSS_HOST_DP_REO_DST_3] = "reo_dest_ring_3",
[CNSS_HOST_DP_REO_DST_3_HANDLE] = "reo_dest_ring_3_handle",
[CNSS_HOST_DP_REO_DST_4] = "reo_dest_ring_4",
[CNSS_HOST_DP_REO_DST_4_HANDLE] = "reo_dest_ring_4_handle",
[CNSS_HOST_DP_REO_DST_5] = "reo_dest_ring_5",
[CNSS_HOST_DP_REO_DST_5_HANDLE] = "reo_dest_ring_5_handle",
[CNSS_HOST_DP_REO_DST_6] = "reo_dest_ring_6",
[CNSS_HOST_DP_REO_DST_6_HANDLE] = "reo_dest_ring_6_handle",
[CNSS_HOST_DP_REO_DST_7] = "reo_dest_ring_7",
[CNSS_HOST_DP_REO_DST_7_HANDLE] = "reo_dest_ring_7_handle",
[CNSS_HOST_DP_PDEV_0] = "dp_pdev_0",
[CNSS_HOST_DP_WLAN_CFG_CTX] = "wlan_cfg_ctx",
[CNSS_HOST_DP_SOC] = "dp_soc",
[CNSS_HOST_HAL_RX_FST] = "hal_rx_fst",
[CNSS_HOST_DP_FISA] = "dp_fisa",
[CNSS_HOST_DP_FISA_HW_FSE_TABLE] = "dp_fisa_hw_fse_table",
[CNSS_HOST_DP_FISA_SW_FSE_TABLE] = "dp_fisa_sw_fse_table",
[CNSS_HOST_HIF] = "hif",
[CNSS_HOST_QDF_NBUF_HIST] = "qdf_nbuf_history",
[CNSS_HOST_TCL_WBM_MAP] = "tcl_wbm_map_array",
[CNSS_HOST_RX_MAC_BUF_RING_0] = "rx_mac_buf_ring_0",
[CNSS_HOST_RX_MAC_BUF_RING_0_HANDLE] = "rx_mac_buf_ring_0_handle",
[CNSS_HOST_RX_MAC_BUF_RING_1] = "rx_mac_buf_ring_1",
[CNSS_HOST_RX_MAC_BUF_RING_1_HANDLE] = "rx_mac_buf_ring_1_handle",
[CNSS_HOST_RX_REFILL_0] = "rx_refill_buf_ring_0",
[CNSS_HOST_RX_REFILL_0_HANDLE] = "rx_refill_buf_ring_0_handle",
[CNSS_HOST_CE_0] = "ce_0",
[CNSS_HOST_CE_0_SRC_RING] = "ce_0_src_ring",
[CNSS_HOST_CE_0_SRC_RING_CTX] = "ce_0_src_ring_ctx",
[CNSS_HOST_CE_1] = "ce_1",
[CNSS_HOST_CE_1_STATUS_RING] = "ce_1_status_ring",
[CNSS_HOST_CE_1_STATUS_RING_CTX] = "ce_1_status_ring_ctx",
[CNSS_HOST_CE_1_DEST_RING] = "ce_1_dest_ring",
[CNSS_HOST_CE_1_DEST_RING_CTX] = "ce_1_dest_ring_ctx",
[CNSS_HOST_CE_2] = "ce_2",
[CNSS_HOST_CE_2_STATUS_RING] = "ce_2_status_ring",
[CNSS_HOST_CE_2_STATUS_RING_CTX] = "ce_2_status_ring_ctx",
[CNSS_HOST_CE_2_DEST_RING] = "ce_2_dest_ring",
[CNSS_HOST_CE_2_DEST_RING_CTX] = "ce_2_dest_ring_ctx",
[CNSS_HOST_CE_3] = "ce_3",
[CNSS_HOST_CE_3_SRC_RING] = "ce_3_src_ring",
[CNSS_HOST_CE_3_SRC_RING_CTX] = "ce_3_src_ring_ctx",
[CNSS_HOST_CE_4] = "ce_4",
[CNSS_HOST_CE_4_SRC_RING] = "ce_4_src_ring",
[CNSS_HOST_CE_4_SRC_RING_CTX] = "ce_4_src_ring_ctx",
[CNSS_HOST_CE_5] = "ce_5",
[CNSS_HOST_CE_6] = "ce_6",
[CNSS_HOST_CE_7] = "ce_7",
[CNSS_HOST_CE_7_STATUS_RING] = "ce_7_status_ring",
[CNSS_HOST_CE_7_STATUS_RING_CTX] = "ce_7_status_ring_ctx",
[CNSS_HOST_CE_7_DEST_RING] = "ce_7_dest_ring",
[CNSS_HOST_CE_7_DEST_RING_CTX] = "ce_7_dest_ring_ctx",
[CNSS_HOST_CE_8] = "ce_8",
[CNSS_HOST_DP_TCL_DATA_3] = "tcl_data_ring_3",
[CNSS_HOST_DP_TCL_DATA_3_HANDLE] = "tcl_data_ring_3_handle",
[CNSS_HOST_DP_TX_COMP_3] = "tx_comp_ring_3",
[CNSS_HOST_DP_TX_COMP_3_HANDLE] = "tx_comp_ring_3_handle"
};
int i;
int ret = 0;
enum cnss_host_dump_type j;
if (!dump_enabled()) {
cnss_pr_info("Dump collection is not enabled\n");
return ret;
}
new_device = kcalloc(1, sizeof(*new_device), GFP_KERNEL);
if (!new_device) {
cnss_pr_err("Failed to alloc device mem\n");
return -ENOMEM;
}
new_device->release = cnss_host_ramdump_dev_release;
device_initialize(new_device);
dev_set_name(new_device, "wlan_driver");
dev_ret = device_add(new_device);
if (dev_ret) {
cnss_pr_err("Failed to add new device\n");
goto put_device;
}
INIT_LIST_HEAD(&head);
for (i = 0; i < num_entries_loaded; i++) {
/* If region name registered by driver is not present in
* wlan_str. type for that entry will not be set, but entry will
* be added. Which will result in entry type being 0. Currently
* entry type 0 is for wlan_logs, which will result in parsing
* issue for wlan_logs as parsing is done based upon type field.
* So initialize type with -1(Invalid) to avoid such issues.
*/
meta_info.entry[i].type = -1;
seg = kcalloc(1, sizeof(*seg), GFP_KERNEL);
if (!seg) {
cnss_pr_err("Failed to alloc seg entry %d\n", i);
continue;
}
seg->va = ssr_entry[i].buffer_pointer;
seg->da = (dma_addr_t)ssr_entry[i].buffer_pointer;
seg->size = ssr_entry[i].buffer_size;
for (j = 0; j < CNSS_HOST_DUMP_TYPE_MAX; j++) {
if (strcmp(ssr_entry[i].region_name, wlan_str[j]) == 0) {
meta_info.entry[i].type = j;
}
}
meta_info.entry[i].entry_start = i + 1;
meta_info.entry[i].entry_num++;
list_add_tail(&seg->node, &head);
}
seg = kcalloc(1, sizeof(*seg), GFP_KERNEL);
if (!seg) {
cnss_pr_err("%s: Failed to allocate mem for host dump seg\n",
__func__);
goto skip_host_dump;
}
meta_info.magic = CNSS_RAMDUMP_MAGIC;
meta_info.version = CNSS_RAMDUMP_VERSION;
meta_info.chipset = plat_priv->device_id;
meta_info.total_entries = num_entries_loaded;
seg->va = &meta_info;
seg->da = (dma_addr_t)&meta_info;
seg->size = sizeof(meta_info);
list_add(&seg->node, &head);
ret = qcom_elf_dump(&head, new_device, ELF_CLASS);
skip_host_dump:
while (!list_empty(&head)) {
seg = list_first_entry(&head, struct qcom_dump_segment, node);
list_del(&seg->node);
kfree(seg);
}
device_del(new_device);
put_device:
put_device(new_device);
cnss_pr_dbg("host ramdump result %d\n", ret);
return ret;
}
#endif
#endif /* CONFIG_MSM_SUBSYSTEM_RESTART */
#if IS_ENABLED(CONFIG_QCOM_MEMORY_DUMP_V2)
static int cnss_init_dump_entry(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info *ramdump_info;
struct msm_dump_entry dump_entry;
ramdump_info = &plat_priv->ramdump_info;
ramdump_info->dump_data.addr = ramdump_info->ramdump_pa;
ramdump_info->dump_data.len = ramdump_info->ramdump_size;
ramdump_info->dump_data.version = CNSS_DUMP_FORMAT_VER;
ramdump_info->dump_data.magic = CNSS_DUMP_MAGIC_VER_V2;
strlcpy(ramdump_info->dump_data.name, CNSS_DUMP_NAME,
sizeof(ramdump_info->dump_data.name));
dump_entry.id = MSM_DUMP_DATA_CNSS_WLAN;
dump_entry.addr = virt_to_phys(&ramdump_info->dump_data);
return msm_dump_data_register_nominidump(MSM_DUMP_TABLE_APPS,
&dump_entry);
}
static int cnss_register_ramdump_v1(struct cnss_plat_data *plat_priv)
{
int ret = 0;
struct device *dev;
struct cnss_ramdump_info *ramdump_info;
u32 ramdump_size = 0;
dev = &plat_priv->plat_dev->dev;
ramdump_info = &plat_priv->ramdump_info;
if (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG) {
/* dt type: legacy or converged */
ret = of_property_read_u32(dev->of_node,
"qcom,wlan-ramdump-dynamic",
&ramdump_size);
} else {
ret = of_property_read_u32(plat_priv->dev_node,
"qcom,wlan-ramdump-dynamic",
&ramdump_size);
}
if (ret == 0) {
ramdump_info->ramdump_va =
dma_alloc_coherent(dev, ramdump_size,
&ramdump_info->ramdump_pa,
GFP_KERNEL);
if (ramdump_info->ramdump_va)
ramdump_info->ramdump_size = ramdump_size;
}
cnss_pr_dbg("ramdump va: %pK, pa: %pa\n",
ramdump_info->ramdump_va, &ramdump_info->ramdump_pa);
if (ramdump_info->ramdump_size == 0) {
cnss_pr_info("Ramdump will not be collected");
goto out;
}
ret = cnss_init_dump_entry(plat_priv);
if (ret) {
cnss_pr_err("Failed to setup dump table, err = %d\n", ret);
goto free_ramdump;
}
ramdump_info->ramdump_dev = cnss_create_ramdump_device(plat_priv);
if (!ramdump_info->ramdump_dev) {
cnss_pr_err("Failed to create ramdump device!");
ret = -ENOMEM;
goto free_ramdump;
}
return 0;
free_ramdump:
dma_free_coherent(dev, ramdump_info->ramdump_size,
ramdump_info->ramdump_va, ramdump_info->ramdump_pa);
out:
return ret;
}
static void cnss_unregister_ramdump_v1(struct cnss_plat_data *plat_priv)
{
struct device *dev;
struct cnss_ramdump_info *ramdump_info;
dev = &plat_priv->plat_dev->dev;
ramdump_info = &plat_priv->ramdump_info;
if (ramdump_info->ramdump_dev)
cnss_destroy_ramdump_device(plat_priv,
ramdump_info->ramdump_dev);
if (ramdump_info->ramdump_va)
dma_free_coherent(dev, ramdump_info->ramdump_size,
ramdump_info->ramdump_va,
ramdump_info->ramdump_pa);
}
/**
* cnss_ignore_dump_data_reg_fail - Ignore Ramdump table register failure
* @ret: Error returned by msm_dump_data_register_nominidump
*
* For Lahaina GKI boot, we dont have support for mem dump feature. So
* ignore failure.
*
* Return: Same given error code if mem dump feature enabled, 0 otherwise
*/
static int cnss_ignore_dump_data_reg_fail(int ret)
{
return ret;
}
static int cnss_register_ramdump_v2(struct cnss_plat_data *plat_priv)
{
int ret = 0;
struct cnss_ramdump_info_v2 *info_v2;
struct cnss_dump_data *dump_data;
struct msm_dump_entry dump_entry;
struct device *dev = &plat_priv->plat_dev->dev;
u32 ramdump_size = 0;
info_v2 = &plat_priv->ramdump_info_v2;
dump_data = &info_v2->dump_data;
if (plat_priv->dt_type != CNSS_DTT_MULTIEXCHG) {
/* dt type: legacy or converged */
ret = of_property_read_u32(dev->of_node,
"qcom,wlan-ramdump-dynamic",
&ramdump_size);
} else {
ret = of_property_read_u32(plat_priv->dev_node,
"qcom,wlan-ramdump-dynamic",
&ramdump_size);
}
if (ret == 0)
info_v2->ramdump_size = ramdump_size;
cnss_pr_dbg("Ramdump size 0x%lx\n", info_v2->ramdump_size);
info_v2->dump_data_vaddr = kzalloc(CNSS_DUMP_DESC_SIZE, GFP_KERNEL);
if (!info_v2->dump_data_vaddr)
return -ENOMEM;
dump_data->paddr = virt_to_phys(info_v2->dump_data_vaddr);
dump_data->version = CNSS_DUMP_FORMAT_VER_V2;
dump_data->magic = CNSS_DUMP_MAGIC_VER_V2;
dump_data->seg_version = CNSS_DUMP_SEG_VER;
strlcpy(dump_data->name, CNSS_DUMP_NAME,
sizeof(dump_data->name));
dump_entry.id = MSM_DUMP_DATA_CNSS_WLAN;
dump_entry.addr = virt_to_phys(dump_data);
ret = msm_dump_data_register_nominidump(MSM_DUMP_TABLE_APPS,
&dump_entry);
if (ret) {
ret = cnss_ignore_dump_data_reg_fail(ret);
cnss_pr_err("Failed to setup dump table, %s (%d)\n",
ret ? "Error" : "Ignoring", ret);
goto free_ramdump;
}
info_v2->ramdump_dev = cnss_create_ramdump_device(plat_priv);
if (!info_v2->ramdump_dev) {
cnss_pr_err("Failed to create ramdump device!\n");
ret = -ENOMEM;
goto free_ramdump;
}
return 0;
free_ramdump:
kfree(info_v2->dump_data_vaddr);
info_v2->dump_data_vaddr = NULL;
return ret;
}
static void cnss_unregister_ramdump_v2(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info_v2 *info_v2;
info_v2 = &plat_priv->ramdump_info_v2;
if (info_v2->ramdump_dev)
cnss_destroy_ramdump_device(plat_priv, info_v2->ramdump_dev);
kfree(info_v2->dump_data_vaddr);
info_v2->dump_data_vaddr = NULL;
info_v2->dump_data_valid = false;
}
int cnss_register_ramdump(struct cnss_plat_data *plat_priv)
{
int ret = 0;
switch (plat_priv->device_id) {
case QCA6174_DEVICE_ID:
ret = cnss_register_ramdump_v1(plat_priv);
break;
case QCA6290_DEVICE_ID:
case QCA6390_DEVICE_ID:
case QCN7605_DEVICE_ID:
case QCA6490_DEVICE_ID:
case KIWI_DEVICE_ID:
case MANGO_DEVICE_ID:
case PEACH_DEVICE_ID:
ret = cnss_register_ramdump_v2(plat_priv);
break;
default:
cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id);
ret = -ENODEV;
break;
}
return ret;
}
void cnss_unregister_ramdump(struct cnss_plat_data *plat_priv)
{
switch (plat_priv->device_id) {
case QCA6174_DEVICE_ID:
cnss_unregister_ramdump_v1(plat_priv);
break;
case QCA6290_DEVICE_ID:
case QCA6390_DEVICE_ID:
case QCN7605_DEVICE_ID:
case QCA6490_DEVICE_ID:
case KIWI_DEVICE_ID:
case MANGO_DEVICE_ID:
case PEACH_DEVICE_ID:
cnss_unregister_ramdump_v2(plat_priv);
break;
default:
cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id);
break;
}
}
#else
int cnss_register_ramdump(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info_v2 *info_v2 = &plat_priv->ramdump_info_v2;
struct cnss_dump_data *dump_data = dump_data = &info_v2->dump_data;
struct device *dev = &plat_priv->plat_dev->dev;
u32 ramdump_size = 0;
if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
&ramdump_size) == 0)
info_v2->ramdump_size = ramdump_size;
cnss_pr_dbg("Ramdump size 0x%lx\n", info_v2->ramdump_size);
info_v2->dump_data_vaddr = kzalloc(CNSS_DUMP_DESC_SIZE, GFP_KERNEL);
if (!info_v2->dump_data_vaddr)
return -ENOMEM;
dump_data->paddr = virt_to_phys(info_v2->dump_data_vaddr);
dump_data->version = CNSS_DUMP_FORMAT_VER_V2;
dump_data->magic = CNSS_DUMP_MAGIC_VER_V2;
dump_data->seg_version = CNSS_DUMP_SEG_VER;
strlcpy(dump_data->name, CNSS_DUMP_NAME,
sizeof(dump_data->name));
info_v2->ramdump_dev = dev;
return 0;
}
void cnss_unregister_ramdump(struct cnss_plat_data *plat_priv)
{
struct cnss_ramdump_info_v2 *info_v2 = &plat_priv->ramdump_info_v2;
info_v2->ramdump_dev = NULL;
kfree(info_v2->dump_data_vaddr);
info_v2->dump_data_vaddr = NULL;
info_v2->dump_data_valid = false;
}
#endif /* CONFIG_QCOM_MEMORY_DUMP_V2 */
int cnss_va_to_pa(struct device *dev, size_t size, void *va, dma_addr_t dma,
phys_addr_t *pa, unsigned long attrs)
{
struct sg_table sgt;
int ret;
ret = dma_get_sgtable_attrs(dev, &sgt, va, dma, size, attrs);
if (ret) {
cnss_pr_err("Failed to get sgtable for va: 0x%pK, dma: %pa, size: 0x%zx, attrs: 0x%x\n",
va, &dma, size, attrs);
return -EINVAL;
}
*pa = page_to_phys(sg_page(sgt.sgl));
sg_free_table(&sgt);
return 0;
}
#if IS_ENABLED(CONFIG_QCOM_MINIDUMP)
int cnss_minidump_add_region(struct cnss_plat_data *plat_priv,
enum cnss_fw_dump_type type, int seg_no,
void *va, phys_addr_t pa, size_t size)
{
struct md_region md_entry;
int ret;
switch (type) {
case CNSS_FW_IMAGE:
snprintf(md_entry.name, sizeof(md_entry.name), "FBC_%X",
seg_no);
break;
case CNSS_FW_RDDM:
snprintf(md_entry.name, sizeof(md_entry.name), "RDDM_%X",
seg_no);
break;
case CNSS_FW_REMOTE_HEAP:
snprintf(md_entry.name, sizeof(md_entry.name), "RHEAP_%X",
seg_no);
break;
default:
cnss_pr_err("Unknown dump type ID: %d\n", type);
return -EINVAL;
}
md_entry.phys_addr = pa;
md_entry.virt_addr = (uintptr_t)va;
md_entry.size = size;
md_entry.id = MSM_DUMP_DATA_CNSS_WLAN;
cnss_pr_dbg("Mini dump region: %s, va: %pK, pa: %pa, size: 0x%zx\n",
md_entry.name, va, &pa, size);
ret = msm_minidump_add_region(&md_entry);
if (ret < 0)
cnss_pr_err("Failed to add mini dump region, err = %d\n", ret);
return ret;
}
int cnss_minidump_remove_region(struct cnss_plat_data *plat_priv,
enum cnss_fw_dump_type type, int seg_no,
void *va, phys_addr_t pa, size_t size)
{
struct md_region md_entry;
int ret;
switch (type) {
case CNSS_FW_IMAGE:
snprintf(md_entry.name, sizeof(md_entry.name), "FBC_%X",
seg_no);
break;
case CNSS_FW_RDDM:
snprintf(md_entry.name, sizeof(md_entry.name), "RDDM_%X",
seg_no);
break;
case CNSS_FW_REMOTE_HEAP:
snprintf(md_entry.name, sizeof(md_entry.name), "RHEAP_%X",
seg_no);
break;
default:
cnss_pr_err("Unknown dump type ID: %d\n", type);
return -EINVAL;
}
md_entry.phys_addr = pa;
md_entry.virt_addr = (uintptr_t)va;
md_entry.size = size;
md_entry.id = MSM_DUMP_DATA_CNSS_WLAN;
cnss_pr_vdbg("Remove mini dump region: %s, va: %pK, pa: %pa, size: 0x%zx\n",
md_entry.name, va, &pa, size);
ret = msm_minidump_remove_region(&md_entry);
if (ret)
cnss_pr_err("Failed to remove mini dump region, err = %d\n",
ret);
return ret;
}
#else
int cnss_minidump_add_region(struct cnss_plat_data *plat_priv,
enum cnss_fw_dump_type type, int seg_no,
void *va, phys_addr_t pa, size_t size)
{
char name[MAX_NAME_LEN];
switch (type) {
case CNSS_FW_IMAGE:
snprintf(name, MAX_NAME_LEN, "FBC_%X", seg_no);
break;
case CNSS_FW_RDDM:
snprintf(name, MAX_NAME_LEN, "RDDM_%X", seg_no);
break;
case CNSS_FW_REMOTE_HEAP:
snprintf(name, MAX_NAME_LEN, "RHEAP_%X", seg_no);
break;
default:
cnss_pr_err("Unknown dump type ID: %d\n", type);
return -EINVAL;
}
cnss_pr_dbg("Dump region: %s, va: %pK, pa: %pa, size: 0x%zx\n",
name, va, &pa, size);
return 0;
}
int cnss_minidump_remove_region(struct cnss_plat_data *plat_priv,
enum cnss_fw_dump_type type, int seg_no,
void *va, phys_addr_t pa, size_t size)
{
return 0;
}
#endif /* CONFIG_QCOM_MINIDUMP */
int cnss_request_firmware_direct(struct cnss_plat_data *plat_priv,
const struct firmware **fw_entry,
const char *filename)
{
if (IS_ENABLED(CONFIG_CNSS_REQ_FW_DIRECT))
return request_firmware_direct(fw_entry, filename,
&plat_priv->plat_dev->dev);
else
return firmware_request_nowarn(fw_entry, filename,
&plat_priv->plat_dev->dev);
}
#if IS_ENABLED(CONFIG_INTERCONNECT)
/**
* cnss_register_bus_scale() - Setup interconnect voting data
* @plat_priv: Platform data structure
*
* For different interconnect path configured in device tree setup voting data
* for list of bandwidth requirements.
*
* Result: 0 for success. -EINVAL if not configured
*/
static int cnss_register_bus_scale(struct cnss_plat_data *plat_priv)
{
int ret = -EINVAL;
u32 idx, i, j, cfg_arr_size, *cfg_arr = NULL;
struct cnss_bus_bw_info *bus_bw_info, *tmp;
struct device *dev = &plat_priv->plat_dev->dev;
INIT_LIST_HEAD(&plat_priv->icc.list_head);
ret = of_property_read_u32(dev->of_node,
"qcom,icc-path-count",
&plat_priv->icc.path_count);
if (ret) {
cnss_pr_dbg("Platform Bus Interconnect path not configured\n");
return 0;
}
ret = of_property_read_u32(plat_priv->plat_dev->dev.of_node,
"qcom,bus-bw-cfg-count",
&plat_priv->icc.bus_bw_cfg_count);
if (ret) {
cnss_pr_err("Failed to get Bus BW Config table size\n");
goto cleanup;
}
cfg_arr_size = plat_priv->icc.path_count *
plat_priv->icc.bus_bw_cfg_count * CNSS_ICC_VOTE_MAX;
cfg_arr = kcalloc(cfg_arr_size, sizeof(*cfg_arr), GFP_KERNEL);
if (!cfg_arr) {
cnss_pr_err("Failed to alloc cfg table mem\n");
ret = -ENOMEM;
goto cleanup;
}
ret = of_property_read_u32_array(plat_priv->plat_dev->dev.of_node,
"qcom,bus-bw-cfg", cfg_arr,
cfg_arr_size);
if (ret) {
cnss_pr_err("Invalid Bus BW Config Table\n");
goto cleanup;
}
cnss_pr_dbg("ICC Path_Count: %d BW_CFG_Count: %d\n",
plat_priv->icc.path_count, plat_priv->icc.bus_bw_cfg_count);
for (idx = 0; idx < plat_priv->icc.path_count; idx++) {
bus_bw_info = devm_kzalloc(dev, sizeof(*bus_bw_info),
GFP_KERNEL);
if (!bus_bw_info) {
ret = -ENOMEM;
goto out;
}
ret = of_property_read_string_index(dev->of_node,
"interconnect-names", idx,
&bus_bw_info->icc_name);
if (ret)
goto out;
bus_bw_info->icc_path =
of_icc_get(&plat_priv->plat_dev->dev,
bus_bw_info->icc_name);
if (IS_ERR(bus_bw_info->icc_path)) {
ret = PTR_ERR(bus_bw_info->icc_path);
if (ret != -EPROBE_DEFER) {
cnss_pr_err("Failed to get Interconnect path for %s. Err: %d\n",
bus_bw_info->icc_name, ret);
goto out;
}
}
bus_bw_info->cfg_table =
devm_kcalloc(dev, plat_priv->icc.bus_bw_cfg_count,
sizeof(*bus_bw_info->cfg_table),
GFP_KERNEL);
if (!bus_bw_info->cfg_table) {
ret = -ENOMEM;
goto out;
}
cnss_pr_dbg("ICC Vote CFG for path: %s\n",
bus_bw_info->icc_name);
for (i = 0, j = (idx * plat_priv->icc.bus_bw_cfg_count *
CNSS_ICC_VOTE_MAX);
i < plat_priv->icc.bus_bw_cfg_count;
i++, j += 2) {
bus_bw_info->cfg_table[i].avg_bw = cfg_arr[j];
bus_bw_info->cfg_table[i].peak_bw = cfg_arr[j + 1];
cnss_pr_dbg("ICC Vote BW: %d avg: %d peak: %d\n",
i, bus_bw_info->cfg_table[i].avg_bw,
bus_bw_info->cfg_table[i].peak_bw);
}
list_add_tail(&bus_bw_info->list,
&plat_priv->icc.list_head);
}
kfree(cfg_arr);
return 0;
out:
list_for_each_entry_safe(bus_bw_info, tmp,
&plat_priv->icc.list_head, list) {
list_del(&bus_bw_info->list);
}
cleanup:
kfree(cfg_arr);
memset(&plat_priv->icc, 0, sizeof(plat_priv->icc));
return ret;
}
static void cnss_unregister_bus_scale(struct cnss_plat_data *plat_priv)
{
struct cnss_bus_bw_info *bus_bw_info, *tmp;
list_for_each_entry_safe(bus_bw_info, tmp,
&plat_priv->icc.list_head, list) {
list_del(&bus_bw_info->list);
if (bus_bw_info->icc_path)
icc_put(bus_bw_info->icc_path);
}
memset(&plat_priv->icc, 0, sizeof(plat_priv->icc));
}
#else
static int cnss_register_bus_scale(struct cnss_plat_data *plat_priv)
{
return 0;
}
static void cnss_unregister_bus_scale(struct cnss_plat_data *plat_priv) {}
#endif /* CONFIG_INTERCONNECT */
void cnss_daemon_connection_update_cb(void *cb_ctx, bool status)
{
struct cnss_plat_data *plat_priv = cb_ctx;
if (!plat_priv) {
cnss_pr_err("%s: Invalid context\n", __func__);
return;
}
if (status) {
cnss_pr_info("CNSS Daemon connected\n");
set_bit(CNSS_DAEMON_CONNECTED, &plat_priv->driver_state);
complete(&plat_priv->daemon_connected);
} else {
cnss_pr_info("CNSS Daemon disconnected\n");
reinit_completion(&plat_priv->daemon_connected);
clear_bit(CNSS_DAEMON_CONNECTED, &plat_priv->driver_state);
}
}
static ssize_t enable_hds_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
unsigned int enable_hds = 0;
if (!plat_priv)
return -ENODEV;
if (sscanf(buf, "%du", &enable_hds) != 1) {
cnss_pr_err("Invalid enable_hds sysfs command\n");
return -EINVAL;
}
if (enable_hds)
plat_priv->hds_enabled = true;
else
plat_priv->hds_enabled = false;
cnss_pr_dbg("%s HDS file download, count is %zu\n",
plat_priv->hds_enabled ? "Enable" : "Disable", count);
return count;
}
static ssize_t recovery_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
u32 buf_size = PAGE_SIZE;
u32 curr_len = 0;
u32 buf_written = 0;
if (!plat_priv)
return -ENODEV;
buf_written = scnprintf(buf, buf_size,
"Usage: echo [recovery_bitmap] > /sys/kernel/cnss/recovery\n"
"BIT0 -- wlan fw recovery\n"
"BIT1 -- wlan pcss recovery\n"
"---------------------------------\n");
curr_len += buf_written;
buf_written = scnprintf(buf + curr_len, buf_size - curr_len,
"WLAN recovery %s[%d]\n",
plat_priv->recovery_enabled ? "Enabled" : "Disabled",
plat_priv->recovery_enabled);
curr_len += buf_written;
buf_written = scnprintf(buf + curr_len, buf_size - curr_len,
"WLAN PCSS recovery %s[%d]\n",
plat_priv->recovery_pcss_enabled ? "Enabled" : "Disabled",
plat_priv->recovery_pcss_enabled);
curr_len += buf_written;
/*
* Now size of curr_len is not over page size for sure,
* later if new item or none-fixed size item added, need
* add check to make sure curr_len is not over page size.
*/
return curr_len;
}
static ssize_t tme_opt_file_download_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
u32 buf_size = PAGE_SIZE;
u32 curr_len = 0;
u32 buf_written = 0;
buf_written = scnprintf(buf, buf_size,
"Usage: echo [file_type] > /sys/kernel/cnss/tme_opt_file_download\n"
"file_type = sec -- For OEM_FUSE file\n"
"file_type = rpr -- For RPR file\n"
"file_type = dpr -- For DPR file\n");
curr_len += buf_written;
return curr_len;
}
static ssize_t time_sync_period_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
return scnprintf(buf, PAGE_SIZE, "%u ms\n",
plat_priv->ctrl_params.time_sync_period);
}
/**
* cnss_get_min_time_sync_period_by_vote() - Get minimum time sync period
* @plat_priv: Platform data structure
*
* Result: return minimum time sync period present in vote from wlan and sys
*/
uint32_t cnss_get_min_time_sync_period_by_vote(struct cnss_plat_data *plat_priv)
{
unsigned int i, min_time_sync_period = CNSS_TIME_SYNC_PERIOD_INVALID;
unsigned int time_sync_period;
for (i = 0; i < TIME_SYNC_VOTE_MAX; i++) {
time_sync_period = plat_priv->ctrl_params.time_sync_period_vote[i];
if (min_time_sync_period > time_sync_period)
min_time_sync_period = time_sync_period;
}
return min_time_sync_period;
}
static ssize_t time_sync_period_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
unsigned int time_sync_period = 0;
if (!plat_priv)
return -ENODEV;
if (sscanf(buf, "%du", &time_sync_period) != 1) {
cnss_pr_err("Invalid time sync sysfs command\n");
return -EINVAL;
}
if (time_sync_period < CNSS_MIN_TIME_SYNC_PERIOD) {
cnss_pr_err("Invalid time sync value\n");
return -EINVAL;
}
plat_priv->ctrl_params.time_sync_period_vote[TIME_SYNC_VOTE_CNSS] =
time_sync_period;
time_sync_period = cnss_get_min_time_sync_period_by_vote(plat_priv);
if (time_sync_period == CNSS_TIME_SYNC_PERIOD_INVALID) {
cnss_pr_err("Invalid min time sync value\n");
return -EINVAL;
}
cnss_bus_update_time_sync_period(plat_priv, time_sync_period);
return count;
}
/**
* cnss_update_time_sync_period() - Set time sync period given by driver
* @dev: device structure
* @time_sync_period: time sync period value
*
* Update time sync period vote of driver and set minimum of time sync period
* from stored vote through wlan and sys config
* Result: return 0 for success, error in case of invalid value and no dev
*/
int cnss_update_time_sync_period(struct device *dev, uint32_t time_sync_period)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
if (!plat_priv)
return -ENODEV;
if (time_sync_period < CNSS_MIN_TIME_SYNC_PERIOD) {
cnss_pr_err("Invalid time sync value\n");
return -EINVAL;
}
plat_priv->ctrl_params.time_sync_period_vote[TIME_SYNC_VOTE_WLAN] =
time_sync_period;
time_sync_period = cnss_get_min_time_sync_period_by_vote(plat_priv);
if (time_sync_period == CNSS_TIME_SYNC_PERIOD_INVALID) {
cnss_pr_err("Invalid min time sync value\n");
return -EINVAL;
}
cnss_bus_update_time_sync_period(plat_priv, time_sync_period);
return 0;
}
EXPORT_SYMBOL(cnss_update_time_sync_period);
/**
* cnss_reset_time_sync_period() - Reset time sync period
* @dev: device structure
*
* Update time sync period vote of driver as invalid
* and reset minimum of time sync period from
* stored vote through wlan and sys config
* Result: return 0 for success, error in case of no dev
*/
int cnss_reset_time_sync_period(struct device *dev)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
unsigned int time_sync_period = 0;
if (!plat_priv)
return -ENODEV;
/* Driver vote is set to invalid in case of reset
* In this case, only vote valid to check is sys config
*/
plat_priv->ctrl_params.time_sync_period_vote[TIME_SYNC_VOTE_WLAN] =
CNSS_TIME_SYNC_PERIOD_INVALID;
time_sync_period = cnss_get_min_time_sync_period_by_vote(plat_priv);
if (time_sync_period == CNSS_TIME_SYNC_PERIOD_INVALID) {
cnss_pr_err("Invalid min time sync value\n");
return -EINVAL;
}
cnss_bus_update_time_sync_period(plat_priv, time_sync_period);
return 0;
}
EXPORT_SYMBOL(cnss_reset_time_sync_period);
static ssize_t recovery_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
unsigned int recovery = 0;
if (!plat_priv)
return -ENODEV;
if (sscanf(buf, "%du", &recovery) != 1) {
cnss_pr_err("Invalid recovery sysfs command\n");
return -EINVAL;
}
plat_priv->recovery_enabled = !!(recovery & CNSS_WLAN_RECOVERY);
plat_priv->recovery_pcss_enabled = !!(recovery & CNSS_PCSS_RECOVERY);
cnss_pr_dbg("%s WLAN recovery, count is %zu\n",
plat_priv->recovery_enabled ? "Enable" : "Disable", count);
cnss_pr_dbg("%s PCSS recovery, count is %zu\n",
plat_priv->recovery_pcss_enabled ? "Enable" : "Disable", count);
cnss_send_subsys_restart_level_msg(plat_priv);
return count;
}
static ssize_t shutdown_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
cnss_pr_dbg("Received shutdown notification\n");
if (plat_priv) {
set_bit(CNSS_IN_REBOOT, &plat_priv->driver_state);
cnss_bus_update_status(plat_priv, CNSS_SYS_REBOOT);
del_timer(&plat_priv->fw_boot_timer);
complete_all(&plat_priv->power_up_complete);
complete_all(&plat_priv->cal_complete);
cnss_pr_dbg("Shutdown notification handled\n");
}
return count;
}
static ssize_t fs_ready_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int fs_ready = 0;
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
if (sscanf(buf, "%du", &fs_ready) != 1)
return -EINVAL;
cnss_pr_dbg("File system is ready, fs_ready is %d, count is %zu\n",
fs_ready, count);
if (!plat_priv) {
cnss_pr_err("plat_priv is NULL\n");
return count;
}
if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks)) {
cnss_pr_dbg("QMI is bypassed\n");
return count;
}
set_bit(CNSS_FS_READY, &plat_priv->driver_state);
if (fs_ready == FILE_SYSTEM_READY && plat_priv->cbc_enabled) {
cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START,
0, NULL);
}
return count;
}
static ssize_t qdss_trace_start_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
wlfw_qdss_trace_start(plat_priv);
cnss_pr_dbg("Received QDSS start command\n");
return count;
}
static ssize_t qdss_trace_stop_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
u32 option = 0;
if (sscanf(buf, "%du", &option) != 1)
return -EINVAL;
wlfw_qdss_trace_stop(plat_priv, option);
cnss_pr_dbg("Received QDSS stop command\n");
return count;
}
static ssize_t qdss_conf_download_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
cnss_wlfw_qdss_dnld_send_sync(plat_priv);
cnss_pr_dbg("Received QDSS download config command\n");
return count;
}
static ssize_t tme_opt_file_download_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
char cmd[5];
if (sscanf(buf, "%s", cmd) != 1)
return -EINVAL;
if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
cnss_pr_err("Firmware is not ready yet\n");
return 0;
}
if (plat_priv->device_id == PEACH_DEVICE_ID &&
cnss_bus_runtime_pm_get_sync(plat_priv) < 0)
goto runtime_pm_put;
if (strcmp(cmd, "sec") == 0) {
cnss_bus_load_tme_opt_file(plat_priv, WLFW_TME_LITE_OEM_FUSE_FILE_V01);
cnss_wlfw_tme_opt_file_dnld_send_sync(plat_priv, WLFW_TME_LITE_OEM_FUSE_FILE_V01);
} else if (strcmp(cmd, "rpr") == 0) {
cnss_bus_load_tme_opt_file(plat_priv, WLFW_TME_LITE_RPR_FILE_V01);
cnss_wlfw_tme_opt_file_dnld_send_sync(plat_priv, WLFW_TME_LITE_RPR_FILE_V01);
} else if (strcmp(cmd, "dpr") == 0) {
cnss_bus_load_tme_opt_file(plat_priv, WLFW_TME_LITE_DPR_FILE_V01);
cnss_wlfw_tme_opt_file_dnld_send_sync(plat_priv, WLFW_TME_LITE_DPR_FILE_V01);
}
cnss_pr_dbg("Received tme_opt_file_download indication cmd: %s\n", cmd);
runtime_pm_put:
if (plat_priv->device_id == PEACH_DEVICE_ID)
cnss_bus_runtime_pm_put(plat_priv);
return count;
}
static ssize_t hw_trace_override_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
int tmp = 0;
if (sscanf(buf, "%du", &tmp) != 1)
return -EINVAL;
plat_priv->hw_trc_override = tmp;
cnss_pr_dbg("Received QDSS hw_trc_override indication\n");
return count;
}
static ssize_t charger_mode_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
int tmp = 0;
if (sscanf(buf, "%du", &tmp) != 1)
return -EINVAL;
plat_priv->charger_mode = tmp;
cnss_pr_dbg("Received Charger Mode: %d\n", tmp);
return count;
}
static DEVICE_ATTR_WO(fs_ready);
static DEVICE_ATTR_WO(shutdown);
static DEVICE_ATTR_RW(recovery);
static DEVICE_ATTR_WO(enable_hds);
static DEVICE_ATTR_WO(qdss_trace_start);
static DEVICE_ATTR_WO(qdss_trace_stop);
static DEVICE_ATTR_WO(qdss_conf_download);
static DEVICE_ATTR_RW(tme_opt_file_download);
static DEVICE_ATTR_WO(hw_trace_override);
static DEVICE_ATTR_WO(charger_mode);
static DEVICE_ATTR_RW(time_sync_period);
static struct attribute *cnss_attrs[] = {
&dev_attr_fs_ready.attr,
&dev_attr_shutdown.attr,
&dev_attr_recovery.attr,
&dev_attr_enable_hds.attr,
&dev_attr_qdss_trace_start.attr,
&dev_attr_qdss_trace_stop.attr,
&dev_attr_qdss_conf_download.attr,
&dev_attr_tme_opt_file_download.attr,
&dev_attr_hw_trace_override.attr,
&dev_attr_charger_mode.attr,
&dev_attr_time_sync_period.attr,
NULL,
};
static struct attribute_group cnss_attr_group = {
.attrs = cnss_attrs,
};
static int cnss_create_sysfs_link(struct cnss_plat_data *plat_priv)
{
struct device *dev = &plat_priv->plat_dev->dev;
int ret;
char cnss_name[CNSS_FS_NAME_SIZE];
char shutdown_name[32];
if (cnss_is_dual_wlan_enabled()) {
snprintf(cnss_name, CNSS_FS_NAME_SIZE,
CNSS_FS_NAME "_%d", plat_priv->plat_idx);
snprintf(shutdown_name, sizeof(shutdown_name),
"shutdown_wlan_%d", plat_priv->plat_idx);
} else {
snprintf(cnss_name, CNSS_FS_NAME_SIZE, CNSS_FS_NAME);
snprintf(shutdown_name, sizeof(shutdown_name),
"shutdown_wlan");
}
ret = sysfs_create_link(kernel_kobj, &dev->kobj, cnss_name);
if (ret) {
cnss_pr_err("Failed to create cnss link, err = %d\n",
ret);
goto out;
}
/* This is only for backward compatibility. */
ret = sysfs_create_link(kernel_kobj, &dev->kobj, shutdown_name);
if (ret) {
cnss_pr_err("Failed to create shutdown_wlan link, err = %d\n",
ret);
goto rm_cnss_link;
}
return 0;
rm_cnss_link:
sysfs_remove_link(kernel_kobj, cnss_name);
out:
return ret;
}
static void cnss_remove_sysfs_link(struct cnss_plat_data *plat_priv)
{
char cnss_name[CNSS_FS_NAME_SIZE];
char shutdown_name[32];
if (cnss_is_dual_wlan_enabled()) {
snprintf(cnss_name, CNSS_FS_NAME_SIZE,
CNSS_FS_NAME "_%d", plat_priv->plat_idx);
snprintf(shutdown_name, sizeof(shutdown_name),
"shutdown_wlan_%d", plat_priv->plat_idx);
} else {
snprintf(cnss_name, CNSS_FS_NAME_SIZE, CNSS_FS_NAME);
snprintf(shutdown_name, sizeof(shutdown_name),
"shutdown_wlan");
}
sysfs_remove_link(kernel_kobj, shutdown_name);
sysfs_remove_link(kernel_kobj, cnss_name);
}
static int cnss_create_sysfs(struct cnss_plat_data *plat_priv)
{
int ret = 0;
ret = devm_device_add_group(&plat_priv->plat_dev->dev,
&cnss_attr_group);
if (ret) {
cnss_pr_err("Failed to create cnss device group, err = %d\n",
ret);
goto out;
}
cnss_create_sysfs_link(plat_priv);
return 0;
out:
return ret;
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 2, 0))
union cnss_device_group_devres {
const struct attribute_group *group;
};
static void devm_cnss_group_remove(struct device *dev, void *res)
{
union cnss_device_group_devres *devres = res;
const struct attribute_group *group = devres->group;
cnss_pr_dbg("%s: removing group %p\n", __func__, group);
sysfs_remove_group(&dev->kobj, group);
}
static int devm_cnss_group_match(struct device *dev, void *res, void *data)
{
return ((union cnss_device_group_devres *)res) == data;
}
static void cnss_remove_sysfs(struct cnss_plat_data *plat_priv)
{
cnss_remove_sysfs_link(plat_priv);
WARN_ON(devres_release(&plat_priv->plat_dev->dev,
devm_cnss_group_remove, devm_cnss_group_match,
(void *)&cnss_attr_group));
}
#else
static void cnss_remove_sysfs(struct cnss_plat_data *plat_priv)
{
cnss_remove_sysfs_link(plat_priv);
devm_device_remove_group(&plat_priv->plat_dev->dev, &cnss_attr_group);
}
#endif
static int cnss_event_work_init(struct cnss_plat_data *plat_priv)
{
spin_lock_init(&plat_priv->event_lock);
plat_priv->event_wq = alloc_workqueue("cnss_driver_event",
WQ_UNBOUND, 1);
if (!plat_priv->event_wq) {
cnss_pr_err("Failed to create event workqueue!\n");
return -EFAULT;
}
INIT_WORK(&plat_priv->event_work, cnss_driver_event_work);
INIT_LIST_HEAD(&plat_priv->event_list);
return 0;
}
static void cnss_event_work_deinit(struct cnss_plat_data *plat_priv)
{
destroy_workqueue(plat_priv->event_wq);
}
static int cnss_reboot_notifier(struct notifier_block *nb,
unsigned long action,
void *data)
{
struct cnss_plat_data *plat_priv =
container_of(nb, struct cnss_plat_data, reboot_nb);
set_bit(CNSS_IN_REBOOT, &plat_priv->driver_state);
cnss_bus_update_status(plat_priv, CNSS_SYS_REBOOT);
del_timer(&plat_priv->fw_boot_timer);
complete_all(&plat_priv->power_up_complete);
complete_all(&plat_priv->cal_complete);
cnss_pr_dbg("Reboot is in progress with action %d\n", action);
return NOTIFY_DONE;
}
#ifdef CONFIG_CNSS_HW_SECURE_DISABLE
#ifdef CONFIG_CNSS_HW_SECURE_SMEM
int cnss_wlan_hw_disable_check(struct cnss_plat_data *plat_priv)
{
uint32_t *peripheralStateInfo = NULL;
size_t size = 0;
/* Once this flag is set, secure peripheral feature
* will not be supported till next reboot
*/
if (plat_priv->sec_peri_feature_disable)
return 0;
peripheralStateInfo = qcom_smem_get(QCOM_SMEM_HOST_ANY, PERISEC_SMEM_ID, &size);
if (IS_ERR_OR_NULL(peripheralStateInfo)) {
if (PTR_ERR(peripheralStateInfo) != -ENOENT &&
PTR_ERR(peripheralStateInfo) != -ENODEV)
CNSS_ASSERT(0);
cnss_pr_dbg("Secure HW feature not enabled. ret = %d\n",
PTR_ERR(peripheralStateInfo));
plat_priv->sec_peri_feature_disable = true;
return 0;
}
cnss_pr_dbg("Secure HW state: %d\n", *peripheralStateInfo);
if ((*peripheralStateInfo >> (HW_WIFI_UID - 0x500)) & 0x1)
set_bit(CNSS_WLAN_HW_DISABLED,
&plat_priv->driver_state);
else
clear_bit(CNSS_WLAN_HW_DISABLED,
&plat_priv->driver_state);
return 0;
}
#else
int cnss_wlan_hw_disable_check(struct cnss_plat_data *plat_priv)
{
struct Object client_env;
struct Object app_object;
u32 wifi_uid = HW_WIFI_UID;
union ObjectArg obj_arg[2] = {{{0, 0}}};
int ret;
u8 state = 0;
/* Once this flag is set, secure peripheral feature
* will not be supported till next reboot
*/
if (plat_priv->sec_peri_feature_disable)
return 0;
/* get rootObj */
ret = get_client_env_object(&client_env);
if (ret) {
cnss_pr_dbg("Failed to get client_env_object, ret: %d\n", ret);
goto end;
}
ret = IClientEnv_open(client_env, HW_STATE_UID, &app_object);
if (ret) {
cnss_pr_dbg("Failed to get app_object, ret: %d\n", ret);
if (ret == FEATURE_NOT_SUPPORTED) {
ret = 0; /* Do not Assert */
plat_priv->sec_peri_feature_disable = true;
cnss_pr_dbg("Secure HW feature not supported\n");
}
goto exit_release_clientenv;
}
obj_arg[0].b = (struct ObjectBuf) {&wifi_uid, sizeof(u32)};
obj_arg[1].b = (struct ObjectBuf) {&state, sizeof(u8)};
ret = Object_invoke(app_object, HW_OP_GET_STATE, obj_arg,
ObjectCounts_pack(1, 1, 0, 0));
cnss_pr_dbg("SMC invoke ret: %d state: %d\n", ret, state);
if (ret) {
if (ret == PERIPHERAL_NOT_FOUND) {
ret = 0; /* Do not Assert */
plat_priv->sec_peri_feature_disable = true;
cnss_pr_dbg("Secure HW mode is not updated. Peripheral not found\n");
}
goto exit_release_app_obj;
}
if (state == 1)
set_bit(CNSS_WLAN_HW_DISABLED,
&plat_priv->driver_state);
else
clear_bit(CNSS_WLAN_HW_DISABLED,
&plat_priv->driver_state);
exit_release_app_obj:
Object_release(app_object);
exit_release_clientenv:
Object_release(client_env);
end:
if (ret) {
cnss_pr_err("Unable to get HW disable status\n");
CNSS_ASSERT(0);
}
return ret;
}
#endif
#else
int cnss_wlan_hw_disable_check(struct cnss_plat_data *plat_priv)
{
return 0;
}
#endif
#ifdef CONFIG_DISABLE_CNSS_SRAM_DUMP
static void cnss_sram_dump_init(struct cnss_plat_data *plat_priv)
{
}
#else
static void cnss_sram_dump_init(struct cnss_plat_data *plat_priv)
{
if (plat_priv->device_id == QCA6490_DEVICE_ID &&
cnss_get_host_build_type() == QMI_HOST_BUILD_TYPE_PRIMARY_V01)
plat_priv->sram_dump = kcalloc(SRAM_DUMP_SIZE, 1, GFP_KERNEL);
}
#endif
#if IS_ENABLED(CONFIG_WCNSS_MEM_PRE_ALLOC)
static void cnss_initialize_mem_pool(unsigned long device_id)
{
cnss_initialize_prealloc_pool(device_id);
}
static void cnss_deinitialize_mem_pool(void)
{
cnss_deinitialize_prealloc_pool();
}
#else
static void cnss_initialize_mem_pool(unsigned long device_id)
{
}
static void cnss_deinitialize_mem_pool(void)
{
}
#endif
static int cnss_misc_init(struct cnss_plat_data *plat_priv)
{
int ret;
ret = cnss_init_sol_gpio(plat_priv);
if (ret)
return ret;
timer_setup(&plat_priv->fw_boot_timer,
cnss_bus_fw_boot_timeout_hdlr, 0);
ret = device_init_wakeup(&plat_priv->plat_dev->dev, true);
if (ret)
cnss_pr_err("Failed to init platform device wakeup source, err = %d\n",
ret);
INIT_WORK(&plat_priv->recovery_work, cnss_recovery_work_handler);
init_completion(&plat_priv->power_up_complete);
init_completion(&plat_priv->cal_complete);
init_completion(&plat_priv->rddm_complete);
init_completion(&plat_priv->recovery_complete);
init_completion(&plat_priv->daemon_connected);
mutex_init(&plat_priv->dev_lock);
mutex_init(&plat_priv->driver_ops_lock);
plat_priv->reboot_nb.notifier_call = cnss_reboot_notifier;
ret = register_reboot_notifier(&plat_priv->reboot_nb);
if (ret)
cnss_pr_err("Failed to register reboot notifier, err = %d\n",
ret);
plat_priv->recovery_ws =
wakeup_source_register(&plat_priv->plat_dev->dev,
"CNSS_FW_RECOVERY");
if (!plat_priv->recovery_ws)
cnss_pr_err("Failed to setup FW recovery wake source\n");
ret = cnss_plat_ipc_register(CNSS_PLAT_IPC_DAEMON_QMI_CLIENT_V01,
cnss_daemon_connection_update_cb,
plat_priv);
if (ret)
cnss_pr_err("QMI IPC connection call back register failed, err = %d\n",
ret);
cnss_sram_dump_init(plat_priv);
if (of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"qcom,rc-ep-short-channel"))
cnss_set_feature_list(plat_priv, CNSS_RC_EP_ULTRASHORT_CHANNEL_V01);
if (plat_priv->device_id == PEACH_DEVICE_ID)
cnss_set_feature_list(plat_priv, CNSS_AUX_UC_SUPPORT_V01);
return 0;
}
#ifdef CONFIG_DISABLE_CNSS_SRAM_DUMP
static void cnss_sram_dump_deinit(struct cnss_plat_data *plat_priv)
{
}
#else
static void cnss_sram_dump_deinit(struct cnss_plat_data *plat_priv)
{
if (plat_priv->device_id == QCA6490_DEVICE_ID &&
cnss_get_host_build_type() == QMI_HOST_BUILD_TYPE_PRIMARY_V01)
kfree(plat_priv->sram_dump);
}
#endif
static void cnss_misc_deinit(struct cnss_plat_data *plat_priv)
{
cnss_plat_ipc_unregister(CNSS_PLAT_IPC_DAEMON_QMI_CLIENT_V01,
plat_priv);
complete_all(&plat_priv->recovery_complete);
complete_all(&plat_priv->rddm_complete);
complete_all(&plat_priv->cal_complete);
complete_all(&plat_priv->power_up_complete);
complete_all(&plat_priv->daemon_connected);
device_init_wakeup(&plat_priv->plat_dev->dev, false);
unregister_reboot_notifier(&plat_priv->reboot_nb);
del_timer(&plat_priv->fw_boot_timer);
wakeup_source_unregister(plat_priv->recovery_ws);
cnss_deinit_sol_gpio(plat_priv);
cnss_sram_dump_deinit(plat_priv);
kfree(plat_priv->on_chip_pmic_board_ids);
}
static void cnss_init_time_sync_period_default(struct cnss_plat_data *plat_priv)
{
plat_priv->ctrl_params.time_sync_period_vote[TIME_SYNC_VOTE_WLAN] =
CNSS_TIME_SYNC_PERIOD_INVALID;
plat_priv->ctrl_params.time_sync_period_vote[TIME_SYNC_VOTE_CNSS] =
CNSS_TIME_SYNC_PERIOD_DEFAULT;
}
static void cnss_init_control_params(struct cnss_plat_data *plat_priv)
{
plat_priv->ctrl_params.quirks = CNSS_QUIRKS_DEFAULT;
plat_priv->cbc_enabled = !IS_ENABLED(CONFIG_CNSS_EMULATION) &&
of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"qcom,wlan-cbc-enabled");
plat_priv->ctrl_params.mhi_timeout = CNSS_MHI_TIMEOUT_DEFAULT;
plat_priv->ctrl_params.mhi_m2_timeout = CNSS_MHI_M2_TIMEOUT_DEFAULT;
plat_priv->ctrl_params.qmi_timeout = CNSS_QMI_TIMEOUT_DEFAULT;
plat_priv->ctrl_params.bdf_type = CNSS_BDF_TYPE_DEFAULT;
plat_priv->ctrl_params.time_sync_period = CNSS_TIME_SYNC_PERIOD_DEFAULT;
cnss_init_time_sync_period_default(plat_priv);
/* Set adsp_pc_enabled default value to true as ADSP pc is always
* enabled by default
*/
plat_priv->adsp_pc_enabled = true;
}
static void cnss_get_pm_domain_info(struct cnss_plat_data *plat_priv)
{
struct device *dev = &plat_priv->plat_dev->dev;
plat_priv->use_pm_domain =
of_property_read_bool(dev->of_node, "use-pm-domain");
cnss_pr_dbg("use-pm-domain is %d\n", plat_priv->use_pm_domain);
}
static void cnss_get_wlaon_pwr_ctrl_info(struct cnss_plat_data *plat_priv)
{
struct device *dev = &plat_priv->plat_dev->dev;
plat_priv->set_wlaon_pwr_ctrl =
of_property_read_bool(dev->of_node, "qcom,set-wlaon-pwr-ctrl");
cnss_pr_dbg("set_wlaon_pwr_ctrl is %d\n",
plat_priv->set_wlaon_pwr_ctrl);
}
static bool cnss_use_fw_path_with_prefix(struct cnss_plat_data *plat_priv)
{
return (of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"qcom,converged-dt") ||
of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"qcom,same-dt-multi-dev") ||
of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"qcom,multi-wlan-exchg"));
}
static const struct platform_device_id cnss_platform_id_table[] = {
{ .name = "qca6174", .driver_data = QCA6174_DEVICE_ID, },
{ .name = "qca6290", .driver_data = QCA6290_DEVICE_ID, },
{ .name = "qca6390", .driver_data = QCA6390_DEVICE_ID, },
{ .name = "qca6490", .driver_data = QCA6490_DEVICE_ID, },
{ .name = "kiwi", .driver_data = KIWI_DEVICE_ID, },
{ .name = "mango", .driver_data = MANGO_DEVICE_ID, },
{ .name = "peach", .driver_data = PEACH_DEVICE_ID, },
{ .name = "qcaconv", .driver_data = 0, },
{ },
};
static const struct of_device_id cnss_of_match_table[] = {
{
.compatible = "qcom,cnss",
.data = (void *)&cnss_platform_id_table[0]},
{
.compatible = "qcom,cnss-qca6290",
.data = (void *)&cnss_platform_id_table[1]},
{
.compatible = "qcom,cnss-qca6390",
.data = (void *)&cnss_platform_id_table[2]},
{
.compatible = "qcom,cnss-qca6490",
.data = (void *)&cnss_platform_id_table[3]},
{
.compatible = "qcom,cnss-kiwi",
.data = (void *)&cnss_platform_id_table[4]},
{
.compatible = "qcom,cnss-mango",
.data = (void *)&cnss_platform_id_table[5]},
{
.compatible = "qcom,cnss-peach",
.data = (void *)&cnss_platform_id_table[6]},
{
.compatible = "qcom,cnss-qca-converged",
.data = (void *)&cnss_platform_id_table[7]},
{ },
};
MODULE_DEVICE_TABLE(of, cnss_of_match_table);
static inline bool
cnss_use_nv_mac(struct cnss_plat_data *plat_priv)
{
return of_property_read_bool(plat_priv->plat_dev->dev.of_node,
"use-nv-mac");
}
static int cnss_get_dev_cfg_node(struct cnss_plat_data *plat_priv)
{
struct device_node *child;
u32 id, i;
int id_n, device_identifier_gpio, ret;
u8 gpio_value;
if (plat_priv->dt_type != CNSS_DTT_CONVERGED)
return 0;
/* Parses the wlan_sw_ctrl gpio which is used to identify device */
ret = cnss_get_wlan_sw_ctrl(plat_priv);
if (ret) {
cnss_pr_dbg("Failed to parse wlan_sw_ctrl gpio, error:%d", ret);
return ret;
}
device_identifier_gpio = plat_priv->pinctrl_info.wlan_sw_ctrl_gpio;
gpio_value = gpio_get_value(device_identifier_gpio);
cnss_pr_dbg("Value of Device Identifier GPIO: %d\n", gpio_value);
for_each_available_child_of_node(plat_priv->plat_dev->dev.of_node,
child) {
if (strcmp(child->name, "chip_cfg"))
continue;
id_n = of_property_count_u32_elems(child, "supported-ids");
if (id_n <= 0) {
cnss_pr_err("Device id is NOT set\n");
return -EINVAL;
}
for (i = 0; i < id_n; i++) {
ret = of_property_read_u32_index(child,
"supported-ids",
i, &id);
if (ret) {
cnss_pr_err("Failed to read supported ids\n");
return -EINVAL;
}
if (gpio_value && id == QCA6490_DEVICE_ID) {
plat_priv->plat_dev->dev.of_node = child;
plat_priv->device_id = QCA6490_DEVICE_ID;
cnss_utils_update_device_type(CNSS_HSP_DEVICE_TYPE);
cnss_pr_dbg("got node[%s@%d] for device[0x%x]\n",
child->name, i, id);
return 0;
} else if (!gpio_value && id == KIWI_DEVICE_ID) {
plat_priv->plat_dev->dev.of_node = child;
plat_priv->device_id = KIWI_DEVICE_ID;
cnss_utils_update_device_type(CNSS_HMT_DEVICE_TYPE);
cnss_pr_dbg("got node[%s@%d] for device[0x%x]\n",
child->name, i, id);
return 0;
}
}
}
return -EINVAL;
}
static inline u32
cnss_dt_type(struct cnss_plat_data *plat_priv)
{
bool is_converged_dt = of_property_read_bool(
plat_priv->plat_dev->dev.of_node, "qcom,converged-dt");
bool is_multi_wlan_xchg;
if (is_converged_dt)
return CNSS_DTT_CONVERGED;
is_multi_wlan_xchg = of_property_read_bool(
plat_priv->plat_dev->dev.of_node, "qcom,multi-wlan-exchg");
if (is_multi_wlan_xchg)
return CNSS_DTT_MULTIEXCHG;
return CNSS_DTT_LEGACY;
}
static int cnss_wlan_device_init(struct cnss_plat_data *plat_priv)
{
int ret = 0;
int retry = 0;
if (test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks))
return 0;
retry:
ret = cnss_power_on_device(plat_priv, true);
if (ret)
goto end;
ret = cnss_bus_init(plat_priv);
if (ret) {
if ((ret != -EPROBE_DEFER) &&
retry++ < POWER_ON_RETRY_MAX_TIMES) {
cnss_power_off_device(plat_priv);
cnss_pr_dbg("Retry cnss_bus_init #%d\n", retry);
msleep(POWER_ON_RETRY_DELAY_MS * retry);
goto retry;
}
goto power_off;
}
return 0;
power_off:
cnss_power_off_device(plat_priv);
end:
return ret;
}
int cnss_wlan_hw_enable(void)
{
struct cnss_plat_data *plat_priv;
int ret = 0;
if (cnss_is_dual_wlan_enabled())
plat_priv = cnss_get_first_plat_priv(NULL);
else
plat_priv = cnss_get_plat_priv(NULL);
if (!plat_priv)
return -ENODEV;
clear_bit(CNSS_WLAN_HW_DISABLED, &plat_priv->driver_state);
if (test_bit(CNSS_PCI_PROBE_DONE, &plat_priv->driver_state))
goto register_driver;
ret = cnss_wlan_device_init(plat_priv);
if (ret) {
if (!test_bit(CNSS_WLAN_HW_DISABLED, &plat_priv->driver_state))
CNSS_ASSERT(0);
return ret;
}
if (test_bit(CNSS_FS_READY, &plat_priv->driver_state))
cnss_driver_event_post(plat_priv,
CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START,
0, NULL);
register_driver:
if (plat_priv->driver_ops)
ret = cnss_wlan_register_driver(plat_priv->driver_ops);
return ret;
}
EXPORT_SYMBOL(cnss_wlan_hw_enable);
int cnss_set_wfc_mode(struct device *dev, struct cnss_wfc_cfg cfg)
{
struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
int ret = 0;
if (!plat_priv)
return -ENODEV;
/* If IMS server is connected, return success without QMI send */
if (test_bit(CNSS_IMS_CONNECTED, &plat_priv->driver_state)) {
cnss_pr_dbg("Ignore host request as IMS server is connected");
return ret;
}
ret = cnss_wlfw_send_host_wfc_call_status(plat_priv, cfg);
return ret;
}
EXPORT_SYMBOL(cnss_set_wfc_mode);
static int cnss_tcdev_get_max_state(struct thermal_cooling_device *tcdev,
unsigned long *thermal_state)
{
struct cnss_thermal_cdev *cnss_tcdev = NULL;
if (!tcdev || !tcdev->devdata) {
cnss_pr_err("tcdev or tcdev->devdata is null!\n");
return -EINVAL;
}
cnss_tcdev = tcdev->devdata;
*thermal_state = cnss_tcdev->max_thermal_state;
return 0;
}
static int cnss_tcdev_get_cur_state(struct thermal_cooling_device *tcdev,
unsigned long *thermal_state)
{
struct cnss_thermal_cdev *cnss_tcdev = NULL;
if (!tcdev || !tcdev->devdata) {
cnss_pr_err("tcdev or tcdev->devdata is null!\n");
return -EINVAL;
}
cnss_tcdev = tcdev->devdata;
*thermal_state = cnss_tcdev->curr_thermal_state;
return 0;
}
static int cnss_tcdev_set_cur_state(struct thermal_cooling_device *tcdev,
unsigned long thermal_state)
{
struct cnss_thermal_cdev *cnss_tcdev = NULL;
struct cnss_plat_data *plat_priv = cnss_get_plat_priv(NULL);
int ret = 0;
if (!tcdev || !tcdev->devdata) {
cnss_pr_err("tcdev or tcdev->devdata is null!\n");
return -EINVAL;
}
cnss_tcdev = tcdev->devdata;
if (thermal_state > cnss_tcdev->max_thermal_state)
return -EINVAL;
cnss_pr_vdbg("Cooling device set current state: %ld,for cdev id %d",
thermal_state, cnss_tcdev->tcdev_id);
mutex_lock(&plat_priv->tcdev_lock);
ret = cnss_bus_set_therm_cdev_state(plat_priv,
thermal_state,
cnss_tcdev->tcdev_id);
if (!ret)
cnss_tcdev->curr_thermal_state = thermal_state;
mutex_unlock(&plat_priv->tcdev_lock);
if (ret) {
cnss_pr_err("Setting Current Thermal State Failed: %d,for cdev id %d",
ret, cnss_tcdev->tcdev_id);
return ret;
}
return 0;
}
static struct thermal_cooling_device_ops cnss_cooling_ops = {
.get_max_state = cnss_tcdev_get_max_state,
.get_cur_state = cnss_tcdev_get_cur_state,
.set_cur_state = cnss_tcdev_set_cur_state,
};
int cnss_thermal_cdev_register(struct device *dev, unsigned long max_state,
int tcdev_id)
{
struct cnss_plat_data *priv = cnss_get_plat_priv(NULL);
struct cnss_thermal_cdev *cnss_tcdev = NULL;
char cdev_node_name[THERMAL_NAME_LENGTH] = "";
struct device_node *dev_node;
int ret = 0;
if (!priv) {
cnss_pr_err("Platform driver is not initialized!\n");
return -ENODEV;
}
cnss_tcdev = kzalloc(sizeof(*cnss_tcdev), GFP_KERNEL);
if (!cnss_tcdev) {
cnss_pr_err("Failed to allocate cnss_tcdev object!\n");
return -ENOMEM;
}
cnss_tcdev->tcdev_id = tcdev_id;
cnss_tcdev->max_thermal_state = max_state;
snprintf(cdev_node_name, THERMAL_NAME_LENGTH,
"qcom,cnss_cdev%d", tcdev_id);
dev_node = of_find_node_by_name(NULL, cdev_node_name);
if (!dev_node) {
cnss_pr_err("Failed to get cooling device node\n");
kfree(cnss_tcdev);
return -EINVAL;
}
cnss_pr_dbg("tcdev node->name=%s\n", dev_node->name);
if (of_find_property(dev_node, "#cooling-cells", NULL)) {
cnss_tcdev->tcdev = thermal_of_cooling_device_register(dev_node,
cdev_node_name,
cnss_tcdev,
&cnss_cooling_ops);
if (IS_ERR_OR_NULL(cnss_tcdev->tcdev)) {
ret = PTR_ERR(cnss_tcdev->tcdev);
cnss_pr_err("Cooling device register failed: %d, for cdev id %d\n",
ret, cnss_tcdev->tcdev_id);
kfree(cnss_tcdev);
} else {
cnss_pr_dbg("Cooling device registered for cdev id %d",
cnss_tcdev->tcdev_id);
mutex_lock(&priv->tcdev_lock);
list_add(&cnss_tcdev->tcdev_list,
&priv->cnss_tcdev_list);
mutex_unlock(&priv->tcdev_lock);
}
} else {
cnss_pr_dbg("Cooling device registration not supported");
kfree(cnss_tcdev);
ret = -EOPNOTSUPP;
}
return ret;
}
EXPORT_SYMBOL(cnss_thermal_cdev_register);
void cnss_thermal_cdev_unregister(struct device *dev, int tcdev_id)
{
struct cnss_plat_data *priv = cnss_get_plat_priv(NULL);
struct cnss_thermal_cdev *cnss_tcdev = NULL;
if (!priv) {
cnss_pr_err("Platform driver is not initialized!\n");
return;
}
mutex_lock(&priv->tcdev_lock);
while (!list_empty(&priv->cnss_tcdev_list)) {
cnss_tcdev = list_first_entry(&priv->cnss_tcdev_list,
struct cnss_thermal_cdev,
tcdev_list);
thermal_cooling_device_unregister(cnss_tcdev->tcdev);
list_del(&cnss_tcdev->tcdev_list);
kfree(cnss_tcdev);
}
mutex_unlock(&priv->tcdev_lock);
}
EXPORT_SYMBOL(cnss_thermal_cdev_unregister);
int cnss_get_curr_therm_cdev_state(struct device *dev,
unsigned long *thermal_state,
int tcdev_id)
{
struct cnss_plat_data *priv = cnss_get_plat_priv(NULL);
struct cnss_thermal_cdev *cnss_tcdev = NULL;
if (!priv) {
cnss_pr_err("Platform driver is not initialized!\n");
return -ENODEV;
}
mutex_lock(&priv->tcdev_lock);
list_for_each_entry(cnss_tcdev, &priv->cnss_tcdev_list, tcdev_list) {
if (cnss_tcdev->tcdev_id != tcdev_id)
continue;
*thermal_state = cnss_tcdev->curr_thermal_state;
mutex_unlock(&priv->tcdev_lock);
cnss_pr_dbg("Cooling device current state: %ld, for cdev id %d",
cnss_tcdev->curr_thermal_state, tcdev_id);
return 0;
}
mutex_unlock(&priv->tcdev_lock);
cnss_pr_dbg("Cooling device ID not found: %d", tcdev_id);
return -EINVAL;
}
EXPORT_SYMBOL(cnss_get_curr_therm_cdev_state);
static int cnss_probe(struct platform_device *plat_dev)
{
int ret = 0;
struct cnss_plat_data *plat_priv;
const struct of_device_id *of_id;
const struct platform_device_id *device_id;
if (cnss_get_plat_priv(plat_dev)) {
cnss_pr_err("Driver is already initialized!\n");
ret = -EEXIST;
goto out;
}
ret = cnss_plat_env_available();
if (ret)
goto out;
of_id = of_match_device(cnss_of_match_table, &plat_dev->dev);
if (!of_id || !of_id->data) {
cnss_pr_err("Failed to find of match device!\n");
ret = -ENODEV;
goto out;
}
device_id = of_id->data;
plat_priv = devm_kzalloc(&plat_dev->dev, sizeof(*plat_priv),
GFP_KERNEL);
if (!plat_priv) {
ret = -ENOMEM;
goto out;
}
plat_priv->plat_dev = plat_dev;
plat_priv->dev_node = NULL;
plat_priv->device_id = device_id->driver_data;
plat_priv->dt_type = cnss_dt_type(plat_priv);
cnss_pr_dbg("Probing platform driver from dt type: %d\n",
plat_priv->dt_type);
plat_priv->use_fw_path_with_prefix =
cnss_use_fw_path_with_prefix(plat_priv);
ret = cnss_get_dev_cfg_node(plat_priv);
if (ret) {
cnss_pr_err("Failed to get device cfg node, err = %d\n", ret);
goto reset_plat_dev;
}
cnss_initialize_mem_pool(plat_priv->device_id);
ret = cnss_get_pld_bus_ops_name(plat_priv);
if (ret)
cnss_pr_vdbg("Failed to find bus ops name, err = %d\n",
ret);
ret = cnss_get_rc_num(plat_priv);
if (ret)
cnss_pr_err("Failed to find PCIe RC number, err = %d\n", ret);
cnss_pr_dbg("rc_num=%d\n", plat_priv->rc_num);
plat_priv->bus_type = cnss_get_bus_type(plat_priv);
plat_priv->use_nv_mac = cnss_use_nv_mac(plat_priv);
cnss_set_plat_priv(plat_dev, plat_priv);
cnss_set_device_name(plat_priv);
platform_set_drvdata(plat_dev, plat_priv);
INIT_LIST_HEAD(&plat_priv->vreg_list);
INIT_LIST_HEAD(&plat_priv->clk_list);
cnss_get_pm_domain_info(plat_priv);
cnss_get_wlaon_pwr_ctrl_info(plat_priv);
cnss_power_misc_params_init(plat_priv);
cnss_get_tcs_info(plat_priv);
cnss_get_cpr_info(plat_priv);
cnss_aop_interface_init(plat_priv);
cnss_init_control_params(plat_priv);
ret = cnss_get_resources(plat_priv);
if (ret)
goto reset_ctx;
ret = cnss_register_esoc(plat_priv);
if (ret)
goto free_res;
ret = cnss_register_bus_scale(plat_priv);
if (ret)
goto unreg_esoc;
ret = cnss_create_sysfs(plat_priv);
if (ret)
goto unreg_bus_scale;
ret = cnss_event_work_init(plat_priv);
if (ret)
goto remove_sysfs;
ret = cnss_dms_init(plat_priv);
if (ret)
goto deinit_event_work;
ret = cnss_debugfs_create(plat_priv);
if (ret)
goto deinit_dms;
ret = cnss_misc_init(plat_priv);
if (ret)
goto destroy_debugfs;
ret = cnss_wlan_hw_disable_check(plat_priv);
if (ret)
goto deinit_misc;
/* Make sure all platform related init are done before
* device power on and bus init.
*/
if (!test_bit(CNSS_WLAN_HW_DISABLED, &plat_priv->driver_state)) {
ret = cnss_wlan_device_init(plat_priv);
if (ret)
goto deinit_misc;
} else {
cnss_pr_info("WLAN HW Disabled. Defer PCI enumeration\n");
}
cnss_register_coex_service(plat_priv);
cnss_register_ims_service(plat_priv);
mutex_init(&plat_priv->tcdev_lock);
INIT_LIST_HEAD(&plat_priv->cnss_tcdev_list);
cnss_pr_info("Platform driver probed successfully.\n");
return 0;
deinit_misc:
cnss_misc_deinit(plat_priv);
destroy_debugfs:
cnss_debugfs_destroy(plat_priv);
deinit_dms:
cnss_dms_deinit(plat_priv);
deinit_event_work:
cnss_event_work_deinit(plat_priv);
remove_sysfs:
cnss_remove_sysfs(plat_priv);
unreg_bus_scale:
cnss_unregister_bus_scale(plat_priv);
unreg_esoc:
cnss_unregister_esoc(plat_priv);
free_res:
cnss_put_resources(plat_priv);
reset_ctx:
cnss_aop_interface_deinit(plat_priv);
platform_set_drvdata(plat_dev, NULL);
cnss_deinitialize_mem_pool();
reset_plat_dev:
cnss_clear_plat_priv(plat_priv);
out:
return ret;
}
static int cnss_remove(struct platform_device *plat_dev)
{
struct cnss_plat_data *plat_priv = platform_get_drvdata(plat_dev);
plat_priv->audio_iommu_domain = NULL;
cnss_genl_exit();
cnss_unregister_ims_service(plat_priv);
cnss_unregister_coex_service(plat_priv);
cnss_bus_deinit(plat_priv);
cnss_misc_deinit(plat_priv);
cnss_debugfs_destroy(plat_priv);
cnss_dms_deinit(plat_priv);
cnss_qmi_deinit(plat_priv);
cnss_event_work_deinit(plat_priv);
cnss_cancel_dms_work();
cnss_remove_sysfs(plat_priv);
cnss_unregister_bus_scale(plat_priv);
cnss_unregister_esoc(plat_priv);
cnss_put_resources(plat_priv);
cnss_aop_interface_deinit(plat_priv);
cnss_deinitialize_mem_pool();
platform_set_drvdata(plat_dev, NULL);
cnss_clear_plat_priv(plat_priv);
return 0;
}
static struct platform_driver cnss_platform_driver = {
.probe = cnss_probe,
.remove = cnss_remove,
.driver = {
.name = "cnss2",
.of_match_table = cnss_of_match_table,
#ifdef CONFIG_CNSS_ASYNC
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
#endif
},
};
static bool cnss_check_compatible_node(void)
{
struct device_node *dn = NULL;
for_each_matching_node(dn, cnss_of_match_table) {
if (of_device_is_available(dn)) {
cnss_allow_driver_loading = true;
return true;
}
}
return false;
}
/**
* cnss_is_valid_dt_node_found - Check if valid device tree node present
*
* Valid device tree node means a node with "compatible" property from the
* device match table and "status" property is not disabled.
*
* Return: true if valid device tree node found, false if not found
*/
static bool cnss_is_valid_dt_node_found(void)
{
struct device_node *dn = NULL;
for_each_matching_node(dn, cnss_of_match_table) {
if (of_device_is_available(dn))
break;
}
if (dn)
return true;
return false;
}
static int __init cnss_initialize(void)
{
int ret = 0;
if (!cnss_is_valid_dt_node_found())
return -ENODEV;
if (!cnss_check_compatible_node())
return ret;
cnss_debug_init();
ret = platform_driver_register(&cnss_platform_driver);
if (ret)
cnss_debug_deinit();
ret = cnss_genl_init();
if (ret < 0)
cnss_pr_err("CNSS genl init failed %d\n", ret);
cnss_init_plat_env_count();
return ret;
}
static void __exit cnss_exit(void)
{
cnss_genl_exit();
platform_driver_unregister(&cnss_platform_driver);
cnss_debug_deinit();
}
module_init(cnss_initialize);
module_exit(cnss_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("CNSS2 Platform Driver");
مرجع در شماره جدید View Git Blame پرمالینک را کپی کنید