// 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 14, 0)) #include #endif #if IS_ENABLED(CONFIG_QCOM_MINIDUMP) #include #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 #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");