evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

icnss: Update WLFW QMI messages

Browse source 
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 <yuanliu@codeaurora.org>
This commit is contained in:
Yuanyuan Liu 2016-01-28 17:14:57 -08:00 • committed by Jeevan Shriram
parent 337f1c5c90
commit fee5dd5aba
5 changed files with 846 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Documentation/devicetree/bindings/cnss/icnss.txt
View file

@ -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>;
};

356
drivers/soc/qcom/icnss.c
View file

@ -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 <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/dma-mapping.h>
#include <linux/qmi_encdec.h>
#include <soc/qcom/memory_dump.h>
#include <soc/qcom/icnss.h>
@ -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__);

406
drivers/soc/qcom/wlan_firmware_service_v01.c
View file

@ -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,
},
};

140
drivers/soc/qcom/wlan_firmware_service_v01.h
View file

@ -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

10
include/soc/qcom/icnss.h
View file

@ -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_ */