// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. */ #define pr_fmt(fmt) "icnss2_qmi: " fmt #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CONFIG_CNSS_OUT_OF_TREE #include "icnss2.h" #else #include #endif #include #include "wlan_firmware_service_v01.h" #include "main.h" #include "qmi.h" #include "debug.h" #include "genl.h" #define WLFW_SERVICE_WCN_INS_ID_V01 3 #define WLFW_SERVICE_INS_ID_V01 0 #define WLFW_CLIENT_ID 0x4b4e454c #define QMI_ERR_PLAT_CCPM_CLK_INIT_FAILED 0x77 #define BDF_FILE_NAME_PREFIX "bdwlan" #define ELF_BDF_FILE_NAME "bdwlan.elf" #define ELF_BDF_FILE_NAME_PREFIX "bdwlan.e" #define BIN_BDF_FILE_NAME "bdwlan.bin" #define BIN_BDF_FILE_NAME_PREFIX "bdwlan." #define REGDB_FILE_NAME "regdb.bin" #define QDSS_TRACE_CONFIG_FILE "qdss_trace_config.cfg" #define WLAN_BOARD_ID_INDEX 0x100 #define DEVICE_BAR_SIZE 0x200000 #define M3_SEGMENT_ADDR_MASK 0xFFFFFFFF #define DMS_QMI_MAX_MSG_LEN SZ_256 #define DMS_MAC_NOT_PROVISIONED 16 #define BDWLAN_SIZE 6 #define UMC_CHIP_ID 0x4320 #define MAX_SHADOW_REG_RESERVED 2 #define MAX_NUM_SHADOW_REG_V3 (QMI_WLFW_MAX_NUM_SHADOW_REG_V3_USAGE_V01 - \ MAX_SHADOW_REG_RESERVED) #define IMSPRIVATE_SERVICE_MAX_MSG_LEN SZ_8K #ifdef CONFIG_ICNSS2_DEBUG bool ignore_fw_timeout; #define ICNSS_QMI_ASSERT() ICNSS_ASSERT(ignore_fw_timeout) #else #define ICNSS_QMI_ASSERT() do { } while (0) #endif #ifdef CONFIG_ICNSS2_DEBUG void icnss_ignore_fw_timeout(bool ignore) { ignore_fw_timeout = ignore; } #else void icnss_ignore_fw_timeout(bool ignore) { } #endif #define icnss_qmi_fatal_err(_fmt, ...) do { \ icnss_pr_err("fatal: "_fmt, ##__VA_ARGS__); \ ICNSS_QMI_ASSERT(); \ } while (0) int wlfw_msa_mem_info_send_sync_msg(struct icnss_priv *priv) { int ret; int i; struct wlfw_msa_info_req_msg_v01 *req; struct wlfw_msa_info_resp_msg_v01 *resp; struct qmi_txn txn; uint64_t max_mapped_addr; if (!priv) return -ENODEV; icnss_pr_dbg("Sending MSA mem info, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->msa_addr = priv->msa_pa; req->size = priv->msa_mem_size; priv->stats.msa_info_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_msa_info_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err( "Fail to init txn for MSA Mem info resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_MSA_INFO_REQ_V01, WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN, wlfw_msa_info_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send MSA Mem info req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err("MSA Mem info resp wait failed ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI MSA Mem info request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } icnss_pr_dbg("Receive mem_region_info_len: %d\n", resp->mem_region_info_len); if (resp->mem_region_info_len > QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01) { icnss_qmi_fatal_err( "Invalid memory region length received: %d\n", resp->mem_region_info_len); ret = -EINVAL; goto out; } max_mapped_addr = priv->msa_pa + priv->msa_mem_size; priv->stats.msa_info_resp++; priv->nr_mem_region = resp->mem_region_info_len; for (i = 0; i < resp->mem_region_info_len; i++) { if (resp->mem_region_info[i].size > priv->msa_mem_size || resp->mem_region_info[i].region_addr >= max_mapped_addr || resp->mem_region_info[i].region_addr < priv->msa_pa || resp->mem_region_info[i].size + resp->mem_region_info[i].region_addr > max_mapped_addr) { icnss_pr_dbg("Received out of range Addr: 0x%llx Size: 0x%x\n", resp->mem_region_info[i].region_addr, resp->mem_region_info[i].size); ret = -EINVAL; goto fail_unwind; } priv->mem_region[i].reg_addr = resp->mem_region_info[i].region_addr; priv->mem_region[i].size = resp->mem_region_info[i].size; priv->mem_region[i].secure_flag = resp->mem_region_info[i].secure_flag; icnss_pr_dbg("Memory Region: %d Addr: 0x%llx Size: 0x%x Flag: 0x%08x\n", i, priv->mem_region[i].reg_addr, priv->mem_region[i].size, priv->mem_region[i].secure_flag); } kfree(resp); kfree(req); return 0; fail_unwind: memset(&priv->mem_region[0], 0, sizeof(priv->mem_region[0]) * i); out: kfree(resp); kfree(req); priv->stats.msa_info_err++; return ret; } int wlfw_msa_ready_send_sync_msg(struct icnss_priv *priv) { int ret; struct wlfw_msa_ready_req_msg_v01 *req; struct wlfw_msa_ready_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending MSA ready request message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } priv->stats.msa_ready_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_msa_ready_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err( "Fail to init txn for MSA Mem Ready resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_MSA_READY_REQ_V01, WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN, wlfw_msa_ready_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send MSA Mem Ready req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err( "MSA Mem Ready resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI MSA Mem Ready request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.msa_ready_resp++; kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.msa_ready_err++; return ret; } int wlfw_device_info_send_msg(struct icnss_priv *priv) { int ret; struct wlfw_device_info_req_msg_v01 *req; struct wlfw_device_info_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending Device Info request message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } priv->stats.device_info_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_device_info_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err( "Fail to init txn for Device Info resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_DEVICE_INFO_REQ_V01, WLFW_DEVICE_INFO_REQ_MSG_V01_MAX_MSG_LEN, wlfw_device_info_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send device info req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err( "Device Info resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI Device info request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.device_info_resp++; if (resp->bar_addr_valid) priv->mem_base_pa = resp->bar_addr; if (resp->bar_size_valid) priv->mem_base_size = resp->bar_size; if (!priv->mem_base_pa) { ret = -EINVAL; icnss_qmi_fatal_err("Fail to get bar address\n"); goto out; } if (priv->mem_base_size < DEVICE_BAR_SIZE) { ret = -EINVAL; icnss_qmi_fatal_err("Bar size is not proper 0x%x\n", priv->mem_base_size); goto out; } if (resp->mhi_state_info_addr_valid) priv->mhi_state_info_pa = resp->mhi_state_info_addr; if (resp->mhi_state_info_size_valid) priv->mhi_state_info_size = resp->mhi_state_info_size; if (!priv->mhi_state_info_pa) icnss_pr_err("Fail to get MHI info address\n"); kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.device_info_err++; return ret; } int wlfw_power_save_send_msg(struct icnss_priv *priv, enum wlfw_power_save_mode_v01 mode) { int ret; struct wlfw_power_save_req_msg_v01 *req; struct qmi_txn txn; if (!priv) return -ENODEV; if (test_bit(ICNSS_FW_DOWN, &priv->state)) return -EINVAL; if (test_bit(ICNSS_PD_RESTART, &priv->state) || !test_bit(ICNSS_MODE_ON, &priv->state)) return 0; icnss_pr_dbg("Sending power save mode: %d, state: 0x%lx\n", mode, priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; req->power_save_mode_valid = 1; req->power_save_mode = mode; if (mode == WLFW_POWER_SAVE_EXIT_V01) priv->stats.exit_power_save_req++; else priv->stats.enter_power_save_req++; ret = qmi_txn_init(&priv->qmi, &txn, NULL, NULL); if (ret < 0) { icnss_qmi_fatal_err("Fail to init txn for exit power save%d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_POWER_SAVE_REQ_V01, WLFW_POWER_SAVE_REQ_MSG_V01_MAX_MSG_LEN, wlfw_power_save_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send exit power save req %d\n", ret); goto out; } qmi_txn_cancel(&txn); if (mode == WLFW_POWER_SAVE_EXIT_V01) priv->stats.exit_power_save_resp++; else priv->stats.enter_power_save_resp++; kfree(req); return 0; out: kfree(req); if (mode == WLFW_POWER_SAVE_EXIT_V01) priv->stats.exit_power_save_err++; else priv->stats.enter_power_save_err++; return ret; } int wlfw_send_soc_wake_msg(struct icnss_priv *priv, enum wlfw_soc_wake_enum_v01 type) { int ret; struct wlfw_soc_wake_req_msg_v01 *req; struct wlfw_soc_wake_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; if (test_bit(ICNSS_FW_DOWN, &priv->state)) return -EINVAL; icnss_pr_soc_wake("Sending soc wake msg, type: 0x%x\n", type); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->wake_valid = 1; req->wake = type; priv->stats.soc_wake_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_soc_wake_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for wake msg resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_SOC_WAKE_REQ_V01, WLFW_SOC_WAKE_REQ_MSG_V01_MAX_MSG_LEN, wlfw_soc_wake_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send soc wake msg %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err("SOC wake timed out with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "SOC wake request rejected,result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.soc_wake_resp++; kfree(resp); kfree(req); return 0; out: kfree(req); kfree(resp); priv->stats.soc_wake_err++; return ret; } int wlfw_ind_register_send_sync_msg(struct icnss_priv *priv) { int ret; struct wlfw_ind_register_req_msg_v01 *req; struct wlfw_ind_register_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending indication register message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->client_id_valid = 1; req->client_id = WLFW_CLIENT_ID; req->fw_ready_enable_valid = 1; req->fw_ready_enable = 1; req->pin_connect_result_enable_valid = 1; req->pin_connect_result_enable = 1; if (priv->device_id == ADRASTEA_DEVICE_ID) { req->msa_ready_enable_valid = 1; req->msa_ready_enable = 1; if (test_bit(FW_REJUVENATE_ENABLE, &priv->ctrl_params.quirks)) { req->rejuvenate_enable_valid = 1; req->rejuvenate_enable = 1; } } else if (priv->device_id == WCN6750_DEVICE_ID || priv->device_id == WCN6450_DEVICE_ID) { req->fw_init_done_enable_valid = 1; req->fw_init_done_enable = 1; req->cal_done_enable_valid = 1; req->cal_done_enable = 1; req->qdss_trace_req_mem_enable_valid = 1; req->qdss_trace_req_mem_enable = 1; req->qdss_trace_save_enable_valid = 1; req->qdss_trace_save_enable = 1; req->qdss_trace_free_enable_valid = 1; req->qdss_trace_free_enable = 1; req->respond_get_info_enable_valid = 1; req->respond_get_info_enable = 1; req->m3_dump_upload_segments_req_enable_valid = 1; req->m3_dump_upload_segments_req_enable = 1; } priv->stats.ind_register_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_ind_register_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err( "Fail to init txn for Ind Register resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_IND_REGISTER_REQ_V01, WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN, wlfw_ind_register_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send Ind Register req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err( "Ind Register resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI Ind Register request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.ind_register_resp++; if (resp->fw_status_valid && (resp->fw_status & QMI_WLFW_ALREADY_REGISTERED_V01)) { ret = -EALREADY; icnss_pr_dbg("WLFW already registered\n"); goto qmi_registered; } kfree(resp); kfree(req); return 0; out: priv->stats.ind_register_err++; qmi_registered: kfree(resp); kfree(req); return ret; } int wlfw_cal_report_req(struct icnss_priv *priv) { int ret; struct wlfw_cal_report_req_msg_v01 *req; struct wlfw_cal_report_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; if (test_bit(ICNSS_FW_DOWN, &priv->state)) return -EINVAL; icnss_pr_info("Sending cal report request, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->meta_data_len = 0; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_cal_report_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err("Fail to init txn for cal report req %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_CAL_REPORT_REQ_V01, WLFW_CAL_REPORT_REQ_MSG_V01_MAX_MSG_LEN, wlfw_cal_report_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send cal report req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err("Cal report wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err("QMI cal report request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } kfree(resp); kfree(req); return 0; out: return ret; } int wlfw_cap_send_sync_msg(struct icnss_priv *priv) { int ret = 0, i = 0; struct wlfw_cap_req_msg_v01 *req; struct wlfw_cap_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending target capability message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } priv->stats.cap_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_cap_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err("Fail to init txn for Capability resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_CAP_REQ_V01, WLFW_CAP_REQ_MSG_V01_MAX_MSG_LEN, wlfw_cap_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send Capability req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout + msecs_to_jiffies(priv->wlan_en_delay_ms)); if (ret < 0) { icnss_qmi_fatal_err("Capability resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { ret = -resp->resp.result; if (resp->resp.error == QMI_ERR_PLAT_CCPM_CLK_INIT_FAILED) { icnss_pr_err("RF card not present\n"); goto out; } icnss_qmi_fatal_err( "QMI Capability request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); goto out; } priv->stats.cap_resp++; if (resp->chip_info_valid) { priv->chip_info.chip_id = resp->chip_info.chip_id; priv->chip_info.chip_family = resp->chip_info.chip_family; } if (resp->board_info_valid) priv->board_id = resp->board_info.board_id; else priv->board_id = 0xFF; if (resp->soc_info_valid) priv->soc_id = resp->soc_info.soc_id; if (resp->fw_version_info_valid) { priv->fw_version_info.fw_version = resp->fw_version_info.fw_version; strlcpy(priv->fw_version_info.fw_build_timestamp, resp->fw_version_info.fw_build_timestamp, WLFW_MAX_TIMESTAMP_LEN + 1); } if (resp->dev_mem_info_valid) { for (i = 0; i < QMI_WLFW_MAX_DEV_MEM_NUM_V01; i++) { priv->dev_mem_info[i].start = resp->dev_mem_info[i].start; priv->dev_mem_info[i].size = resp->dev_mem_info[i].size; icnss_pr_info("Device memory info[%d]: start = 0x%llx, size = 0x%llx\n", i, priv->dev_mem_info[i].start, priv->dev_mem_info[i].size); } } if (resp->voltage_mv_valid) { priv->cpr_info.voltage = resp->voltage_mv; icnss_pr_dbg("Voltage for CPR: %dmV\n", priv->cpr_info.voltage); icnss_update_cpr_info(priv); } if (resp->fw_build_id_valid) strlcpy(priv->fw_build_id, resp->fw_build_id, QMI_WLFW_MAX_BUILD_ID_LEN_V01 + 1); if (resp->rd_card_chain_cap_valid) { priv->rd_card_chain_cap = (enum icnss_rd_card_chain_cap)resp->rd_card_chain_cap; if (resp->rd_card_chain_cap == WLFW_RD_CARD_CHAIN_CAP_1x1_V01) priv->is_chain1_supported = false; } if (resp->foundry_name_valid) priv->foundry_name = resp->foundry_name[0]; else if (resp->chip_info_valid && priv->chip_info.chip_id == UMC_CHIP_ID) priv->foundry_name = 'u'; if (resp->he_channel_width_cap_valid) priv->phy_he_channel_width_cap = (enum icnss_phy_he_channel_width_cap)resp->he_channel_width_cap; if (resp->phy_qam_cap_valid) priv->phy_qam_cap = (enum icnss_phy_qam_cap)resp->phy_qam_cap; if (resp->serial_id_valid) { priv->serial_id = resp->serial_id; icnss_pr_info("serial id 0x%x 0x%x\n", resp->serial_id.serial_id_msb, resp->serial_id.serial_id_lsb); } icnss_pr_dbg("Capability, chip_id: 0x%x, chip_family: 0x%x, board_id: 0x%x, soc_id: 0x%x", priv->chip_info.chip_id, priv->chip_info.chip_family, priv->board_id, priv->soc_id); icnss_pr_dbg("fw_version: 0x%x, fw_build_timestamp: %s, fw_build_id: %s", priv->fw_version_info.fw_version, priv->fw_version_info.fw_build_timestamp, priv->fw_build_id); icnss_pr_dbg("RD card chain cap: %d, PHY HE channel width cap: %d, PHY QAM cap: %d", priv->rd_card_chain_cap, priv->phy_he_channel_width_cap, priv->phy_qam_cap); kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.cap_err++; return ret; } int icnss_qmi_get_dms_mac(struct icnss_priv *priv) { struct dms_get_mac_address_req_msg_v01 req; struct dms_get_mac_address_resp_msg_v01 resp; struct qmi_txn txn; int ret = 0; if (!test_bit(ICNSS_QMI_DMS_CONNECTED, &priv->state)) { icnss_pr_err("DMS QMI connection not established\n"); return -EAGAIN; } icnss_pr_dbg("Requesting DMS MAC address"); memset(&resp, 0, sizeof(resp)); ret = qmi_txn_init(&priv->qmi_dms, &txn, dms_get_mac_address_resp_msg_v01_ei, &resp); if (ret < 0) { icnss_pr_err("Failed to initialize txn for dms, err: %d\n", ret); goto out; } req.device = DMS_DEVICE_MAC_WLAN_V01; ret = qmi_send_request(&priv->qmi_dms, NULL, &txn, QMI_DMS_GET_MAC_ADDRESS_REQ_V01, DMS_GET_MAC_ADDRESS_REQ_MSG_V01_MAX_MSG_LEN, dms_get_mac_address_req_msg_v01_ei, &req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Failed to send QMI_DMS_GET_MAC_ADDRESS_REQ_V01, err: %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Failed to wait for QMI_DMS_GET_MAC_ADDRESS_RESP_V01, err: %d\n", ret); goto out; } if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { if (resp.resp.error == DMS_MAC_NOT_PROVISIONED) { icnss_pr_err("NV MAC address is not provisioned"); priv->dms.nv_mac_not_prov = 1; } else { icnss_pr_err("QMI_DMS_GET_MAC_ADDRESS_REQ_V01 failed, result: %d, err: %d\n", resp.resp.result, resp.resp.error); } ret = -resp.resp.result; goto out; } if (!resp.mac_address_valid || resp.mac_address_len != QMI_WLFW_MAC_ADDR_SIZE_V01) { icnss_pr_err("Invalid MAC address received from DMS\n"); priv->dms.mac_valid = false; goto out; } priv->dms.mac_valid = true; memcpy(priv->dms.mac, resp.mac_address, QMI_WLFW_MAC_ADDR_SIZE_V01); icnss_pr_info("Received DMS MAC: [%pM]\n", priv->dms.mac); out: return ret; } int icnss_wlfw_wlan_mac_req_send_sync(struct icnss_priv *priv, u8 *mac, u32 mac_len) { struct wlfw_mac_addr_req_msg_v01 req; struct wlfw_mac_addr_resp_msg_v01 resp = {0}; struct qmi_txn txn; int ret; if (!priv || !mac || mac_len != QMI_WLFW_MAC_ADDR_SIZE_V01) return -EINVAL; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_mac_addr_resp_msg_v01_ei, &resp); if (ret < 0) { icnss_pr_err("Failed to initialize txn for mac req, err: %d\n", ret); ret = -EIO; goto out; } icnss_pr_dbg("Sending WLAN mac req [%pM], state: 0x%lx\n", mac, priv->state); memcpy(req.mac_addr, mac, mac_len); req.mac_addr_valid = 1; ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_MAC_ADDR_REQ_V01, WLFW_MAC_ADDR_REQ_MSG_V01_MAX_MSG_LEN, wlfw_mac_addr_req_msg_v01_ei, &req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Failed to send mac req, err: %d\n", ret); ret = -EIO; goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Failed to wait for resp of mac req, err: %d\n", ret); ret = -EIO; goto out; } if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("WLAN mac req failed, result: %d\n", resp.resp.result); ret = -resp.resp.result; } out: return ret; } static int icnss_dms_connect_to_server(struct icnss_priv *priv, unsigned int node, unsigned int port) { struct qmi_handle *qmi_dms = &priv->qmi_dms; struct sockaddr_qrtr sq = {0}; int ret = 0; sq.sq_family = AF_QIPCRTR; sq.sq_node = node; sq.sq_port = port; ret = kernel_connect(qmi_dms->sock, (struct sockaddr *)&sq, sizeof(sq), 0); if (ret < 0) { icnss_pr_err("Failed to connect to QMI DMS remote service Node: %d Port: %d\n", node, port); goto out; } set_bit(ICNSS_QMI_DMS_CONNECTED, &priv->state); icnss_pr_info("QMI DMS service connected, state: 0x%lx\n", priv->state); out: return ret; } static int dms_new_server(struct qmi_handle *qmi_dms, struct qmi_service *service) { struct icnss_priv *priv = container_of(qmi_dms, struct icnss_priv, qmi_dms); if (!service) return -EINVAL; return icnss_dms_connect_to_server(priv, service->node, service->port); } static void dms_del_server(struct qmi_handle *qmi_dms, struct qmi_service *service) { struct icnss_priv *priv = container_of(qmi_dms, struct icnss_priv, qmi_dms); clear_bit(ICNSS_QMI_DMS_CONNECTED, &priv->state); icnss_pr_info("QMI DMS service disconnected, state: 0x%lx\n", priv->state); } static struct qmi_ops qmi_dms_ops = { .new_server = dms_new_server, .del_server = dms_del_server, }; int icnss_dms_init(struct icnss_priv *priv) { int ret = 0; ret = qmi_handle_init(&priv->qmi_dms, DMS_QMI_MAX_MSG_LEN, &qmi_dms_ops, NULL); if (ret < 0) { icnss_pr_err("Failed to initialize DMS handle, err: %d\n", ret); goto out; } ret = qmi_add_lookup(&priv->qmi_dms, DMS_SERVICE_ID_V01, DMS_SERVICE_VERS_V01, 0); if (ret < 0) icnss_pr_err("Failed to add DMS lookup, err: %d\n", ret); out: return ret; } void icnss_dms_deinit(struct icnss_priv *priv) { qmi_handle_release(&priv->qmi_dms); } static int icnss_get_bdf_file_name(struct icnss_priv *priv, u32 bdf_type, char *filename, u32 filename_len) { char filename_tmp[ICNSS_MAX_FILE_NAME]; char foundry_specific_filename[ICNSS_MAX_FILE_NAME]; int ret = 0; switch (bdf_type) { case ICNSS_BDF_ELF: if (priv->board_id == 0xFF) snprintf(filename_tmp, filename_len, ELF_BDF_FILE_NAME); else if (priv->board_id < 0xFF) snprintf(filename_tmp, filename_len, ELF_BDF_FILE_NAME_PREFIX "%02x", priv->board_id); else snprintf(filename_tmp, filename_len, BDF_FILE_NAME_PREFIX "%02x.e%02x", priv->board_id >> 8 & 0xFF, priv->board_id & 0xFF); break; case ICNSS_BDF_BIN: if (priv->board_id == 0xFF) snprintf(filename_tmp, filename_len, BIN_BDF_FILE_NAME); else if (priv->board_id >= WLAN_BOARD_ID_INDEX) snprintf(filename_tmp, filename_len, BIN_BDF_FILE_NAME_PREFIX "%03x", priv->board_id); else snprintf(filename_tmp, filename_len, BIN_BDF_FILE_NAME_PREFIX "b%02x", priv->board_id); if (priv->foundry_name) { strlcpy(foundry_specific_filename, filename_tmp, ICNSS_MAX_FILE_NAME); memmove(foundry_specific_filename + BDWLAN_SIZE + 1, foundry_specific_filename + BDWLAN_SIZE, BDWLAN_SIZE - 1); foundry_specific_filename[BDWLAN_SIZE] = priv->foundry_name; foundry_specific_filename[ICNSS_MAX_FILE_NAME - 1] = '\0'; strlcpy(filename_tmp, foundry_specific_filename, ICNSS_MAX_FILE_NAME); } break; case ICNSS_BDF_REGDB: snprintf(filename_tmp, filename_len, REGDB_FILE_NAME); break; default: icnss_pr_err("Invalid BDF type: %d\n", priv->ctrl_params.bdf_type); ret = -EINVAL; break; } if (!ret) icnss_add_fw_prefix_name(priv, filename, filename_tmp); return ret; } static char *icnss_bdf_type_to_str(enum icnss_bdf_type bdf_type) { switch (bdf_type) { case ICNSS_BDF_BIN: return "BDF"; case ICNSS_BDF_ELF: return "BDF"; case ICNSS_BDF_REGDB: return "REGDB"; default: return "UNKNOWN"; } }; int icnss_wlfw_bdf_dnld_send_sync(struct icnss_priv *priv, u32 bdf_type) { struct wlfw_bdf_download_req_msg_v01 *req; struct wlfw_bdf_download_resp_msg_v01 *resp; struct qmi_txn txn; char filename[ICNSS_MAX_FILE_NAME]; const struct firmware *fw_entry = NULL; const u8 *temp; unsigned int remaining; int ret = 0; icnss_pr_dbg("Sending %s download message, state: 0x%lx, type: %d\n", icnss_bdf_type_to_str(bdf_type), priv->state, bdf_type); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } ret = icnss_get_bdf_file_name(priv, bdf_type, filename, sizeof(filename)); if (ret) goto err_req_fw; ret = firmware_request_nowarn(&fw_entry, filename, &priv->pdev->dev); if (ret) { icnss_pr_err("Failed to load %s: %s ret:%d\n", icnss_bdf_type_to_str(bdf_type), filename, ret); goto err_req_fw; } temp = fw_entry->data; remaining = fw_entry->size; icnss_pr_dbg("Downloading %s: %s, size: %u\n", icnss_bdf_type_to_str(bdf_type), filename, remaining); while (remaining) { req->valid = 1; req->file_id_valid = 1; req->file_id = priv->board_id; req->total_size_valid = 1; req->total_size = fw_entry->size; req->seg_id_valid = 1; req->data_valid = 1; req->end_valid = 1; req->bdf_type_valid = 1; req->bdf_type = bdf_type; if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) { req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01; } else { req->data_len = remaining; req->end = 1; } memcpy(req->data, temp, req->data_len); ret = qmi_txn_init(&priv->qmi, &txn, wlfw_bdf_download_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Failed to initialize txn for %s download request, err: %d\n", icnss_bdf_type_to_str(bdf_type), ret); goto err_send; } ret = qmi_send_request (&priv->qmi, NULL, &txn, QMI_WLFW_BDF_DOWNLOAD_REQ_V01, WLFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN, wlfw_bdf_download_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Failed to send respond %s download request, err: %d\n", icnss_bdf_type_to_str(bdf_type), ret); goto err_send; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Failed to wait for response of %s download request, err: %d\n", icnss_bdf_type_to_str(bdf_type), ret); goto err_send; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("%s download request failed, result: %d, err: %d\n", icnss_bdf_type_to_str(bdf_type), resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto err_send; } remaining -= req->data_len; temp += req->data_len; req->seg_id++; } release_firmware(fw_entry); kfree(req); kfree(resp); return 0; err_send: release_firmware(fw_entry); err_req_fw: if (bdf_type != ICNSS_BDF_REGDB) ICNSS_QMI_ASSERT(); kfree(req); kfree(resp); return ret; } int icnss_wlfw_qdss_data_send_sync(struct icnss_priv *priv, char *file_name, u32 total_size) { int ret = 0; struct wlfw_qdss_trace_data_req_msg_v01 *req; struct wlfw_qdss_trace_data_resp_msg_v01 *resp; unsigned char *p_qdss_trace_data_temp, *p_qdss_trace_data = NULL; unsigned int remaining; struct qmi_txn txn; icnss_pr_dbg("%s", __func__); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } p_qdss_trace_data = kzalloc(total_size, GFP_KERNEL); if (!p_qdss_trace_data) { ret = ENOMEM; goto end; } remaining = total_size; p_qdss_trace_data_temp = p_qdss_trace_data; while (remaining && resp->end == 0) { ret = qmi_txn_init(&priv->qmi, &txn, wlfw_qdss_trace_data_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for QDSS trace resp %d\n", ret); goto fail; } ret = qmi_send_request (&priv->qmi, NULL, &txn, QMI_WLFW_QDSS_TRACE_DATA_REQ_V01, WLFW_QDSS_TRACE_DATA_REQ_MSG_V01_MAX_MSG_LEN, wlfw_qdss_trace_data_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send QDSS trace data req %d\n", ret); goto fail; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("QDSS trace resp wait failed with rc %d\n", ret); goto fail; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QMI QDSS trace request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto fail; } else { ret = 0; } icnss_pr_dbg("%s: response total size %d data len %d", __func__, resp->total_size, resp->data_len); if ((resp->total_size_valid == 1 && resp->total_size == total_size) && (resp->seg_id_valid == 1 && resp->seg_id == req->seg_id) && (resp->data_valid == 1 && resp->data_len <= QMI_WLFW_MAX_DATA_SIZE_V01) && resp->data_len <= remaining) { memcpy(p_qdss_trace_data_temp, resp->data, resp->data_len); } else { icnss_pr_err("%s: Unmatched qdss trace data, Expect total_size %u, seg_id %u, Recv total_size_valid %u, total_size %u, seg_id_valid %u, seg_id %u, data_len_valid %u, data_len %u", __func__, total_size, req->seg_id, resp->total_size_valid, resp->total_size, resp->seg_id_valid, resp->seg_id, resp->data_valid, resp->data_len); ret = -EINVAL; goto fail; } remaining -= resp->data_len; p_qdss_trace_data_temp += resp->data_len; req->seg_id++; } if (remaining == 0 && (resp->end_valid && resp->end)) { ret = icnss_genl_send_msg(p_qdss_trace_data, ICNSS_GENL_MSG_TYPE_QDSS, file_name, total_size); if (ret < 0) { icnss_pr_err("Fail to save QDSS trace data: %d\n", ret); ret = -EINVAL; } } else { icnss_pr_err("%s: QDSS trace file corrupted: remaining %u, end_valid %u, end %u", __func__, remaining, resp->end_valid, resp->end); ret = -EINVAL; } fail: kfree(p_qdss_trace_data); end: kfree(req); kfree(resp); return ret; } int icnss_wlfw_qdss_dnld_send_sync(struct icnss_priv *priv) { struct wlfw_qdss_trace_config_download_req_msg_v01 *req; struct wlfw_qdss_trace_config_download_resp_msg_v01 *resp; struct qmi_txn txn; char filename[ICNSS_MAX_FILE_NAME]; const struct firmware *fw_entry = NULL; const u8 *temp; unsigned int remaining; int ret = 0; icnss_pr_dbg("Sending QDSS config download message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } icnss_add_fw_prefix_name(priv, filename, QDSS_TRACE_CONFIG_FILE); ret = firmware_request_nowarn(&fw_entry, filename, &priv->pdev->dev); if (ret) { icnss_pr_err("Failed to load QDSS: %s ret:%d\n", filename, ret); goto err_req_fw; } temp = fw_entry->data; remaining = fw_entry->size; icnss_pr_dbg("Downloading QDSS: %s, size: %u\n", filename, remaining); while (remaining) { req->total_size_valid = 1; req->total_size = remaining; req->seg_id_valid = 1; req->data_valid = 1; req->end_valid = 1; if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) { req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01; } else { req->data_len = remaining; req->end = 1; } memcpy(req->data, temp, req->data_len); ret = qmi_txn_init (&priv->qmi, &txn, wlfw_qdss_trace_config_download_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Failed to initialize txn for QDSS download request, err: %d\n", ret); goto err_send; } ret = qmi_send_request (&priv->qmi, NULL, &txn, QMI_WLFW_QDSS_TRACE_CONFIG_DOWNLOAD_REQ_V01, WLFW_QDSS_TRACE_CONFIG_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN, wlfw_qdss_trace_config_download_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Failed to send respond QDSS download request, err: %d\n", ret); goto err_send; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Failed to wait for response of QDSS download request, err: %d\n", ret); goto err_send; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QDSS download request failed, result: %d, err: %d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto err_send; } remaining -= req->data_len; temp += req->data_len; req->seg_id++; } release_firmware(fw_entry); kfree(req); kfree(resp); return 0; err_send: release_firmware(fw_entry); err_req_fw: kfree(req); kfree(resp); return ret; } int wlfw_wlan_mode_send_sync_msg(struct icnss_priv *priv, enum wlfw_driver_mode_enum_v01 mode) { int ret; struct wlfw_wlan_mode_req_msg_v01 *req; struct wlfw_wlan_mode_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; /* During recovery do not send mode request for WLAN OFF as * FW not able to process it. */ if (test_bit(ICNSS_PD_RESTART, &priv->state) && mode == QMI_WLFW_OFF_V01) return 0; if (!test_bit(ICNSS_MODE_ON, &priv->state) && mode == QMI_WLFW_OFF_V01) return 0; icnss_pr_dbg("Sending Mode request, state: 0x%lx, mode: %d\n", priv->state, mode); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->mode = mode; req->hw_debug_valid = 1; req->hw_debug = !!test_bit(HW_DEBUG_ENABLE, &priv->ctrl_params.quirks); if (priv->wlan_en_delay_ms >= 100) { icnss_pr_dbg("Setting WLAN_EN delay: %d ms\n", priv->wlan_en_delay_ms); req->wlan_en_delay_valid = 1; req->wlan_en_delay = priv->wlan_en_delay_ms; } priv->stats.mode_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_wlan_mode_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err("Fail to init txn for Mode resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_WLAN_MODE_REQ_V01, WLFW_WLAN_MODE_REQ_MSG_V01_MAX_MSG_LEN, wlfw_wlan_mode_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send Mode req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout + msecs_to_jiffies(priv->wlan_en_delay_ms)); if (ret < 0) { icnss_qmi_fatal_err("Mode resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI Mode request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.mode_resp++; if (mode == QMI_WLFW_OFF_V01) { icnss_pr_dbg("Clear mode on 0x%lx, mode: %d\n", priv->state, mode); clear_bit(ICNSS_MODE_ON, &priv->state); } else { icnss_pr_dbg("Set mode on 0x%lx, mode: %d\n", priv->state, mode); set_bit(ICNSS_MODE_ON, &priv->state); } kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.mode_req_err++; return ret; } static int wlfw_send_qdss_trace_mode_req (struct icnss_priv *priv, enum wlfw_qdss_trace_mode_enum_v01 mode, unsigned long long option) { int rc = 0; int tmp = 0; struct wlfw_qdss_trace_mode_req_msg_v01 *req; struct wlfw_qdss_trace_mode_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->mode_valid = 1; req->mode = mode; req->option_valid = 1; req->option = option; tmp = priv->hw_trc_override; req->hw_trc_disable_override_valid = 1; req->hw_trc_disable_override = (tmp > QMI_PARAM_DISABLE_V01 ? QMI_PARAM_DISABLE_V01 : (tmp < 0 ? QMI_PARAM_INVALID_V01 : tmp)); icnss_pr_dbg("%s: mode %u, option %llu, hw_trc_disable_override: %u", __func__, mode, option, req->hw_trc_disable_override); rc = qmi_txn_init(&priv->qmi, &txn, wlfw_qdss_trace_mode_resp_msg_v01_ei, resp); if (rc < 0) { icnss_qmi_fatal_err("Fail to init txn for QDSS Mode resp %d\n", rc); goto out; } rc = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_QDSS_TRACE_MODE_REQ_V01, WLFW_QDSS_TRACE_MODE_REQ_MSG_V01_MAX_MSG_LEN, wlfw_qdss_trace_mode_req_msg_v01_ei, req); if (rc < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send QDSS Mode req %d\n", rc); goto out; } rc = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (rc < 0) { icnss_qmi_fatal_err("QDSS Mode resp wait failed with rc %d\n", rc); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI QDSS Mode request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); rc = -resp->resp.result; goto out; } out: kfree(resp); kfree(req); return rc; } int wlfw_qdss_trace_start(struct icnss_priv *priv) { return wlfw_send_qdss_trace_mode_req(priv, QMI_WLFW_QDSS_TRACE_ON_V01, 0); } int wlfw_qdss_trace_stop(struct icnss_priv *priv, unsigned long long option) { return wlfw_send_qdss_trace_mode_req(priv, QMI_WLFW_QDSS_TRACE_OFF_V01, option); } int wlfw_wlan_cfg_send_sync_msg(struct icnss_priv *priv, struct wlfw_wlan_cfg_req_msg_v01 *data) { int ret; struct wlfw_wlan_cfg_req_msg_v01 *req; struct wlfw_wlan_cfg_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending config request, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } memcpy(req, data, sizeof(*req)); priv->stats.cfg_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_wlan_cfg_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err("Fail to init txn for Config resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_WLAN_CFG_REQ_V01, WLFW_WLAN_CFG_REQ_MSG_V01_MAX_MSG_LEN, wlfw_wlan_cfg_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send Config req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err("Config resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI Config request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.cfg_resp++; kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.cfg_req_err++; return ret; } int wlfw_send_modem_shutdown_msg(struct icnss_priv *priv) { int ret; struct wlfw_shutdown_req_msg_v01 *req; struct wlfw_shutdown_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; if (test_bit(ICNSS_FW_DOWN, &priv->state)) return -EINVAL; icnss_pr_dbg("Sending modem shutdown request, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->shutdown_valid = 1; req->shutdown = 1; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_shutdown_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for shutdown resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_SHUTDOWN_REQ_V01, WLFW_SHUTDOWN_REQ_MSG_V01_MAX_MSG_LEN, wlfw_shutdown_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send Shutdown req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Shutdown resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QMI modem shutdown request rejected result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } out: kfree(resp); kfree(req); return ret; } int wlfw_ini_send_sync_msg(struct icnss_priv *priv, uint8_t fw_log_mode) { int ret; struct wlfw_ini_req_msg_v01 *req; struct wlfw_ini_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending ini sync request, state: 0x%lx, fw_log_mode: %d\n", priv->state, fw_log_mode); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->enablefwlog_valid = 1; req->enablefwlog = fw_log_mode; priv->stats.ini_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_ini_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err("Fail to init txn for INI resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_INI_REQ_V01, WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN, wlfw_ini_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send INI req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err("INI resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI INI request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.ini_resp++; kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.ini_req_err++; return ret; } int wlfw_athdiag_read_send_sync_msg(struct icnss_priv *priv, uint32_t offset, uint32_t mem_type, uint32_t data_len, uint8_t *data) { int ret; struct wlfw_athdiag_read_req_msg_v01 *req; struct wlfw_athdiag_read_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Diag read: state 0x%lx, offset %x, mem_type %x, data_len %u\n", priv->state, offset, mem_type, data_len); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->offset = offset; req->mem_type = mem_type; req->data_len = data_len; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_athdiag_read_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for Athdiag Read resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_ATHDIAG_READ_REQ_V01, WLFW_ATHDIAG_READ_REQ_MSG_V01_MAX_MSG_LEN, wlfw_athdiag_read_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send Athdiag Read req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Athdaig Read resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QMI Athdiag Read request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } else { ret = 0; } if (!resp->data_valid || resp->data_len < data_len) { icnss_pr_err("Athdiag read data is invalid, data_valid = %u, data_len = %u\n", resp->data_valid, resp->data_len); ret = -EINVAL; goto out; } memcpy(data, resp->data, resp->data_len); out: kfree(resp); kfree(req); return ret; } int wlfw_athdiag_write_send_sync_msg(struct icnss_priv *priv, uint32_t offset, uint32_t mem_type, uint32_t data_len, uint8_t *data) { int ret; struct wlfw_athdiag_write_req_msg_v01 *req; struct wlfw_athdiag_write_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Diag write: state 0x%lx, offset %x, mem_type %x, data_len %u, data %pK\n", priv->state, offset, mem_type, data_len, data); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->offset = offset; req->mem_type = mem_type; req->data_len = data_len; memcpy(req->data, data, data_len); ret = qmi_txn_init(&priv->qmi, &txn, wlfw_athdiag_write_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for Athdiag Write resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_ATHDIAG_WRITE_REQ_V01, WLFW_ATHDIAG_WRITE_REQ_MSG_V01_MAX_MSG_LEN, wlfw_athdiag_write_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send Athdiag Write req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Athdiag Write resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QMI Athdiag Write request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } else { ret = 0; } out: kfree(resp); kfree(req); return ret; } int wlfw_rejuvenate_ack_send_sync_msg(struct icnss_priv *priv) { int ret; struct wlfw_rejuvenate_ack_req_msg_v01 *req; struct wlfw_rejuvenate_ack_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending rejuvenate ack request, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } priv->stats.rejuvenate_ack_req++; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_rejuvenate_ack_resp_msg_v01_ei, resp); if (ret < 0) { icnss_qmi_fatal_err( "Fail to init txn for Rejuvenate Ack resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_REJUVENATE_ACK_REQ_V01, WLFW_REJUVENATE_ACK_REQ_MSG_V01_MAX_MSG_LEN, wlfw_rejuvenate_ack_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_qmi_fatal_err("Fail to send Rejuvenate Ack req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_qmi_fatal_err( "Rejuvenate Ack resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_qmi_fatal_err( "QMI Rejuvenate Ack request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } priv->stats.rejuvenate_ack_resp++; kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); priv->stats.rejuvenate_ack_err++; return ret; } int wlfw_dynamic_feature_mask_send_sync_msg(struct icnss_priv *priv, uint64_t dynamic_feature_mask) { int ret; struct wlfw_dynamic_feature_mask_req_msg_v01 *req; struct wlfw_dynamic_feature_mask_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; if (!test_bit(ICNSS_WLFW_CONNECTED, &priv->state)) { icnss_pr_err("Invalid state for dynamic feature: 0x%lx\n", priv->state); return -EINVAL; } if (!test_bit(FW_REJUVENATE_ENABLE, &priv->ctrl_params.quirks)) { icnss_pr_dbg("FW rejuvenate is disabled from quirks\n"); return 0; } icnss_pr_dbg("Sending dynamic feature mask request, val 0x%llx, state: 0x%lx\n", dynamic_feature_mask, priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->mask_valid = 1; req->mask = dynamic_feature_mask; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_dynamic_feature_mask_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for Dynamic Feature Mask resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_DYNAMIC_FEATURE_MASK_REQ_V01, WLFW_DYNAMIC_FEATURE_MASK_REQ_MSG_V01_MAX_MSG_LEN, wlfw_dynamic_feature_mask_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send Dynamic Feature Mask req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Dynamic Feature Mask resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QMI Dynamic Feature Mask request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } icnss_pr_dbg("prev_mask_valid %u, prev_mask 0x%llx, curr_maks_valid %u, curr_mask 0x%llx\n", resp->prev_mask_valid, resp->prev_mask, resp->curr_mask_valid, resp->curr_mask); out: kfree(resp); kfree(req); return ret; } void icnss_handle_rejuvenate(struct icnss_priv *priv) { struct icnss_event_pd_service_down_data *event_data; struct icnss_uevent_fw_down_data fw_down_data = {0}; event_data = kzalloc(sizeof(*event_data), GFP_KERNEL); if (event_data == NULL) return; event_data->crashed = true; event_data->fw_rejuvenate = true; fw_down_data.crashed = true; set_bit(ICNSS_REJUVENATE, &priv->state); icnss_call_driver_uevent(priv, ICNSS_UEVENT_FW_DOWN, &fw_down_data); icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_PD_SERVICE_DOWN, 0, event_data); } int wlfw_qdss_trace_mem_info_send_sync(struct icnss_priv *priv) { struct wlfw_qdss_trace_mem_info_req_msg_v01 *req; struct wlfw_qdss_trace_mem_info_resp_msg_v01 *resp; struct qmi_txn txn; struct icnss_fw_mem *qdss_mem = priv->qdss_mem; int ret = 0; int i; if (test_bit(ICNSS_FW_DOWN, &priv->state)) return -EINVAL; icnss_pr_dbg("Sending QDSS trace mem info, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->mem_seg_len = priv->qdss_mem_seg_len; if (priv->qdss_mem_seg_len > QMI_WLFW_MAX_NUM_MEM_SEG_V01) { icnss_pr_err("Invalid seg len %u\n", priv->qdss_mem_seg_len); ret = -EINVAL; goto out; } for (i = 0; i < req->mem_seg_len; i++) { icnss_pr_dbg("Memory for FW, va: 0x%pK, pa: %pa, size: 0x%zx, type: %u\n", qdss_mem[i].va, &qdss_mem[i].pa, qdss_mem[i].size, qdss_mem[i].type); req->mem_seg[i].addr = qdss_mem[i].pa; req->mem_seg[i].size = qdss_mem[i].size; req->mem_seg[i].type = qdss_mem[i].type; } ret = qmi_txn_init(&priv->qmi, &txn, wlfw_qdss_trace_mem_info_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to initialize txn for QDSS trace mem request: err %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_QDSS_TRACE_MEM_INFO_REQ_V01, WLFW_QDSS_TRACE_MEM_INFO_REQ_MSG_V01_MAX_MSG_LEN, wlfw_qdss_trace_mem_info_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send QDSS trace mem info request: err %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Fail to wait for response of QDSS trace mem info request, err %d\n", ret); goto out; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QDSS trace mem info request failed, result: %d, err: %d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } kfree(req); kfree(resp); return 0; out: kfree(req); kfree(resp); return ret; } int icnss_wlfw_m3_dump_upload_done_send_sync(struct icnss_priv *priv, u32 pdev_id, int status) { struct wlfw_m3_dump_upload_done_req_msg_v01 *req; struct wlfw_m3_dump_upload_done_resp_msg_v01 *resp; struct qmi_txn txn; int ret = 0; req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } icnss_pr_dbg("Sending M3 Upload done req, pdev %d, status %d\n", pdev_id, status); req->pdev_id = pdev_id; req->status = status; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_m3_dump_upload_done_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to initialize txn for M3 dump upload done req: err %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_M3_DUMP_UPLOAD_DONE_REQ_V01, WLFW_M3_DUMP_UPLOAD_DONE_REQ_MSG_V01_MAX_MSG_LEN, wlfw_m3_dump_upload_done_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send M3 dump upload done request: err %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Fail to wait for response of M3 dump upload done request, err %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("M3 Dump Upload Done Req failed, result: %d, err: 0x%X\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } out: kfree(req); kfree(resp); return ret; } static void fw_ready_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); icnss_pr_dbg("Received FW Ready Indication\n"); if (!txn) { pr_err("spurious indication\n"); return; } icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_FW_READY_IND, 0, NULL); } static void msa_ready_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); struct device *dev = &priv->pdev->dev; const struct wlfw_msa_ready_ind_msg_v01 *ind_msg = data; uint64_t msa_base_addr = priv->msa_pa; phys_addr_t hang_data_phy_addr; icnss_pr_dbg("Received MSA Ready Indication\n"); if (!txn) { pr_err("spurious indication\n"); return; } priv->stats.msa_ready_ind++; /* Check if the length is valid & * the length should not be 0 and * should be <= WLFW_MAX_HANG_EVENT_DATA_SIZE(400) */ if (ind_msg->hang_data_length_valid && ind_msg->hang_data_length && ind_msg->hang_data_length <= WLFW_MAX_HANG_EVENT_DATA_SIZE) priv->hang_event_data_len = ind_msg->hang_data_length; else goto out; /* Check if the offset is valid & * the offset should be in range of 0 to msa_mem_size-hang_data_length */ if (ind_msg->hang_data_addr_offset_valid && (ind_msg->hang_data_addr_offset <= (priv->msa_mem_size - ind_msg->hang_data_length))) hang_data_phy_addr = msa_base_addr + ind_msg->hang_data_addr_offset; else goto out; if (priv->hang_event_data_pa == hang_data_phy_addr) goto exit; priv->hang_event_data_pa = hang_data_phy_addr; priv->hang_event_data_va = devm_ioremap(dev, priv->hang_event_data_pa, ind_msg->hang_data_length); if (!priv->hang_event_data_va) { icnss_pr_err("Hang Data ioremap failed: phy addr: %pa\n", &priv->hang_event_data_pa); goto fail; } exit: icnss_pr_dbg("Hang Event Data details,Offset:0x%x, Length:0x%x,va_addr: 0x%pK\n", ind_msg->hang_data_addr_offset, ind_msg->hang_data_length, priv->hang_event_data_va); return; out: icnss_pr_err("Invalid Hang Data details, Offset:0x%x, Length:0x%x", ind_msg->hang_data_addr_offset, ind_msg->hang_data_length); fail: priv->hang_event_data_va = NULL; priv->hang_event_data_pa = 0; priv->hang_event_data_len = 0; } static void pin_connect_result_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_pin_connect_result_ind_msg_v01 *ind_msg = data; icnss_pr_dbg("Received Pin Connect Result Indication\n"); if (!txn) { pr_err("spurious indication\n"); return; } if (ind_msg->pwr_pin_result_valid) priv->pwr_pin_result = ind_msg->pwr_pin_result; if (ind_msg->phy_io_pin_result_valid) priv->phy_io_pin_result = ind_msg->phy_io_pin_result; if (ind_msg->rf_pin_result_valid) priv->rf_pin_result = ind_msg->rf_pin_result; icnss_pr_dbg("Pin connect Result: pwr_pin: 0x%x phy_io_pin: 0x%x rf_io_pin: 0x%x\n", ind_msg->pwr_pin_result, ind_msg->phy_io_pin_result, ind_msg->rf_pin_result); priv->stats.pin_connect_result++; } static void rejuvenate_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_rejuvenate_ind_msg_v01 *ind_msg = data; icnss_pr_dbg("Received Rejuvenate Indication\n"); if (!txn) { pr_err("spurious indication\n"); return; } icnss_ignore_fw_timeout(true); if (ind_msg->cause_for_rejuvenation_valid) priv->cause_for_rejuvenation = ind_msg->cause_for_rejuvenation; else priv->cause_for_rejuvenation = 0; if (ind_msg->requesting_sub_system_valid) priv->requesting_sub_system = ind_msg->requesting_sub_system; else priv->requesting_sub_system = 0; if (ind_msg->line_number_valid) priv->line_number = ind_msg->line_number; else priv->line_number = 0; if (ind_msg->function_name_valid) memcpy(priv->function_name, ind_msg->function_name, QMI_WLFW_FUNCTION_NAME_LEN_V01 + 1); else memset(priv->function_name, 0, QMI_WLFW_FUNCTION_NAME_LEN_V01 + 1); icnss_pr_info("Cause for rejuvenation: 0x%x, requesting sub-system: 0x%x, line number: %u, function name: %s\n", priv->cause_for_rejuvenation, priv->requesting_sub_system, priv->line_number, priv->function_name); priv->stats.rejuvenate_ind++; icnss_handle_rejuvenate(priv); } static void cal_done_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); icnss_pr_dbg("Received QMI WLFW calibration done indication\n"); if (!txn) { icnss_pr_err("Spurious indication\n"); return; } priv->cal_done = true; clear_bit(ICNSS_COLD_BOOT_CAL, &priv->state); } static void fw_init_done_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); struct device *dev = &priv->pdev->dev; const struct wlfw_fw_init_done_ind_msg_v01 *ind_msg = data; uint64_t msa_base_addr = priv->msa_pa; phys_addr_t hang_data_phy_addr; icnss_pr_dbg("Received QMI WLFW FW initialization done indication\n"); if (!txn) { icnss_pr_err("Spurious indication\n"); return; } /* Check if the length is valid & * the length should not be 0 and * should be <= WLFW_MAX_HANG_EVENT_DATA_SIZE(400) */ if (ind_msg->hang_data_length_valid && ind_msg->hang_data_length && ind_msg->hang_data_length <= WLFW_MAX_HANG_EVENT_DATA_SIZE) priv->hang_event_data_len = ind_msg->hang_data_length; else goto out; /* Check if the offset is valid & * the offset should be in range of 0 to msa_mem_size-hang_data_length */ if (ind_msg->hang_data_addr_offset_valid && (ind_msg->hang_data_addr_offset <= (priv->msa_mem_size - ind_msg->hang_data_length))) hang_data_phy_addr = msa_base_addr + ind_msg->hang_data_addr_offset; else goto out; if (priv->hang_event_data_pa == hang_data_phy_addr) goto exit; priv->hang_event_data_pa = hang_data_phy_addr; priv->hang_event_data_va = devm_ioremap(dev, priv->hang_event_data_pa, ind_msg->hang_data_length); if (!priv->hang_event_data_va) { icnss_pr_err("Hang Data ioremap failed: phy addr: %pa\n", &priv->hang_event_data_pa); goto fail; } exit: icnss_pr_dbg("Hang Event Data details,Offset:0x%x, Length:0x%x,va_addr: 0x%pK\n", ind_msg->hang_data_addr_offset, ind_msg->hang_data_length, priv->hang_event_data_va); goto post; out: icnss_pr_err("Invalid Hang Data details, Offset:0x%x, Length:0x%x", ind_msg->hang_data_addr_offset, ind_msg->hang_data_length); fail: priv->hang_event_data_va = NULL; priv->hang_event_data_pa = 0; priv->hang_event_data_len = 0; post: icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_FW_INIT_DONE_IND, 0, NULL); } static void wlfw_qdss_trace_req_mem_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_qdss_trace_req_mem_ind_msg_v01 *ind_msg = data; int i; icnss_pr_dbg("Received QMI WLFW QDSS trace request mem indication\n"); if (!txn) { icnss_pr_err("Spurious indication\n"); return; } if (priv->qdss_mem_seg_len) { icnss_pr_err("Ignore double allocation for QDSS trace, current len %u\n", priv->qdss_mem_seg_len); return; } priv->qdss_mem_seg_len = ind_msg->mem_seg_len; if (priv->qdss_mem_seg_len > QMI_WLFW_MAX_NUM_MEM_SEG_V01) { icnss_pr_err("Invalid seg len %u\n", priv->qdss_mem_seg_len); return; } for (i = 0; i < priv->qdss_mem_seg_len; i++) { icnss_pr_dbg("QDSS requests for memory, size: 0x%x, type: %u\n", ind_msg->mem_seg[i].size, ind_msg->mem_seg[i].type); priv->qdss_mem[i].type = ind_msg->mem_seg[i].type; priv->qdss_mem[i].size = ind_msg->mem_seg[i].size; } icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM, 0, NULL); } static void wlfw_qdss_trace_save_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_qdss_trace_save_ind_msg_v01 *ind_msg = data; struct icnss_qmi_event_qdss_trace_save_data *event_data; int i = 0; icnss_pr_dbg("Received QMI WLFW QDSS trace save indication\n"); if (!txn) { icnss_pr_err("Spurious indication\n"); return; } icnss_pr_dbg("QDSS_trace_save info: source %u, total_size %u, file_name_valid %u, file_name %s\n", ind_msg->source, ind_msg->total_size, ind_msg->file_name_valid, ind_msg->file_name); event_data = kzalloc(sizeof(*event_data), GFP_KERNEL); if (!event_data) return; if (ind_msg->mem_seg_valid) { if (ind_msg->mem_seg_len > QDSS_TRACE_SEG_LEN_MAX) { icnss_pr_err("Invalid seg len %u\n", ind_msg->mem_seg_len); goto free_event_data; } icnss_pr_dbg("QDSS_trace_save seg len %u\n", ind_msg->mem_seg_len); event_data->mem_seg_len = ind_msg->mem_seg_len; for (i = 0; i < ind_msg->mem_seg_len; i++) { event_data->mem_seg[i].addr = ind_msg->mem_seg[i].addr; event_data->mem_seg[i].size = ind_msg->mem_seg[i].size; icnss_pr_dbg("seg-%d: addr 0x%llx size 0x%x\n", i, ind_msg->mem_seg[i].addr, ind_msg->mem_seg[i].size); } } event_data->total_size = ind_msg->total_size; if (ind_msg->file_name_valid) strlcpy(event_data->file_name, ind_msg->file_name, QDSS_TRACE_FILE_NAME_MAX + 1); if (ind_msg->source == 1) { if (!ind_msg->file_name_valid) strlcpy(event_data->file_name, "qdss_trace_wcss_etb", QDSS_TRACE_FILE_NAME_MAX + 1); icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_REQ_DATA, 0, event_data); } else { if (!ind_msg->file_name_valid) strlcpy(event_data->file_name, "qdss_trace_ddr", QDSS_TRACE_FILE_NAME_MAX + 1); icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_SAVE, 0, event_data); } return; free_event_data: kfree(event_data); } static void wlfw_qdss_trace_free_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_QDSS_TRACE_FREE, 0, NULL); } static void icnss_wlfw_respond_get_info_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_respond_get_info_ind_msg_v01 *ind_msg = data; if (!txn) { icnss_pr_err("Spurious indication\n"); return; } icnss_pr_vdbg("Extract message with event length: %d, type: %d, is last: %d, seq no: %d\n", ind_msg->data_len, ind_msg->type, ind_msg->is_last, ind_msg->seq_no); if (priv->get_info_cb_ctx && priv->get_info_cb) priv->get_info_cb(priv->get_info_cb_ctx, (void *)ind_msg->data, ind_msg->data_len); } static void icnss_wlfw_m3_dump_upload_segs_req_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *d) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_m3_dump_upload_segments_req_ind_msg_v01 *ind_msg = d; struct icnss_m3_upload_segments_req_data *event_data = NULL; u64 max_mapped_addr = 0; u64 segment_addr = 0; int i = 0; icnss_pr_dbg("Received QMI WLFW M3 dump upload sigments indication\n"); if (!txn) { icnss_pr_err("Spurious indication\n"); return; } icnss_pr_dbg("M3 Dump upload info: pdev_id: %d no_of_segments: %d\n", ind_msg->pdev_id, ind_msg->no_of_valid_segments); if (ind_msg->no_of_valid_segments > QMI_WLFW_MAX_M3_SEGMENTS_SIZE_V01) return; event_data = kzalloc(sizeof(*event_data), GFP_KERNEL); if (!event_data) return; event_data->pdev_id = ind_msg->pdev_id; event_data->no_of_valid_segments = ind_msg->no_of_valid_segments; max_mapped_addr = priv->msa_pa + priv->msa_mem_size; for (i = 0; i < ind_msg->no_of_valid_segments; i++) { segment_addr = ind_msg->m3_segment[i].addr & M3_SEGMENT_ADDR_MASK; if (ind_msg->m3_segment[i].size > priv->msa_mem_size || segment_addr >= max_mapped_addr || segment_addr < priv->msa_pa || ind_msg->m3_segment[i].size + segment_addr > max_mapped_addr) { icnss_pr_dbg("Received out of range Segment %d Addr: 0x%llx Size: 0x%x, Name: %s, type: %d\n", (i + 1), segment_addr, ind_msg->m3_segment[i].size, ind_msg->m3_segment[i].name, ind_msg->m3_segment[i].type); goto out; } event_data->m3_segment[i].addr = segment_addr; event_data->m3_segment[i].size = ind_msg->m3_segment[i].size; event_data->m3_segment[i].type = ind_msg->m3_segment[i].type; strlcpy(event_data->m3_segment[i].name, ind_msg->m3_segment[i].name, WLFW_MAX_STR_LEN + 1); icnss_pr_dbg("Received Segment %d Addr: 0x%llx Size: 0x%x, Name: %s, type: %d\n", (i + 1), segment_addr, ind_msg->m3_segment[i].size, ind_msg->m3_segment[i].name, ind_msg->m3_segment[i].type); } icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_M3_DUMP_UPLOAD_REQ, 0, event_data); return; out: kfree(event_data); } static int icnss_wlfw_wfc_call_status_send_sync (struct icnss_priv *priv, const struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg) { struct wlfw_wfc_call_status_req_msg_v01 *req; struct wlfw_wfc_call_status_resp_msg_v01 *resp; struct qmi_txn txn; int ret = 0; if (!test_bit(ICNSS_FW_READY, &priv->state) || !test_bit(ICNSS_MODE_ON, &priv->state)) { icnss_pr_err("Drop IMS WFC indication as FW not initialized\n"); return -EINVAL; } req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } /** * WFC Call r1 design has CNSS as pass thru using opaque hex buffer. * But in r2 update QMI structure is expanded and as an effect qmi * decoded structures have padding. Thus we cannot use buffer design. * For backward compatibility for r1 design copy only wfc_call_active * value in hex buffer. */ req->wfc_call_status_len = sizeof(ind_msg->wfc_call_active); req->wfc_call_status[0] = ind_msg->wfc_call_active; /* wfc_call_active is mandatory in IMS indication */ req->wfc_call_active_valid = 1; req->wfc_call_active = ind_msg->wfc_call_active; req->all_wfc_calls_held_valid = ind_msg->all_wfc_calls_held_valid; req->all_wfc_calls_held = ind_msg->all_wfc_calls_held; req->is_wfc_emergency_valid = ind_msg->is_wfc_emergency_valid; req->is_wfc_emergency = ind_msg->is_wfc_emergency; req->twt_ims_start_valid = ind_msg->twt_ims_start_valid; req->twt_ims_start = ind_msg->twt_ims_start; req->twt_ims_int_valid = ind_msg->twt_ims_int_valid; req->twt_ims_int = ind_msg->twt_ims_int; req->media_quality_valid = ind_msg->media_quality_valid; req->media_quality = (enum wlfw_wfc_media_quality_v01)ind_msg->media_quality; icnss_pr_dbg("CNSS->FW: WFC_CALL_REQ: state: 0x%lx\n", priv->state); ret = qmi_txn_init(&priv->qmi, &txn, wlfw_wfc_call_status_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Txn Init: Err %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_WFC_CALL_STATUS_REQ_V01, WLFW_WFC_CALL_STATUS_REQ_MSG_V01_MAX_MSG_LEN, wlfw_wfc_call_status_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Send Err: %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("FW->CNSS: WFC_CALL_RSP: QMI Wait Err: %d\n", ret); goto out; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("FW->CNSS: WFC_CALL_RSP: Result: %d Err: %d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } ret = 0; out: kfree(req); kfree(resp); return ret; } static int icnss_ims_wfc_call_twt_cfg_send_sync (struct icnss_priv *priv, const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg) { struct ims_private_service_wfc_call_twt_config_req_msg_v01 *req; struct ims_private_service_wfc_call_twt_config_rsp_msg_v01 *resp; struct qmi_txn txn; int ret = 0; if (!test_bit(ICNSS_IMS_CONNECTED, &priv->state)) { icnss_pr_err("Drop FW WFC indication as IMS QMI not connected\n"); return -EINVAL; } req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->twt_sta_start_valid = ind_msg->twt_sta_start_valid; req->twt_sta_start = ind_msg->twt_sta_start; req->twt_sta_int_valid = ind_msg->twt_sta_int_valid; req->twt_sta_int = ind_msg->twt_sta_int; req->twt_sta_upo_valid = ind_msg->twt_sta_upo_valid; req->twt_sta_upo = ind_msg->twt_sta_upo; req->twt_sta_sp_valid = ind_msg->twt_sta_sp_valid; req->twt_sta_sp = ind_msg->twt_sta_sp; req->twt_sta_dl_valid = req->twt_sta_dl_valid; req->twt_sta_dl = req->twt_sta_dl; req->twt_sta_config_changed_valid = ind_msg->twt_sta_config_changed_valid; req->twt_sta_config_changed = ind_msg->twt_sta_config_changed; icnss_pr_dbg("CNSS->IMS: TWT_CFG_REQ: state: 0x%lx\n", priv->state); ret = qmi_txn_init(&priv->ims_qmi, &txn, ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Txn Init Err: %d\n", ret); goto out; } ret = qmi_send_request(&priv->ims_qmi, NULL, &txn, QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_V01, IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_MSG_V01_MAX_MSG_LEN, ims_private_service_wfc_call_twt_config_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Send Err: %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("IMS->CNSS: TWT_CFG_RSP: QMI Wait Err: %d\n", ret); goto out; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("IMS->CNSS: TWT_CFG_RSP: Result: %d Err: %d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } ret = 0; out: kfree(req); kfree(resp); return ret; } int icnss_process_twt_cfg_ind_event(struct icnss_priv *priv, void *data) { int ret; struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg = data; ret = icnss_ims_wfc_call_twt_cfg_send_sync(priv, ind_msg); kfree(data); return ret; } static void icnss_wlfw_process_twt_cfg_ind(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg = data; struct wlfw_wfc_call_twt_config_ind_msg_v01 *event_data; if (!txn) { icnss_pr_err("FW->CNSS: TWT_CFG_IND: Spurious indication\n"); return; } if (!ind_msg) { icnss_pr_err("FW->CNSS: TWT_CFG_IND: Invalid indication\n"); return; } icnss_pr_dbg("FW->CNSS: TWT_CFG_IND: %x %llx, %x %x, %x %x, %x %x, %x %x, %x %x\n", ind_msg->twt_sta_start_valid, ind_msg->twt_sta_start, ind_msg->twt_sta_int_valid, ind_msg->twt_sta_int, ind_msg->twt_sta_upo_valid, ind_msg->twt_sta_upo, ind_msg->twt_sta_sp_valid, ind_msg->twt_sta_sp, ind_msg->twt_sta_dl_valid, ind_msg->twt_sta_dl, ind_msg->twt_sta_config_changed_valid, ind_msg->twt_sta_config_changed); event_data = kmemdup(ind_msg, sizeof(*event_data), GFP_KERNEL); if (!event_data) return; icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_WLFW_TWT_CFG_IND, 0, event_data); } static struct qmi_msg_handler wlfw_msg_handlers[] = { { .type = QMI_INDICATION, .msg_id = QMI_WLFW_FW_READY_IND_V01, .ei = wlfw_fw_ready_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_fw_ready_ind_msg_v01), .fn = fw_ready_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_MSA_READY_IND_V01, .ei = wlfw_msa_ready_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_msa_ready_ind_msg_v01), .fn = msa_ready_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_PIN_CONNECT_RESULT_IND_V01, .ei = wlfw_pin_connect_result_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_pin_connect_result_ind_msg_v01), .fn = pin_connect_result_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_REJUVENATE_IND_V01, .ei = wlfw_rejuvenate_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_rejuvenate_ind_msg_v01), .fn = rejuvenate_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_CAL_DONE_IND_V01, .ei = wlfw_cal_done_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_cal_done_ind_msg_v01), .fn = cal_done_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_FW_INIT_DONE_IND_V01, .ei = wlfw_fw_init_done_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_fw_init_done_ind_msg_v01), .fn = fw_init_done_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_QDSS_TRACE_REQ_MEM_IND_V01, .ei = wlfw_qdss_trace_req_mem_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_qdss_trace_req_mem_ind_msg_v01), .fn = wlfw_qdss_trace_req_mem_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_QDSS_TRACE_SAVE_IND_V01, .ei = wlfw_qdss_trace_save_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_qdss_trace_save_ind_msg_v01), .fn = wlfw_qdss_trace_save_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_QDSS_TRACE_FREE_IND_V01, .ei = wlfw_qdss_trace_free_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_qdss_trace_free_ind_msg_v01), .fn = wlfw_qdss_trace_free_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_RESPOND_GET_INFO_IND_V01, .ei = wlfw_respond_get_info_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_respond_get_info_ind_msg_v01), .fn = icnss_wlfw_respond_get_info_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_M3_DUMP_UPLOAD_SEGMENTS_REQ_IND_V01, .ei = wlfw_m3_dump_upload_segments_req_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_m3_dump_upload_segments_req_ind_msg_v01), .fn = icnss_wlfw_m3_dump_upload_segs_req_ind_cb }, { .type = QMI_INDICATION, .msg_id = QMI_WLFW_WFC_CALL_TWT_CONFIG_IND_V01, .ei = wlfw_wfc_call_twt_config_ind_msg_v01_ei, .decoded_size = sizeof(struct wlfw_wfc_call_twt_config_ind_msg_v01), .fn = icnss_wlfw_process_twt_cfg_ind }, {} }; int icnss_connect_to_fw_server(struct icnss_priv *priv, void *data) { struct icnss_event_server_arrive_data *event_data = data; struct qmi_handle *qmi = &priv->qmi; struct sockaddr_qrtr sq = { 0 }; int ret = 0; if (!priv) { ret = -ENODEV; goto out; } sq.sq_family = AF_QIPCRTR; sq.sq_node = event_data->node; sq.sq_port = event_data->port; ret = kernel_connect(qmi->sock, (struct sockaddr *)&sq, sizeof(sq), 0); if (ret < 0) { icnss_pr_err("Fail to connect to remote service port\n"); goto out; } icnss_pr_info("QMI Server Connected: state: 0x%lx\n", priv->state); kfree(data); return 0; out: kfree(data); ICNSS_ASSERT(0); return ret; } int icnss_clear_server(struct icnss_priv *priv) { int ret; if (!priv) return -ENODEV; icnss_pr_info("QMI Service Disconnected: 0x%lx\n", priv->state); clear_bit(ICNSS_WLFW_CONNECTED, &priv->state); icnss_unregister_fw_service(priv); clear_bit(ICNSS_DEL_SERVER, &priv->state); ret = icnss_register_fw_service(priv); if (ret < 0) { icnss_pr_err("WLFW server registration failed\n"); ICNSS_ASSERT(0); } return 0; } static int wlfw_new_server(struct qmi_handle *qmi, struct qmi_service *service) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); struct icnss_event_server_arrive_data *event_data; if (priv && test_bit(ICNSS_DEL_SERVER, &priv->state)) { icnss_pr_info("WLFW server delete in progress, Ignore server arrive: 0x%lx\n", priv->state); return 0; } icnss_pr_dbg("WLFW server arrive: node %u port %u\n", service->node, service->port); event_data = kzalloc(sizeof(*event_data), GFP_KERNEL); if (event_data == NULL) return -ENOMEM; event_data->node = service->node; event_data->port = service->port; icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_SERVER_ARRIVE, 0, event_data); return 0; } static void wlfw_del_server(struct qmi_handle *qmi, struct qmi_service *service) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, qmi); if (priv && test_bit(ICNSS_DEL_SERVER, &priv->state)) { icnss_pr_info("WLFW server delete / icnss remove in progress, Ignore server delete: 0x%lx\n", priv->state); return; } icnss_pr_dbg("WLFW server delete\n"); if (priv) { set_bit(ICNSS_DEL_SERVER, &priv->state); set_bit(ICNSS_FW_DOWN, &priv->state); icnss_ignore_fw_timeout(true); } icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_SERVER_EXIT, 0, NULL); } static struct qmi_ops wlfw_qmi_ops = { .new_server = wlfw_new_server, .del_server = wlfw_del_server, }; int icnss_register_fw_service(struct icnss_priv *priv) { int ret; ret = qmi_handle_init(&priv->qmi, WLFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN, &wlfw_qmi_ops, wlfw_msg_handlers); if (ret < 0) return ret; if (priv->device_id == WCN6750_DEVICE_ID || priv->device_id == WCN6450_DEVICE_ID) ret = qmi_add_lookup(&priv->qmi, WLFW_SERVICE_ID_V01, WLFW_SERVICE_VERS_V01, WLFW_SERVICE_WCN_INS_ID_V01); else ret = qmi_add_lookup(&priv->qmi, WLFW_SERVICE_ID_V01, WLFW_SERVICE_VERS_V01, WLFW_SERVICE_INS_ID_V01); return ret; } void icnss_unregister_fw_service(struct icnss_priv *priv) { set_bit(ICNSS_DEL_SERVER, &priv->state); qmi_handle_release(&priv->qmi); } int icnss_send_wlan_enable_to_fw(struct icnss_priv *priv, struct icnss_wlan_enable_cfg *config, enum icnss_driver_mode mode, const char *host_version) { struct wlfw_wlan_cfg_req_msg_v01 req; u32 i; int ret; icnss_pr_dbg("Mode: %d, config: %pK, host_version: %s\n", mode, config, host_version); memset(&req, 0, sizeof(req)); if (mode == ICNSS_WALTEST || mode == ICNSS_CCPM) goto skip; if (!config || !host_version) { icnss_pr_err("Invalid cfg pointer, config: %pK, host_version: %pK\n", config, host_version); ret = -EINVAL; goto out; } req.host_version_valid = 1; strlcpy(req.host_version, host_version, WLFW_MAX_STR_LEN + 1); req.tgt_cfg_valid = 1; if (config->num_ce_tgt_cfg > WLFW_MAX_NUM_CE) req.tgt_cfg_len = WLFW_MAX_NUM_CE; else req.tgt_cfg_len = config->num_ce_tgt_cfg; for (i = 0; i < req.tgt_cfg_len; i++) { req.tgt_cfg[i].pipe_num = config->ce_tgt_cfg[i].pipe_num; req.tgt_cfg[i].pipe_dir = config->ce_tgt_cfg[i].pipe_dir; req.tgt_cfg[i].nentries = config->ce_tgt_cfg[i].nentries; req.tgt_cfg[i].nbytes_max = config->ce_tgt_cfg[i].nbytes_max; req.tgt_cfg[i].flags = config->ce_tgt_cfg[i].flags; } req.svc_cfg_valid = 1; if (config->num_ce_svc_pipe_cfg > WLFW_MAX_NUM_SVC) req.svc_cfg_len = WLFW_MAX_NUM_SVC; else req.svc_cfg_len = config->num_ce_svc_pipe_cfg; for (i = 0; i < req.svc_cfg_len; i++) { req.svc_cfg[i].service_id = config->ce_svc_cfg[i].service_id; req.svc_cfg[i].pipe_dir = config->ce_svc_cfg[i].pipe_dir; req.svc_cfg[i].pipe_num = config->ce_svc_cfg[i].pipe_num; } if (priv->device_id == WCN6750_DEVICE_ID) { req.shadow_reg_v2_valid = 1; if (config->num_shadow_reg_v2_cfg > QMI_WLFW_MAX_NUM_SHADOW_REG_V2_V01) req.shadow_reg_v2_len = QMI_WLFW_MAX_NUM_SHADOW_REG_V2_V01; else req.shadow_reg_v2_len = config->num_shadow_reg_v2_cfg; memcpy(req.shadow_reg_v2, config->shadow_reg_v2_cfg, sizeof(struct wlfw_shadow_reg_v2_cfg_s_v01) * req.shadow_reg_v2_len); } else if (priv->device_id == ADRASTEA_DEVICE_ID) { req.shadow_reg_valid = 1; if (config->num_shadow_reg_cfg > QMI_WLFW_MAX_NUM_SHADOW_REG_V01) req.shadow_reg_len = QMI_WLFW_MAX_NUM_SHADOW_REG_V01; else req.shadow_reg_len = config->num_shadow_reg_cfg; memcpy(req.shadow_reg, config->shadow_reg_cfg, sizeof(struct wlfw_msi_cfg_s_v01) * req.shadow_reg_len); } else if (priv->device_id == WCN6450_DEVICE_ID) { req.shadow_reg_v3_valid = 1; if (config->num_shadow_reg_v3_cfg > MAX_NUM_SHADOW_REG_V3) req.shadow_reg_v3_len = MAX_NUM_SHADOW_REG_V3; else req.shadow_reg_v3_len = config->num_shadow_reg_v3_cfg; memcpy(req.shadow_reg_v3, config->shadow_reg_v3_cfg, sizeof(struct wlfw_shadow_reg_v3_cfg_s_v01) * req.shadow_reg_v3_len); } ret = wlfw_wlan_cfg_send_sync_msg(priv, &req); if (ret) goto out; skip: ret = wlfw_wlan_mode_send_sync_msg(priv, (enum wlfw_driver_mode_enum_v01)mode); out: if (test_bit(SKIP_QMI, &priv->ctrl_params.quirks)) ret = 0; return ret; } int icnss_send_wlan_disable_to_fw(struct icnss_priv *priv) { enum wlfw_driver_mode_enum_v01 mode = QMI_WLFW_OFF_V01; return wlfw_wlan_mode_send_sync_msg(priv, mode); } #ifdef CONFIG_ICNSS2_DEBUG static inline u32 icnss_get_host_build_type(void) { return QMI_HOST_BUILD_TYPE_PRIMARY_V01; } #else static inline u32 icnss_get_host_build_type(void) { return QMI_HOST_BUILD_TYPE_SECONDARY_V01; } #endif int wlfw_host_cap_send_sync(struct icnss_priv *priv) { struct wlfw_host_cap_req_msg_v01 *req; struct wlfw_host_cap_resp_msg_v01 *resp; struct qmi_txn txn; int ddr_type; u32 gpio; int ret = 0; u64 iova_start = 0, iova_size = 0, iova_ipa_start = 0, iova_ipa_size = 0; icnss_pr_dbg("Sending host capability message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->num_clients_valid = 1; req->num_clients = 1; req->bdf_support_valid = 1; req->bdf_support = 1; req->cal_done_valid = 1; req->cal_done = priv->cal_done; icnss_pr_dbg("Calibration done is %d\n", priv->cal_done); if (priv->smmu_s1_enable && !icnss_get_iova(priv, &iova_start, &iova_size) && !icnss_get_iova_ipa(priv, &iova_ipa_start, &iova_ipa_size)) { req->ddr_range_valid = 1; req->ddr_range[0].start = iova_start; req->ddr_range[0].size = iova_size + iova_ipa_size; req->ddr_range[1].start = priv->msa_pa; req->ddr_range[1].size = priv->msa_mem_size; icnss_pr_dbg("Sending iova starting 0x%llx with size 0x%llx\n", req->ddr_range[0].start, req->ddr_range[0].size); icnss_pr_dbg("Sending msa starting 0x%llx with size 0x%llx\n", req->ddr_range[1].start, req->ddr_range[1].size); } req->host_build_type_valid = 1; req->host_build_type = icnss_get_host_build_type(); if (priv->wlan_en_delay_ms >= 100) { icnss_pr_dbg("Setting WLAN_EN delay: %d ms\n", priv->wlan_en_delay_ms); req->wlan_enable_delay_valid = 1; req->wlan_enable_delay = priv->wlan_en_delay_ms; } /* ddr_type = 7(LPDDR4) and 8(LPDDR5) */ ddr_type = of_fdt_get_ddrtype(); if (ddr_type > 0) { icnss_pr_dbg("DDR Type: %d\n", ddr_type); req->ddr_type_valid = 1; req->ddr_type = ddr_type; } ret = of_property_read_u32(priv->pdev->dev.of_node, "wlan-en-gpio", &gpio); if (!ret) { icnss_pr_dbg("WLAN_EN_GPIO modified through DT: %d\n", gpio); req->gpio_info_valid = 1; req->gpio_info[WLAN_EN_GPIO_V01] = gpio; } else { req->gpio_info[WLAN_EN_GPIO_V01] = 0xFFFF; } ret = of_property_read_u32(priv->pdev->dev.of_node, "bt-en-gpio", &gpio); if (!ret) { icnss_pr_dbg("BT_EN_GPIO modified through DT: %d\n", gpio); req->gpio_info_valid = 1; req->gpio_info[BT_EN_GPIO_V01] = gpio; } else { req->gpio_info[BT_EN_GPIO_V01] = 0xFFFF; } ret = of_property_read_u32(priv->pdev->dev.of_node, "host-sol-gpio", &gpio); if (!ret) { icnss_pr_dbg("HOST_SOL_GPIO modified through DT: %d\n", gpio); req->gpio_info_valid = 1; req->gpio_info[HOST_SOL_GPIO_V01] = gpio; } else { req->gpio_info[HOST_SOL_GPIO_V01] = 0xFFFF; } ret = of_property_read_u32(priv->pdev->dev.of_node, "target-sol-gpio", &gpio); if (!ret) { icnss_pr_dbg("TARGET_SOL_GPIO modified through DT: %d\n", gpio); req->gpio_info_valid = 1; req->gpio_info[TARGET_SOL_GPIO_V01] = gpio; } else { req->gpio_info[TARGET_SOL_GPIO_V01] = 0xFFFF; } req->gpio_info_len = GPIO_TYPE_MAX_V01; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_host_cap_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Failed to initialize txn for host capability request, err: %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_HOST_CAP_REQ_V01, WLFW_HOST_CAP_REQ_MSG_V01_MAX_MSG_LEN, wlfw_host_cap_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Failed to send host capability request, err: %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Failed to wait for response of host capability request, err: %d\n", ret); goto out; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("Host capability request failed, result: %d, err: %d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } kfree(req); kfree(resp); return 0; out: ICNSS_QMI_ASSERT(); kfree(req); kfree(resp); return ret; } int icnss_wlfw_get_info_send_sync(struct icnss_priv *plat_priv, int type, void *cmd, int cmd_len) { struct wlfw_get_info_req_msg_v01 *req; struct wlfw_get_info_resp_msg_v01 *resp; struct qmi_txn txn; int ret = 0; int flags = GFP_KERNEL & ~__GFP_DIRECT_RECLAIM; if (cmd_len > QMI_WLFW_MAX_DATA_SIZE_V01) return -EINVAL; if (test_bit(ICNSS_FW_DOWN, &plat_priv->state)) return -EINVAL; req = kzalloc(sizeof(*req), flags); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), flags); if (!resp) { kfree(req); return -ENOMEM; } req->type = type; req->data_len = cmd_len; memcpy(req->data, cmd, req->data_len); ret = qmi_txn_init(&plat_priv->qmi, &txn, wlfw_get_info_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Failed to initialize txn for get info request, err: %d\n", ret); goto out; } ret = qmi_send_request(&plat_priv->qmi, NULL, &txn, QMI_WLFW_GET_INFO_REQ_V01, WLFW_GET_INFO_REQ_MSG_V01_MAX_MSG_LEN, wlfw_get_info_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Failed to send get info request, err: %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, plat_priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Failed to wait for response of get info request, err: %d\n", ret); goto out; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("Get info request failed, result: %d, err: %d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } kfree(req); kfree(resp); return 0; out: kfree(req); kfree(resp); return ret; } int wlfw_subsys_restart_level_msg(struct icnss_priv *penv, uint8_t restart_level) { int ret; struct wlfw_subsys_restart_level_req_msg_v01 *req; struct wlfw_subsys_restart_level_resp_msg_v01 *resp; struct qmi_txn txn; if (!penv) return -ENODEV; if (test_bit(ICNSS_FW_DOWN, &penv->state)) return -EINVAL; icnss_pr_dbg("Sending subsystem restart level: 0x%x\n", restart_level); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->restart_level_type_valid = 1; req->restart_level_type = restart_level; penv->stats.restart_level_req++; ret = qmi_txn_init(&penv->qmi, &txn, wlfw_subsys_restart_level_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for subsystem restart level, resp %d\n", ret); goto out; } ret = qmi_send_request(&penv->qmi, NULL, &txn, QMI_WLFW_SUBSYS_RESTART_LEVEL_REQ_V01, WLFW_SUBSYS_RESTART_LEVEL_REQ_MSG_V01_MAX_MSG_LEN, wlfw_subsys_restart_level_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send subsystem restart level %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, penv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("Subsystem restart level timed out with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("Subsystem restart level request rejected,result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } penv->stats.restart_level_resp++; kfree(resp); kfree(req); return 0; out: kfree(req); kfree(resp); penv->stats.restart_level_err++; return ret; } int icnss_send_vbatt_update(struct icnss_priv *priv, uint64_t voltage_uv) { int ret; struct wlfw_vbatt_req_msg_v01 *req; struct wlfw_vbatt_resp_msg_v01 *resp; struct qmi_txn txn; if (!priv) return -ENODEV; if (test_bit(ICNSS_FW_DOWN, &priv->state)) return -EINVAL; icnss_pr_dbg("Sending Vbatt message, state: 0x%lx\n", priv->state); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->voltage_uv = voltage_uv; ret = qmi_txn_init(&priv->qmi, &txn, wlfw_vbatt_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for Vbatt message resp %d\n", ret); goto out; } ret = qmi_send_request(&priv->qmi, NULL, &txn, QMI_WLFW_VBATT_REQ_V01, WLFW_VBATT_REQ_MSG_V01_MAX_MSG_LEN, wlfw_vbatt_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send Vbatt message req %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, priv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("VBATT message resp wait failed with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("QMI Vbatt message request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } kfree(resp); kfree(req); return 0; out: kfree(resp); kfree(req); return ret; } int wlfw_wlan_hw_init_cfg_msg(struct icnss_priv *penv, enum wlfw_wlan_rf_subtype_v01 type) { int ret; struct wlfw_wlan_hw_init_cfg_req_msg_v01 *req; struct wlfw_wlan_hw_init_cfg_resp_msg_v01 *resp; struct qmi_txn txn; if (!penv) return -ENODEV; icnss_pr_dbg("Sending hw init cfg, rf_subtype: 0x%x\n", type); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; resp = kzalloc(sizeof(*resp), GFP_KERNEL); if (!resp) { kfree(req); return -ENOMEM; } req->rf_subtype_valid = 1; req->rf_subtype = type; ret = qmi_txn_init(&penv->qmi, &txn, wlfw_wlan_hw_init_cfg_resp_msg_v01_ei, resp); if (ret < 0) { icnss_pr_err("Fail to init txn for hw init cfg, resp %d\n", ret); goto out; } ret = qmi_send_request(&penv->qmi, NULL, &txn, QMI_WLFW_WLAN_HW_INIT_CFG_REQ_V01, WLFW_WLAN_HW_INIT_CFG_REQ_MSG_V01_MAX_MSG_LEN, wlfw_wlan_hw_init_cfg_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(&txn); icnss_pr_err("Fail to send hw init cfg %d\n", ret); goto out; } ret = qmi_txn_wait(&txn, penv->ctrl_params.qmi_timeout); if (ret < 0) { icnss_pr_err("HW init cfg timed out with ret %d\n", ret); goto out; } else if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("HW init cfg request rejected,result:%d error:%d\n", resp->resp.result, resp->resp.error); ret = -resp->resp.result; goto out; } kfree(resp); kfree(req); return 0; out: kfree(req); kfree(resp); return ret; } /* IMS Service */ int ims_subscribe_for_indication_send_async(struct icnss_priv *priv) { int ret; struct ims_private_service_subscribe_for_indications_req_msg_v01 *req; struct qmi_txn *txn; if (!priv) return -ENODEV; icnss_pr_dbg("Sending ASYNC ims subscribe for indication\n"); req = kzalloc(sizeof(*req), GFP_KERNEL); if (!req) return -ENOMEM; req->wfc_call_status_valid = 1; req->wfc_call_status = 1; txn = &priv->ims_async_txn; ret = qmi_txn_init(&priv->ims_qmi, txn, NULL, NULL); if (ret < 0) { icnss_pr_err("Fail to init txn for ims subscribe for indication resp %d\n", ret); goto out; } ret = qmi_send_request (&priv->ims_qmi, NULL, txn, QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01, IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_MSG_V01_MAX_MSG_LEN, ims_private_service_subscribe_ind_req_msg_v01_ei, req); if (ret < 0) { qmi_txn_cancel(txn); icnss_pr_err("Fail to send ims subscribe for indication req %d\n", ret); goto out; } kfree(req); return 0; out: kfree(req); return ret; } static void ims_subscribe_for_indication_resp_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { const struct ims_private_service_subscribe_for_indications_rsp_msg_v01 *resp = data; icnss_pr_dbg("Received IMS subscribe indication response\n"); if (!txn) { icnss_pr_err("spurious response\n"); return; } if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { icnss_pr_err("IMS subscribe for indication request rejected, result:%d error:%d\n", resp->resp.result, resp->resp.error); txn->result = -resp->resp.result; } } int icnss_process_wfc_call_ind_event(struct icnss_priv *priv, void *data) { int ret; struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg = data; ret = icnss_wlfw_wfc_call_status_send_sync(priv, ind_msg); kfree(data); return ret; } static void icnss_ims_process_wfc_call_ind_cb(struct qmi_handle *ims_qmi, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *data) { struct icnss_priv *priv = container_of(ims_qmi, struct icnss_priv, ims_qmi); const struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg = data; struct ims_private_service_wfc_call_status_ind_msg_v01 *event_data; if (!txn) { icnss_pr_err("IMS->CNSS: WFC_CALL_IND: Spurious indication\n"); return; } if (!ind_msg) { icnss_pr_err("IMS->CNSS: WFC_CALL_IND: Invalid indication\n"); return; } icnss_pr_dbg("IMS->CNSS: WFC_CALL_IND: %x, %x %x, %x %x, %x %llx, %x %x, %x %x\n", ind_msg->wfc_call_active, ind_msg->all_wfc_calls_held_valid, ind_msg->all_wfc_calls_held, ind_msg->is_wfc_emergency_valid, ind_msg->is_wfc_emergency, ind_msg->twt_ims_start_valid, ind_msg->twt_ims_start, ind_msg->twt_ims_int_valid, ind_msg->twt_ims_int, ind_msg->media_quality_valid, ind_msg->media_quality); event_data = kmemdup(ind_msg, sizeof(*event_data), GFP_KERNEL); if (!event_data) return; icnss_driver_event_post(priv, ICNSS_DRIVER_EVENT_IMS_WFC_CALL_IND, 0, event_data); } static struct qmi_msg_handler qmi_ims_msg_handlers[] = { { .type = QMI_RESPONSE, .msg_id = QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01, .ei = ims_private_service_subscribe_ind_rsp_msg_v01_ei, .decoded_size = sizeof(struct ims_private_service_subscribe_for_indications_rsp_msg_v01), .fn = ims_subscribe_for_indication_resp_cb }, { .type = QMI_INDICATION, .msg_id = QMI_IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_V01, .ei = ims_private_service_wfc_call_status_ind_msg_v01_ei, .decoded_size = sizeof(struct ims_private_service_wfc_call_status_ind_msg_v01), .fn = icnss_ims_process_wfc_call_ind_cb }, {} }; static int ims_new_server(struct qmi_handle *qmi, struct qmi_service *service) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, ims_qmi); struct sockaddr_qrtr sq = { 0 }; int ret = 0; icnss_pr_dbg("IMS server arrive: node %u port %u\n", service->node, service->port); sq.sq_family = AF_QIPCRTR; sq.sq_node = service->node; sq.sq_port = service->port; ret = kernel_connect(qmi->sock, (struct sockaddr *)&sq, sizeof(sq), 0); if (ret < 0) { icnss_pr_err("Fail to connect to remote service port\n"); return ret; } set_bit(ICNSS_IMS_CONNECTED, &priv->state); icnss_pr_dbg("IMS Server Connected: 0x%lx\n", priv->state); ret = ims_subscribe_for_indication_send_async(priv); return ret; } static void ims_del_server(struct qmi_handle *qmi, struct qmi_service *service) { struct icnss_priv *priv = container_of(qmi, struct icnss_priv, ims_qmi); icnss_pr_dbg("IMS server exit\n"); clear_bit(ICNSS_IMS_CONNECTED, &priv->state); } static struct qmi_ops ims_qmi_ops = { .new_server = ims_new_server, .del_server = ims_del_server, }; int icnss_register_ims_service(struct icnss_priv *priv) { int ret; ret = qmi_handle_init(&priv->ims_qmi, IMSPRIVATE_SERVICE_MAX_MSG_LEN, &ims_qmi_ops, qmi_ims_msg_handlers); if (ret < 0) return ret; ret = qmi_add_lookup(&priv->ims_qmi, IMSPRIVATE_SERVICE_ID_V01, IMSPRIVATE_SERVICE_VERS_V01, 0); return ret; } void icnss_unregister_ims_service(struct icnss_priv *priv) { qmi_handle_release(&priv->ims_qmi); }