From fee5dd5aba0b3c9f03bf48c7cc60d1826ed73c44 Mon Sep 17 00:00:00 2001 From: Yuanyuan Liu Date: Thu, 28 Jan 2016 17:14:57 -0800 Subject: [PATCH] icnss: Update WLFW QMI messages Add QMI message to send MSA0 physical memory start address and size to wlan FW. Add QMI message indication to get the HAL-PYH Pin connect test result from wlan FW. Add a new qmi message for sending fw debug configuration. Update cap_resp message. CRs-Fixed: 978217 Change-Id: Ie0fa374b720ebbffd1d1fd5b9289b2aa816a822a Signed-off-by: Yuanyuan Liu --- .../devicetree/bindings/cnss/icnss.txt | 2 + drivers/soc/qcom/icnss.c | 356 +++++++++++++-- drivers/soc/qcom/wlan_firmware_service_v01.c | 406 +++++++++++++++++- drivers/soc/qcom/wlan_firmware_service_v01.h | 140 +++++- include/soc/qcom/icnss.h | 10 +- 5 files changed, 846 insertions(+), 68 deletions(-) diff --git a/Documentation/devicetree/bindings/cnss/icnss.txt b/Documentation/devicetree/bindings/cnss/icnss.txt index 252e3075f8e2..f07a2beafbb3 100644 --- a/Documentation/devicetree/bindings/cnss/icnss.txt +++ b/Documentation/devicetree/bindings/cnss/icnss.txt @@ -11,6 +11,7 @@ Required properties: - reg: Memory regions defined as starting address and size - reg-names: Names of the memory regions defined in reg entry - interrupts: Copy engine interrupt table + - qcom,wlan-msa-memory: MSA memory size Optional properties: @@ -33,4 +34,5 @@ Example: <0 139 0 /* CE9 */ >, <0 140 0 /* CE10 */ >, <0 141 0 /* CE11 */ >; + qcom,wlan-msa-memory = <0x200000>; }; diff --git a/drivers/soc/qcom/icnss.c b/drivers/soc/qcom/icnss.c index e36e8e216d98..e9f7b8931d9b 100644 --- a/drivers/soc/qcom/icnss.c +++ b/drivers/soc/qcom/icnss.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include @@ -85,11 +86,19 @@ static struct { struct work_struct qmi_event_work; struct work_struct qmi_recv_msg_work; struct workqueue_struct *qmi_event_wq; + phys_addr_t msa_phys; + uint32_t msa_mem_size; + void *msa_addr; uint32_t state; - u32 board_id; - u32 num_peers; - u32 mac_version; - char fw_version[QMI_WLFW_MAX_STR_LEN_V01 + 1]; + struct wlfw_rf_chip_info_s_v01 chip_info; + struct wlfw_rf_board_info_s_v01 board_info; + struct wlfw_soc_info_s_v01 soc_info; + struct wlfw_fw_version_info_s_v01 fw_version_info; + u32 pwr_pin_result; + u32 phy_io_pin_result; + u32 rf_pin_result; + struct icnss_mem_region_info + icnss_mem_region[QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01]; } *penv; static int icnss_qmi_event_post(enum icnss_qmi_event_type type, void *data) @@ -116,6 +125,167 @@ static int icnss_qmi_event_post(enum icnss_qmi_event_type type, void *data) return 0; } +static int icnss_qmi_pin_connect_result_ind(void *msg, unsigned int msg_len) +{ + struct msg_desc ind_desc; + struct wlfw_pin_connect_result_ind_msg_v01 ind_msg; + int ret = 0; + + if (!penv || !penv->wlfw_clnt) { + ret = -ENODEV; + goto out; + } + + ind_desc.msg_id = QMI_WLFW_PIN_CONNECT_RESULT_IND_V01; + ind_desc.max_msg_len = WLFW_PIN_CONNECT_RESULT_IND_MSG_V01_MAX_MSG_LEN; + ind_desc.ei_array = wlfw_pin_connect_result_ind_msg_v01_ei; + + ret = qmi_kernel_decode(&ind_desc, &ind_msg, msg, msg_len); + if (ret < 0) { + pr_err("%s: Failed to decode message!\n", __func__); + goto out; + } + + /* store pin result locally */ + if (ind_msg.pwr_pin_result_valid) + penv->pwr_pin_result = ind_msg.pwr_pin_result; + if (ind_msg.phy_io_pin_result_valid) + penv->phy_io_pin_result = ind_msg.phy_io_pin_result; + if (ind_msg.rf_pin_result_valid) + penv->rf_pin_result = ind_msg.rf_pin_result; + + pr_debug("%s: Pin connect Result: pwr_pin: 0x%x phy_io_pin: 0x%x rf_io_pin: 0x%x\n", + __func__, ind_msg.pwr_pin_result, ind_msg.phy_io_pin_result, + ind_msg.rf_pin_result); +out: + return ret; +} + + +static int icnss_adrastea_power_on(void) +{ + int ret = 0; + + /* TZ API of power on adrastea */ + + return ret; +} + +void icnss_adrastea_power_off(void) +{ + /* TZ API of power off adrastea */ +} + +static int wlfw_msa_mem_info_send_sync_msg(void) +{ + int ret = 0; + int i; + struct wlfw_msa_info_req_msg_v01 req; + struct wlfw_msa_info_resp_msg_v01 resp; + struct msg_desc req_desc, resp_desc; + + if (!penv || !penv->wlfw_clnt) { + ret = -ENODEV; + goto out; + } + + memset(&req, 0, sizeof(req)); + memset(&resp, 0, sizeof(resp)); + + req.msa_addr = penv->msa_phys; + req.size = penv->msa_mem_size; + + req_desc.max_msg_len = WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN; + req_desc.msg_id = QMI_WLFW_MSA_INFO_REQ_V01; + req_desc.ei_array = wlfw_msa_info_req_msg_v01_ei; + + resp_desc.max_msg_len = WLFW_MSA_INFO_RESP_MSG_V01_MAX_MSG_LEN; + resp_desc.msg_id = QMI_WLFW_MSA_INFO_RESP_V01; + resp_desc.ei_array = wlfw_msa_info_resp_msg_v01_ei; + + ret = qmi_send_req_wait(penv->wlfw_clnt, &req_desc, &req, sizeof(req), + &resp_desc, &resp, sizeof(resp), WLFW_TIMEOUT_MS); + if (ret < 0) { + pr_err("%s: send req failed %d\n", __func__, ret); + goto out; + } + + if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { + pr_err("%s: QMI request failed %d %d\n", + __func__, resp.resp.result, resp.resp.error); + ret = resp.resp.result; + goto out; + } + + pr_debug("%s: Receive mem_region_info_len: %d\n", + __func__, resp.mem_region_info_len); + + if (resp.mem_region_info_len > 2) { + pr_err("%s : Invalid memory region length received\n", + __func__); + ret = -EINVAL; + goto out; + } + + for (i = 0; i < resp.mem_region_info_len; i++) { + penv->icnss_mem_region[i].reg_addr = + resp.mem_region_info[i].region_addr; + penv->icnss_mem_region[i].size = + resp.mem_region_info[i].size; + penv->icnss_mem_region[i].secure_flag = + resp.mem_region_info[i].secure_flag; + pr_debug("%s : Memory Region: %d Addr:0x%x Size : %d Flag: %d\n", + __func__, + i, + (unsigned int)penv->icnss_mem_region[i].reg_addr, + penv->icnss_mem_region[i].size, + penv->icnss_mem_region[i].secure_flag); + } + +out: + return ret; +} + +static int wlfw_msa_ready_send_sync_msg(void) +{ + int ret; + struct wlfw_msa_ready_req_msg_v01 req; + struct wlfw_msa_ready_resp_msg_v01 resp; + struct msg_desc req_desc, resp_desc; + + if (!penv || !penv->wlfw_clnt) { + ret = -ENODEV; + goto out; + } + + memset(&req, 0, sizeof(req)); + memset(&resp, 0, sizeof(resp)); + + req_desc.max_msg_len = WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN; + req_desc.msg_id = QMI_WLFW_MSA_READY_REQ_V01; + req_desc.ei_array = wlfw_msa_ready_req_msg_v01_ei; + + resp_desc.max_msg_len = WLFW_MSA_READY_RESP_MSG_V01_MAX_MSG_LEN; + resp_desc.msg_id = QMI_WLFW_MSA_READY_RESP_V01; + resp_desc.ei_array = wlfw_msa_ready_resp_msg_v01_ei; + + ret = qmi_send_req_wait(penv->wlfw_clnt, &req_desc, &req, sizeof(req), + &resp_desc, &resp, sizeof(resp), WLFW_TIMEOUT_MS); + if (ret < 0) { + pr_err("%s: send req failed %d\n", __func__, ret); + goto out; + } + + if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { + pr_err("%s: QMI request failed %d %d\n", + __func__, resp.resp.result, resp.resp.error); + ret = resp.resp.result; + goto out; + } +out: + return ret; +} + static int wlfw_ind_register_send_sync_msg(void) { int ret; @@ -133,6 +303,10 @@ static int wlfw_ind_register_send_sync_msg(void) req.fw_ready_enable_valid = 1; req.fw_ready_enable = 1; + req.msa_ready_enable_valid = 1; + req.msa_ready_enable = 1; + req.pin_connect_result_enable_valid = 1; + req.pin_connect_result_enable = 1; req_desc.max_msg_len = WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN; req_desc.msg_id = QMI_WLFW_IND_REGISTER_REQ_V01; @@ -198,19 +372,25 @@ static int wlfw_cap_send_sync_msg(void) } /* store cap locally */ - if (resp.board_id_valid) - penv->board_id = resp.board_id; - if (resp.num_peers_valid) - penv->num_peers = resp.num_peers; - if (resp.mac_version_valid) - penv->mac_version = resp.mac_version; - if (resp.fw_version_valid) - strlcpy(penv->fw_version, resp.fw_version, - QMI_WLFW_MAX_STR_LEN_V01 + 1); + if (resp.chip_info_valid) + penv->chip_info = resp.chip_info; + if (resp.board_info_valid) + penv->board_info = resp.board_info; + else + penv->board_info.board_id = 0xFF; + if (resp.soc_info_valid) + penv->soc_info = resp.soc_info; + if (resp.fw_version_info_valid) + penv->fw_version_info = resp.fw_version_info; - pr_debug("%s: board_id:0x%0x num_peers: %d mac_version: 0x%0x fw_version: %s", - __func__, penv->board_id, penv->num_peers, - penv->mac_version, penv->fw_version); + pr_debug("%s: chip_id: 0x%0x, chip_family: 0x%0x, board_id: 0x%0x, soc_id: 0x%0x, fw_version: 0x%0x, fw_build_timestamp: %s", + __func__, + penv->chip_info.chip_id, + penv->chip_info.chip_family, + penv->board_info.board_id, + penv->soc_info.soc_id, + penv->fw_version_info.fw_version, + penv->fw_version_info.fw_build_timestamp); out: return ret; } @@ -301,6 +481,49 @@ out: return ret; } +static int wlfw_ini_send_sync_msg(bool enablefwlog) +{ + int ret; + struct wlfw_ini_req_msg_v01 req; + struct wlfw_ini_resp_msg_v01 resp; + struct msg_desc req_desc, resp_desc; + + if (!penv || !penv->wlfw_clnt) { + ret = -ENODEV; + goto out; + } + + memset(&req, 0, sizeof(req)); + memset(&resp, 0, sizeof(resp)); + + req.enablefwlog_valid = 1; + req.enablefwlog = enablefwlog; + + req_desc.max_msg_len = WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN; + req_desc.msg_id = QMI_WLFW_INI_REQ_V01; + req_desc.ei_array = wlfw_ini_req_msg_v01_ei; + + resp_desc.max_msg_len = WLFW_INI_RESP_MSG_V01_MAX_MSG_LEN; + resp_desc.msg_id = QMI_WLFW_INI_RESP_V01; + resp_desc.ei_array = wlfw_ini_resp_msg_v01_ei; + + ret = qmi_send_req_wait(penv->wlfw_clnt, &req_desc, &req, sizeof(req), + &resp_desc, &resp, sizeof(resp), WLFW_TIMEOUT_MS); + if (ret < 0) { + pr_err("%s: send req failed %d\n", __func__, ret); + goto out; + } + + if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { + pr_err("%s: QMI request failed %d %d\n", + __func__, resp.resp.result, resp.resp.error); + ret = resp.resp.result; + goto out; + } +out: + return ret; +} + static void icnss_qmi_wlfw_clnt_notify_work(struct work_struct *work) { int ret; @@ -345,6 +568,15 @@ static void icnss_qmi_wlfw_clnt_ind(struct qmi_handle *handle, case QMI_WLFW_FW_READY_IND_V01: icnss_qmi_event_post(ICNSS_QMI_EVENT_FW_READY_IND, NULL); break; + case QMI_WLFW_MSA_READY_IND_V01: + pr_debug("%s: Received MSA Ready Indication msg_id 0x%x\n", + __func__, msg_id); + break; + case QMI_WLFW_PIN_CONNECT_RESULT_IND_V01: + pr_debug("%s: Received Pin Connect Test Result msg_id 0x%x\n", + __func__, msg_id); + icnss_qmi_pin_connect_result_ind(msg, msg_len); + break; default: pr_err("%s: Invalid msg_id 0x%x\n", __func__, msg_id); break; @@ -377,8 +609,8 @@ static int icnss_qmi_event_server_arrive(void *data) ret = qmi_register_ind_cb(penv->wlfw_clnt, icnss_qmi_wlfw_clnt_ind, penv); if (ret < 0) { - pr_err("Failed to register indication callback: %d\n", - ret); + pr_err("%s: Failed to register indication callback: %d\n", + __func__, ret); goto fail; } @@ -386,17 +618,48 @@ static int icnss_qmi_event_server_arrive(void *data) pr_info("%s: QMI Server Connected\n", __func__); + ret = icnss_adrastea_power_on(); + if (ret < 0) { + pr_err("%s: Failed to power on hardware: %d\n", + __func__, ret); + goto fail; + } + ret = wlfw_ind_register_send_sync_msg(); if (ret < 0) { - pr_err("Failed to send indication message: %d\n", - ret); + pr_err("%s: Failed to send indication message: %d\n", + __func__, ret); goto out; } + if (penv->msa_mem_size) { + penv->msa_addr = dma_alloc_coherent(&penv->pdev->dev, + penv->msa_mem_size, &penv->msa_phys, + GFP_KERNEL); + + pr_debug("%s: MSA addr: %p, MSA phys: %pa\n", __func__, + penv->msa_addr, &penv->msa_phys); + + if (penv->msa_addr) { + ret = wlfw_msa_mem_info_send_sync_msg(); + if (ret < 0) { + pr_err("%s: Failed to send MSA info: %d\n", + __func__, ret); + goto out; + } + ret = wlfw_msa_ready_send_sync_msg(); + if (ret < 0) { + pr_err("%s: Failed to send MSA ready : %d\n", + __func__, ret); + goto out; + } + } + } + ret = wlfw_cap_send_sync_msg(); if (ret < 0) { - pr_err("Failed to get capability: %d\n", - ret); + pr_err("%s: Failed to get capability: %d\n", + __func__, ret); goto out; } return ret; @@ -404,6 +667,10 @@ fail: qmi_handle_destroy(penv->wlfw_clnt); penv->wlfw_clnt = NULL; out: + if (penv->msa_addr) { + dma_free_coherent(&penv->pdev->dev, penv->msa_mem_size, + penv->msa_addr, penv->msa_phys); + } ICNSS_ASSERT(0); return ret; } @@ -416,6 +683,10 @@ static int icnss_qmi_event_server_exit(void *data) pr_info("%s: QMI Service Disconnected\n", __func__); qmi_handle_destroy(penv->wlfw_clnt); + if (penv->msa_addr) { + dma_free_coherent(&penv->pdev->dev, penv->msa_mem_size, + penv->msa_addr, penv->msa_phys); + } penv->state = 0; penv->wlfw_clnt = NULL; @@ -436,6 +707,9 @@ static int icnss_qmi_event_fw_ready_ind(void *data) ret = -ENODEV; goto out; } + + icnss_adrastea_power_off(); + if (!penv->ops || !penv->ops->probe) { pr_err("%s: WLAN driver is not registed yet\n", __func__); ret = -ENOENT; @@ -458,7 +732,7 @@ static int icnss_qmi_wlfw_clnt_svc_event_notify(struct notifier_block *this, if (!penv) return -ENODEV; - pr_debug("Event Notify: code: %ld", code); + pr_debug("%s: Event Notify: code: %ld", __func__, code); switch (code) { case QMI_SERVER_ARRIVE: @@ -469,7 +743,7 @@ static int icnss_qmi_wlfw_clnt_svc_event_notify(struct notifier_block *this, ret = icnss_qmi_event_post(ICNSS_QMI_EVENT_SERVER_EXIT, NULL); break; default: - pr_debug("Invalid code: %ld", code); + pr_debug("%s: Invalid code: %ld", __func__, code); break; } return ret; @@ -499,7 +773,8 @@ static void icnss_qmi_wlfw_event_work(struct work_struct *work) icnss_qmi_event_fw_ready_ind(event->data); break; default: - pr_debug("Invalid Event type: %d", event->type); + pr_debug("%s: Invalid Event type: %d", + __func__, event->type); break; } kfree(event); @@ -536,8 +811,12 @@ int icnss_register_driver(struct icnss_driver_ops *ops) penv->ops = ops; /* check for all conditions before invoking probe */ - if (ICNSS_IS_FW_READY(penv->state) && penv->ops->probe) + if (ICNSS_IS_FW_READY(penv->state) && penv->ops->probe) { ret = penv->ops->probe(&pdev->dev); + } else { + pr_err("icnss: FW is not ready\n"); + ret = -ENOENT; + } out: return ret; @@ -744,6 +1023,18 @@ int icnss_get_soc_info(struct icnss_soc_info *info) } EXPORT_SYMBOL(icnss_get_soc_info); +int icnss_set_fw_debug_mode(bool enablefwlog) +{ + int ret; + + ret = wlfw_ini_send_sync_msg(enablefwlog); + if (ret) + pr_err("icnss: Fail to send ini, ret = %d\n", ret); + + return ret; +} +EXPORT_SYMBOL(icnss_set_fw_debug_mode); + int icnss_wlan_enable(struct icnss_wlan_enable_cfg *config, enum icnss_driver_mode mode, const char *host_version) @@ -838,6 +1129,8 @@ static int icnss_probe(struct platform_device *pdev) int ret = 0; struct resource *res; int i; + struct device *dev = &pdev->dev; + u32 msa_mem_size = 0; if (penv) return -EEXIST; @@ -873,6 +1166,15 @@ static int icnss_probe(struct platform_device *pdev) } } + if (of_property_read_u32(dev->of_node, "qcom,wlan-msa-memory", + &msa_mem_size) == 0) { + penv->msa_mem_size = msa_mem_size; + } else { + pr_err("icnss: Fail to get MSA Memory Size\n"); + ret = -ENODEV; + goto out; + } + penv->qmi_event_wq = alloc_workqueue("icnss_qmi_event", 0, 0); if (!penv->qmi_event_wq) { pr_err("%s: workqueue creation failed\n", __func__); diff --git a/drivers/soc/qcom/wlan_firmware_service_v01.c b/drivers/soc/qcom/wlan_firmware_service_v01.c index b514f3f7c6cd..e899459a5a40 100644 --- a/drivers/soc/qcom/wlan_firmware_service_v01.c +++ b/drivers/soc/qcom/wlan_firmware_service_v01.c @@ -1,4 +1,4 @@ - /* Copyright (c) 2015, The Linux Foundation. All rights reserved. + /* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -130,6 +130,127 @@ static struct elem_info wlfw_shadow_reg_cfg_s_v01_ei[] = { }, }; +static struct elem_info wlfw_memory_region_info_s_v01_ei[] = { + { + .data_type = QMI_UNSIGNED_8_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint64_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_memory_region_info_s_v01, + region_addr), + }, + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_memory_region_info_s_v01, + size), + }, + { + .data_type = QMI_UNSIGNED_1_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_memory_region_info_s_v01, + secure_flag), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +static struct elem_info wlfw_rf_chip_info_s_v01_ei[] = { + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_rf_chip_info_s_v01, + chip_id), + }, + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_rf_chip_info_s_v01, + chip_family), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +static struct elem_info wlfw_rf_board_info_s_v01_ei[] = { + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_rf_board_info_s_v01, + board_id), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +static struct elem_info wlfw_soc_info_s_v01_ei[] = { + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_soc_info_s_v01, + soc_id), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +static struct elem_info wlfw_fw_version_info_s_v01_ei[] = { + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_fw_version_info_s_v01, + fw_version), + }, + { + .data_type = QMI_STRING, + .elem_len = QMI_WLFW_MAX_TIMESTAMP_LEN_V01 + 1, + .elem_size = sizeof(char), + .is_array = NO_ARRAY, + .tlv_type = 0, + .offset = offsetof(struct wlfw_fw_version_info_s_v01, + fw_build_timestamp), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + struct elem_info wlfw_ind_register_req_msg_v01_ei[] = { { .data_type = QMI_OPT_FLAG, @@ -185,6 +306,42 @@ struct elem_info wlfw_ind_register_req_msg_v01_ei[] = { .offset = offsetof(struct wlfw_ind_register_req_msg_v01, initiate_cal_update_enable), }, + { + .data_type = QMI_OPT_FLAG, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x13, + .offset = offsetof(struct wlfw_ind_register_req_msg_v01, + msa_ready_enable_valid), + }, + { + .data_type = QMI_UNSIGNED_1_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x13, + .offset = offsetof(struct wlfw_ind_register_req_msg_v01, + msa_ready_enable), + }, + { + .data_type = QMI_OPT_FLAG, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x14, + .offset = offsetof(struct wlfw_ind_register_req_msg_v01, + pin_connect_result_enable_valid), + }, + { + .data_type = QMI_UNSIGNED_1_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x14, + .offset = offsetof(struct wlfw_ind_register_req_msg_v01, + pin_connect_result_enable), + }, { .data_type = QMI_EOTI, .is_array = NO_ARRAY, @@ -218,6 +375,82 @@ struct elem_info wlfw_fw_ready_ind_msg_v01_ei[] = { }, }; +struct elem_info wlfw_msa_ready_ind_msg_v01_ei[] = { + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +struct elem_info wlfw_pin_connect_result_ind_msg_v01_ei[] = { + { + .data_type = QMI_OPT_FLAG, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x10, + .offset = offsetof( + struct wlfw_pin_connect_result_ind_msg_v01, + pwr_pin_result_valid), + }, + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0x10, + .offset = offsetof( + struct wlfw_pin_connect_result_ind_msg_v01, + pwr_pin_result), + }, + { + .data_type = QMI_OPT_FLAG, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x11, + .offset = offsetof( + struct wlfw_pin_connect_result_ind_msg_v01, + phy_io_pin_result_valid), + }, + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0x11, + .offset = offsetof( + struct wlfw_pin_connect_result_ind_msg_v01, + phy_io_pin_result), + }, + { + .data_type = QMI_OPT_FLAG, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x12, + .offset = offsetof( + struct wlfw_pin_connect_result_ind_msg_v01, + rf_pin_result_valid), + }, + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0x12, + .offset = offsetof( + struct wlfw_pin_connect_result_ind_msg_v01, + rf_pin_result), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + struct elem_info wlfw_wlan_mode_req_msg_v01_ei[] = { { .data_type = QMI_SIGNED_4_BYTE_ENUM, @@ -407,16 +640,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = { .is_array = NO_ARRAY, .tlv_type = 0x10, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - board_id_valid), + chip_info_valid), }, { - .data_type = QMI_UNSIGNED_4_BYTE, + .data_type = QMI_STRUCT, .elem_len = 1, - .elem_size = sizeof(uint32_t), + .elem_size = sizeof(struct wlfw_rf_chip_info_s_v01), .is_array = NO_ARRAY, .tlv_type = 0x10, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - board_id), + chip_info), + .ei_array = wlfw_rf_chip_info_s_v01_ei, }, { .data_type = QMI_OPT_FLAG, @@ -425,16 +659,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = { .is_array = NO_ARRAY, .tlv_type = 0x11, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - num_peers_valid), + board_info_valid), }, { - .data_type = QMI_UNSIGNED_4_BYTE, + .data_type = QMI_STRUCT, .elem_len = 1, - .elem_size = sizeof(uint32_t), + .elem_size = sizeof(struct wlfw_rf_board_info_s_v01), .is_array = NO_ARRAY, .tlv_type = 0x11, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - num_peers), + board_info), + .ei_array = wlfw_rf_board_info_s_v01_ei, }, { .data_type = QMI_OPT_FLAG, @@ -443,16 +678,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = { .is_array = NO_ARRAY, .tlv_type = 0x12, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - mac_version_valid), + soc_info_valid), }, { - .data_type = QMI_UNSIGNED_4_BYTE, + .data_type = QMI_STRUCT, .elem_len = 1, - .elem_size = sizeof(uint32_t), + .elem_size = sizeof(struct wlfw_soc_info_s_v01), .is_array = NO_ARRAY, .tlv_type = 0x12, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - mac_version), + soc_info), + .ei_array = wlfw_soc_info_s_v01_ei, }, { .data_type = QMI_OPT_FLAG, @@ -461,16 +697,17 @@ struct elem_info wlfw_cap_resp_msg_v01_ei[] = { .is_array = NO_ARRAY, .tlv_type = 0x13, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - fw_version_valid), + fw_version_info_valid), }, { - .data_type = QMI_STRING, - .elem_len = QMI_WLFW_MAX_STR_LEN_V01 + 1, - .elem_size = sizeof(char), + .data_type = QMI_STRUCT, + .elem_len = 1, + .elem_size = sizeof(struct wlfw_fw_version_info_s_v01), .is_array = NO_ARRAY, .tlv_type = 0x13, .offset = offsetof(struct wlfw_cap_resp_msg_v01, - fw_version), + fw_version_info), + .ei_array = wlfw_fw_version_info_s_v01_ei, }, { .data_type = QMI_EOTI, @@ -976,3 +1213,136 @@ struct elem_info wlfw_cal_update_resp_msg_v01_ei[] = { .is_array = QMI_COMMON_TLV_TYPE, }, }; + +struct elem_info wlfw_msa_info_req_msg_v01_ei[] = { + { + .data_type = QMI_UNSIGNED_8_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint64_t), + .is_array = NO_ARRAY, + .tlv_type = 0x01, + .offset = offsetof(struct wlfw_msa_info_req_msg_v01, + msa_addr), + }, + { + .data_type = QMI_UNSIGNED_4_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint32_t), + .is_array = NO_ARRAY, + .tlv_type = 0x02, + .offset = offsetof(struct wlfw_msa_info_req_msg_v01, + size), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +struct elem_info wlfw_msa_info_resp_msg_v01_ei[] = { + { + .data_type = QMI_STRUCT, + .elem_len = 1, + .elem_size = sizeof(struct qmi_response_type_v01), + .is_array = NO_ARRAY, + .tlv_type = 0x02, + .offset = offsetof(struct wlfw_msa_info_resp_msg_v01, + resp), + .ei_array = get_qmi_response_type_v01_ei(), + }, + { + .data_type = QMI_DATA_LEN, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x03, + .offset = offsetof(struct wlfw_msa_info_resp_msg_v01, + mem_region_info_len), + }, + { + .data_type = QMI_STRUCT, + .elem_len = QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01, + .elem_size = sizeof(struct wlfw_memory_region_info_s_v01), + .is_array = VAR_LEN_ARRAY, + .tlv_type = 0x03, + .offset = offsetof(struct wlfw_msa_info_resp_msg_v01, + mem_region_info), + .ei_array = wlfw_memory_region_info_s_v01_ei, + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +struct elem_info wlfw_msa_ready_req_msg_v01_ei[] = { + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +struct elem_info wlfw_msa_ready_resp_msg_v01_ei[] = { + { + .data_type = QMI_STRUCT, + .elem_len = 1, + .elem_size = sizeof(struct qmi_response_type_v01), + .is_array = NO_ARRAY, + .tlv_type = 0x02, + .offset = offsetof(struct wlfw_msa_ready_resp_msg_v01, + resp), + .ei_array = get_qmi_response_type_v01_ei(), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +struct elem_info wlfw_ini_req_msg_v01_ei[] = { + { + .data_type = QMI_OPT_FLAG, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x10, + .offset = offsetof(struct wlfw_ini_req_msg_v01, + enablefwlog_valid), + }, + { + .data_type = QMI_UNSIGNED_1_BYTE, + .elem_len = 1, + .elem_size = sizeof(uint8_t), + .is_array = NO_ARRAY, + .tlv_type = 0x10, + .offset = offsetof(struct wlfw_ini_req_msg_v01, + enablefwlog), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; + +struct elem_info wlfw_ini_resp_msg_v01_ei[] = { + { + .data_type = QMI_STRUCT, + .elem_len = 1, + .elem_size = sizeof(struct qmi_response_type_v01), + .is_array = NO_ARRAY, + .tlv_type = 0x02, + .offset = offsetof(struct wlfw_ini_resp_msg_v01, + resp), + .ei_array = get_qmi_response_type_v01_ei(), + }, + { + .data_type = QMI_EOTI, + .is_array = NO_ARRAY, + .is_array = QMI_COMMON_TLV_TYPE, + }, +}; diff --git a/drivers/soc/qcom/wlan_firmware_service_v01.h b/drivers/soc/qcom/wlan_firmware_service_v01.h index 62b7183e2141..6d007c297cf6 100644 --- a/drivers/soc/qcom/wlan_firmware_service_v01.h +++ b/drivers/soc/qcom/wlan_firmware_service_v01.h @@ -1,4 +1,4 @@ - /* Copyright (c) 2015, The Linux Foundation. All rights reserved. + /* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -16,29 +16,39 @@ #define WLFW_SERVICE_ID_V01 0x45 #define WLFW_SERVICE_VERS_V01 0x01 -#define QMI_WLFW_CAL_REPORT_REQ_V01 0x0026 -#define QMI_WLFW_CAL_REPORT_RESP_V01 0x0026 -#define QMI_WLFW_CAP_RESP_V01 0x0024 #define QMI_WLFW_BDF_DOWNLOAD_REQ_V01 0x0025 -#define QMI_WLFW_CAL_DOWNLOAD_RESP_V01 0x0027 -#define QMI_WLFW_WLAN_MODE_RESP_V01 0x0022 -#define QMI_WLFW_CAL_UPDATE_RESP_V01 0x0029 -#define QMI_WLFW_BDF_DOWNLOAD_RESP_V01 0x0025 #define QMI_WLFW_INITIATE_CAL_UPDATE_IND_V01 0x002A -#define QMI_WLFW_FW_READY_IND_V01 0x0021 -#define QMI_WLFW_INITIATE_CAL_DOWNLOAD_IND_V01 0x0028 #define QMI_WLFW_CAP_REQ_V01 0x0024 -#define QMI_WLFW_CAL_DOWNLOAD_REQ_V01 0x0027 +#define QMI_WLFW_CAL_REPORT_REQ_V01 0x0026 +#define QMI_WLFW_CAL_UPDATE_RESP_V01 0x0029 +#define QMI_WLFW_CAL_DOWNLOAD_RESP_V01 0x0027 +#define QMI_WLFW_INI_RESP_V01 0x002F +#define QMI_WLFW_CAL_REPORT_RESP_V01 0x0026 +#define QMI_WLFW_INITIATE_CAL_DOWNLOAD_IND_V01 0x0028 +#define QMI_WLFW_MSA_READY_IND_V01 0x002B #define QMI_WLFW_WLAN_MODE_REQ_V01 0x0022 -#define QMI_WLFW_CAL_UPDATE_REQ_V01 0x0029 #define QMI_WLFW_IND_REGISTER_REQ_V01 0x0020 #define QMI_WLFW_WLAN_CFG_RESP_V01 0x0023 +#define QMI_WLFW_WLAN_MODE_RESP_V01 0x0022 +#define QMI_WLFW_PIN_CONNECT_RESULT_IND_V01 0x002C +#define QMI_WLFW_FW_READY_IND_V01 0x0021 +#define QMI_WLFW_MSA_READY_RESP_V01 0x002E +#define QMI_WLFW_CAL_UPDATE_REQ_V01 0x0029 +#define QMI_WLFW_INI_REQ_V01 0x002F +#define QMI_WLFW_BDF_DOWNLOAD_RESP_V01 0x0025 +#define QMI_WLFW_MSA_INFO_RESP_V01 0x002D +#define QMI_WLFW_MSA_READY_REQ_V01 0x002E +#define QMI_WLFW_CAP_RESP_V01 0x0024 +#define QMI_WLFW_MSA_INFO_REQ_V01 0x002D +#define QMI_WLFW_CAL_DOWNLOAD_REQ_V01 0x0027 #define QMI_WLFW_WLAN_CFG_REQ_V01 0x0023 #define QMI_WLFW_IND_REGISTER_RESP_V01 0x0020 +#define QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01 2 #define QMI_WLFW_MAX_NUM_CAL_V01 5 #define QMI_WLFW_MAX_DATA_SIZE_V01 6144 #define QMI_WLFW_MAX_NUM_CE_V01 12 +#define QMI_WLFW_MAX_TIMESTAMP_LEN_V01 32 #define QMI_WLFW_MAX_STR_LEN_V01 16 #define QMI_WLFW_MAX_NUM_SHADOW_REG_V01 24 #define QMI_WLFW_MAX_NUM_SVC_V01 24 @@ -98,6 +108,30 @@ struct wlfw_shadow_reg_cfg_s_v01 { uint16_t offset; }; +struct wlfw_memory_region_info_s_v01 { + uint64_t region_addr; + uint32_t size; + uint8_t secure_flag; +}; + +struct wlfw_rf_chip_info_s_v01 { + uint32_t chip_id; + uint32_t chip_family; +}; + +struct wlfw_rf_board_info_s_v01 { + uint32_t board_id; +}; + +struct wlfw_soc_info_s_v01 { + uint32_t soc_id; +}; + +struct wlfw_fw_version_info_s_v01 { + uint32_t fw_version; + char fw_build_timestamp[QMI_WLFW_MAX_TIMESTAMP_LEN_V01 + 1]; +}; + struct wlfw_ind_register_req_msg_v01 { uint8_t fw_ready_enable_valid; uint8_t fw_ready_enable; @@ -105,8 +139,12 @@ struct wlfw_ind_register_req_msg_v01 { uint8_t initiate_cal_download_enable; uint8_t initiate_cal_update_enable_valid; uint8_t initiate_cal_update_enable; + uint8_t msa_ready_enable_valid; + uint8_t msa_ready_enable; + uint8_t pin_connect_result_enable_valid; + uint8_t pin_connect_result_enable; }; -#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 12 +#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 20 extern struct elem_info wlfw_ind_register_req_msg_v01_ei[]; struct wlfw_ind_register_resp_msg_v01 { @@ -121,6 +159,23 @@ struct wlfw_fw_ready_ind_msg_v01 { #define WLFW_FW_READY_IND_MSG_V01_MAX_MSG_LEN 0 extern struct elem_info wlfw_fw_ready_ind_msg_v01_ei[]; +struct wlfw_msa_ready_ind_msg_v01 { + char placeholder; +}; +#define WLFW_MSA_READY_IND_MSG_V01_MAX_MSG_LEN 0 +extern struct elem_info wlfw_msa_ready_ind_msg_v01_ei[]; + +struct wlfw_pin_connect_result_ind_msg_v01 { + uint8_t pwr_pin_result_valid; + uint32_t pwr_pin_result; + uint8_t phy_io_pin_result_valid; + uint32_t phy_io_pin_result; + uint8_t rf_pin_result_valid; + uint32_t rf_pin_result; +}; +#define WLFW_PIN_CONNECT_RESULT_IND_MSG_V01_MAX_MSG_LEN 21 +extern struct elem_info wlfw_pin_connect_result_ind_msg_v01_ei[]; + struct wlfw_wlan_mode_req_msg_v01 { enum wlfw_driver_mode_enum_v01 mode; }; @@ -163,16 +218,16 @@ extern struct elem_info wlfw_cap_req_msg_v01_ei[]; struct wlfw_cap_resp_msg_v01 { struct qmi_response_type_v01 resp; - uint8_t board_id_valid; - uint32_t board_id; - uint8_t num_peers_valid; - uint32_t num_peers; - uint8_t mac_version_valid; - uint32_t mac_version; - uint8_t fw_version_valid; - char fw_version[QMI_WLFW_MAX_STR_LEN_V01 + 1]; + uint8_t chip_info_valid; + struct wlfw_rf_chip_info_s_v01 chip_info; + uint8_t board_info_valid; + struct wlfw_rf_board_info_s_v01 board_info; + uint8_t soc_info_valid; + struct wlfw_soc_info_s_v01 soc_info; + uint8_t fw_version_info_valid; + struct wlfw_fw_version_info_s_v01 fw_version_info; }; -#define WLFW_CAP_RESP_MSG_V01_MAX_MSG_LEN 47 +#define WLFW_CAP_RESP_MSG_V01_MAX_MSG_LEN 72 extern struct elem_info wlfw_cap_resp_msg_v01_ei[]; struct wlfw_bdf_download_req_msg_v01 { @@ -271,4 +326,45 @@ struct wlfw_cal_update_resp_msg_v01 { #define WLFW_CAL_UPDATE_RESP_MSG_V01_MAX_MSG_LEN 6181 extern struct elem_info wlfw_cal_update_resp_msg_v01_ei[]; +struct wlfw_msa_info_req_msg_v01 { + uint64_t msa_addr; + uint32_t size; +}; +#define WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN 18 +extern struct elem_info wlfw_msa_info_req_msg_v01_ei[]; + +struct wlfw_msa_info_resp_msg_v01 { + struct qmi_response_type_v01 resp; + uint32_t mem_region_info_len; + struct wlfw_memory_region_info_s_v01 + mem_region_info[QMI_WLFW_MAX_NUM_MEMORY_REGIONS_V01]; +}; +#define WLFW_MSA_INFO_RESP_MSG_V01_MAX_MSG_LEN 37 +extern struct elem_info wlfw_msa_info_resp_msg_v01_ei[]; + +struct wlfw_msa_ready_req_msg_v01 { + char placeholder; +}; +#define WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN 0 +extern struct elem_info wlfw_msa_ready_req_msg_v01_ei[]; + +struct wlfw_msa_ready_resp_msg_v01 { + struct qmi_response_type_v01 resp; +}; +#define WLFW_MSA_READY_RESP_MSG_V01_MAX_MSG_LEN 7 +extern struct elem_info wlfw_msa_ready_resp_msg_v01_ei[]; + +struct wlfw_ini_req_msg_v01 { + uint8_t enablefwlog_valid; + uint8_t enablefwlog; +}; +#define WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN 4 +extern struct elem_info wlfw_ini_req_msg_v01_ei[]; + +struct wlfw_ini_resp_msg_v01 { + struct qmi_response_type_v01 resp; +}; +#define WLFW_INI_RESP_MSG_V01_MAX_MSG_LEN 7 +extern struct elem_info wlfw_ini_resp_msg_v01_ei[]; + #endif diff --git a/include/soc/qcom/icnss.h b/include/soc/qcom/icnss.h index d1d677f6eaf5..14a22fd1b55f 100644 --- a/include/soc/qcom/icnss.h +++ b/include/soc/qcom/icnss.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -58,6 +58,13 @@ struct icnss_wlan_enable_cfg { struct icnss_shadow_reg_cfg *shadow_reg_cfg; }; +/* MSA Memory Regions Information */ +struct icnss_mem_region_info { + uint64_t reg_addr; + uint32_t size; + uint8_t secure_flag; +}; + /* driver modes */ enum icnss_driver_mode { ICNSS_MISSION, @@ -91,5 +98,6 @@ extern int icnss_ce_request_irq(unsigned int ce_id, irqreturn_t (*handler)(int, void *), unsigned long flags, const char *name, void *ctx); extern int icnss_get_ce_id(int irq); +extern int icnss_set_fw_debug_mode(bool enablefwlog); #endif /* _ICNSS_WLAN_H_ */