ath11k: driver for Qualcomm IEEE 802.11ax devices
Subsystems (5)
PATCH v3 35/49 ath11k: add qmi.c
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/qmi.c | 2435 +++++++++++++++++++++++++++++++++ 1 file changed, 2435 insertions(+)
drivers/net/wireless/ath/ath11k/qmi.c new file +2435 -0
@@ -0,0 +1,2435 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ + +#include "qmi.h" +#include "core.h" +#include "debug.h" +#include <linux/of.h> +#include <linux/firmware.h> + +static struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = { + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + num_clients_valid), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + num_clients), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + wake_msi_valid), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + wake_msi), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + gpios_valid), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + gpios_len), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =QMI_WLFW_MAX_NUM_GPIO_V01 , + .elem_size =sizeof (u32), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + gpios), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + nm_modem_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + nm_modem), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + bdf_support_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + bdf_support), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + bdf_cache_support_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + bdf_cache_support), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x16 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + m3_support_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x16 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + m3_support), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x17 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + m3_cache_support_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x17 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + m3_cache_support), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x18 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + cal_filesys_support_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x18 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + cal_filesys_support), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x19 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + cal_cache_support_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x19 , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + cal_cache_support), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1A , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + cal_done_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1A , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + cal_done), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1B , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + mem_bucket_valid), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x1B , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + mem_bucket), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1C , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + mem_cfg_mode_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1C , + .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01 , + mem_cfg_mode), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_host_cap_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_host_cap_resp_msg_v01 , resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_ind_register_req_msg_v01_ei[] = { + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + fw_ready_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + fw_ready_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + initiate_cal_download_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + initiate_cal_download_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + initiate_cal_update_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + initiate_cal_update_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + msa_ready_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + msa_ready_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + pin_connect_result_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + pin_connect_result_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + client_id_valid), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + client_id), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x16 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + request_mem_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x16 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + request_mem_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x17 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + fw_mem_ready_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x17 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + fw_mem_ready_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x18 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + fw_init_done_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x18 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + fw_init_done_enable), + }, + + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x19 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + rejuvenate_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x19 , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + rejuvenate_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1A , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + xo_cal_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1A , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + xo_cal_enable), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1B , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + cal_done_enable_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x1B , + .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01 , + cal_done_enable), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_ind_register_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01 , + resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01 , + fw_status_valid), + }, + { + .data_type =QMI_UNSIGNED_8_BYTE , + .elem_len =1 , + .elem_size =sizeof (u64), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01 , + fw_status), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_mem_cfg_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_8_BYTE , + .elem_len =1 , + .elem_size =sizeof (u64), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01 , offset), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01 , size), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01 , secure_flag), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_mem_seg_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01 , + size), + }, + { + .data_type =QMI_SIGNED_4_BYTE_ENUM , + .elem_len =1 , + .elem_size =sizeof (enum qmi_wlanfw_mem_type_enum_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01 , type), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01 , mem_cfg_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =QMI_WLANFW_MAX_NUM_MEM_CFG_V01 , + .elem_size =sizeof (struct qmi_wlanfw_mem_cfg_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01 , mem_cfg), + .ei_array = qmi_wlanfw_mem_cfg_s_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_request_mem_ind_msg_v01_ei[] = { + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01 , + mem_seg_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 , + .elem_size =sizeof (struct qmi_wlanfw_mem_seg_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01 , + mem_seg), + .ei_array = qmi_wlanfw_mem_seg_s_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_mem_seg_resp_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_8_BYTE , + .elem_len =1 , + .elem_size =sizeof (u64), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01 , addr), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01 , size), + }, + { + .data_type =QMI_SIGNED_4_BYTE_ENUM , + .elem_len =1 , + .elem_size =sizeof (enum qmi_wlanfw_mem_type_enum_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01 , type), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01 , restore), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_respond_mem_req_msg_v01_ei[] = { + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01 , + mem_seg_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 , + .elem_size =sizeof (struct qmi_wlanfw_mem_seg_resp_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01 , + mem_seg), + .ei_array = qmi_wlanfw_mem_seg_resp_s_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_respond_mem_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_respond_mem_resp_msg_v01 , + resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_cap_req_msg_v01_ei[] = { + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_rf_chip_info_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01 , + chip_id), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01 , + chip_family), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_rf_board_info_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_rf_board_info_s_v01 , + board_id), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_soc_info_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_soc_info_s_v01 , soc_id), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_fw_version_info_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01 , + fw_version), + }, + { + .data_type =QMI_STRING , + .elem_len =ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 +1 , + .elem_size =sizeof (char ), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01 , + fw_build_timestamp), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_cap_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + chip_info_valid), + }, + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_wlanfw_rf_chip_info_s_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + chip_info), + .ei_array = qmi_wlanfw_rf_chip_info_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + board_info_valid), + }, + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_wlanfw_rf_board_info_s_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + board_info), + .ei_array = qmi_wlanfw_rf_board_info_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + soc_info_valid), + }, + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_wlanfw_soc_info_s_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + soc_info), + .ei_array = qmi_wlanfw_soc_info_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + fw_version_info_valid), + }, + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_wlanfw_fw_version_info_s_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + fw_version_info), + .ei_array = qmi_wlanfw_fw_version_info_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + fw_build_id_valid), + }, + { + .data_type =QMI_STRING , + .elem_len =ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 +1 , + .elem_size =sizeof (char ), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + fw_build_id), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + num_macs_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01 , + num_macs), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_bdf_download_req_msg_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + valid), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + file_id_valid), + }, + { + .data_type =QMI_SIGNED_4_BYTE_ENUM , + .elem_len =1 , + .elem_size =sizeof (enum qmi_wlanfw_cal_temp_id_enum_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + file_id), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + total_size_valid), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + total_size), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + seg_id_valid), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + seg_id), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + data_valid), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u16), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + data_len), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =QMI_WLANFW_MAX_DATA_SIZE_V01 , + .elem_size =sizeof (u8), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + data), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + end_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + end), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + bdf_type_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x15 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01 , + bdf_type), + }, + + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_bdf_download_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_bdf_download_resp_msg_v01 , + resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_m3_info_req_msg_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_8_BYTE , + .elem_len =1 , + .elem_size =sizeof (u64), + .array_type =NO_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01 , addr), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01 , size), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_m3_info_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_m3_info_resp_msg_v01 , resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 , + pipe_num), + }, + { + .data_type =QMI_SIGNED_4_BYTE_ENUM , + .elem_len =1 , + .elem_size =sizeof (enum qmi_wlanfw_pipedir_enum_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 , + pipe_dir), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 , + nentries), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 , + nbytes_max), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 , + flags), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01 , + service_id), + }, + { + .data_type =QMI_SIGNED_4_BYTE_ENUM , + .elem_len =1 , + .elem_size =sizeof (enum qmi_wlanfw_pipedir_enum_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01 , + pipe_dir), + }, + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01 , + pipe_num), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_shadow_reg_cfg_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_2_BYTE , + .elem_len =1 , + .elem_size =sizeof (u16), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01 , id), + }, + { + .data_type =QMI_UNSIGNED_2_BYTE , + .elem_len =1 , + .elem_size =sizeof (u16), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01 , + offset), + }, + { + .data_type =QMI_EOTI , + .array_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0 , + .offset = offsetof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01 , + addr), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_wlan_mode_req_msg_v01_ei[] = { + { + .data_type =QMI_UNSIGNED_4_BYTE , + .elem_len =1 , + .elem_size =sizeof (u32), + .array_type =NO_ARRAY , + .tlv_type =0x01 , + .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01 , + mode), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01 , + hw_debug_valid), + }, + { + .data_type =QMI_UNSIGNED_1_BYTE , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01 , + hw_debug), + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_wlan_mode_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_wlan_mode_resp_msg_v01 , + resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_wlan_cfg_req_msg_v01_ei[] = { + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + host_version_valid), + }, + { + .data_type =QMI_STRING , + .elem_len =QMI_WLANFW_MAX_STR_LEN_V01 +1 , + .elem_size =sizeof (char ), + .array_type =NO_ARRAY , + .tlv_type =0x10 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + host_version), + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + tgt_cfg_valid), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + tgt_cfg_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =QMI_WLANFW_MAX_NUM_CE_V01 , + .elem_size =sizeof ( +struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x11 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + tgt_cfg), + .ei_array = qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + svc_cfg_valid), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + svc_cfg_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =QMI_WLANFW_MAX_NUM_SVC_V01 , + .elem_size =sizeof (struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x12 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + svc_cfg), + .ei_array = qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + shadow_reg_valid), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + shadow_reg_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =QMI_WLANFW_MAX_NUM_SHADOW_REG_V01 , + .elem_size =sizeof (struct qmi_wlanfw_shadow_reg_cfg_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x13 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + shadow_reg), + .ei_array = qmi_wlanfw_shadow_reg_cfg_s_v01_ei, + }, + { + .data_type =QMI_OPT_FLAG , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + shadow_reg_v2_valid), + }, + { + .data_type =QMI_DATA_LEN , + .elem_len =1 , + .elem_size =sizeof (u8), + .array_type =NO_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + shadow_reg_v2_len), + }, + { + .data_type =QMI_STRUCT , + .elem_len =QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01 , + .elem_size =sizeof (struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01 ), + .array_type =VAR_LEN_ARRAY , + .tlv_type =0x14 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01 , + shadow_reg_v2), + .ei_array = qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_wlan_cfg_resp_msg_v01_ei[] = { + { + .data_type =QMI_STRUCT , + .elem_len =1 , + .elem_size =sizeof (struct qmi_response_type_v01 ), + .array_type =NO_ARRAY , + .tlv_type =0x02 , + .offset = offsetof(struct qmi_wlanfw_wlan_cfg_resp_msg_v01 , resp), + .ei_array = qmi_response_type_v01_ei, + }, + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + .tlv_type =QMI_COMMON_TLV_TYPE , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_mem_ready_ind_msg_v01_ei[] = { + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_fw_ready_ind_msg_v01_ei[] = { + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + }, +}; + +static struct qmi_elem_info qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei[] = { + { + .data_type =QMI_EOTI , + .array_type =NO_ARRAY , + }, +}; + +static int ath11k_qmi_host_cap_send (struct ath11k_base *ab) +{ +struct qmi_wlanfw_host_cap_req_msg_v01 req; +struct qmi_wlanfw_host_cap_resp_msg_v01 resp; +struct qmi_txn txn = {}; +int ret =0 ; + +memset (&req,0 ,sizeof (req)); +memset (&resp,0 ,sizeof (resp)); + + req.num_clients_valid =1 ; + req.num_clients =1 ; + req.mem_cfg_mode = ab->qmi.target_mem_mode; + req.mem_cfg_mode_valid =1 ; + req.bdf_support_valid =1 ; + req.bdf_support =1 ; + + req.m3_support_valid =0 ; + req.m3_support =0 ; + + req.m3_cache_support_valid =0 ; + req.m3_cache_support =0 ; + + req.cal_done_valid =1 ; + req.cal_done = ab->qmi.cal_done; + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_host_cap_resp_msg_v01_ei, &resp); +if (ret <0 ) + goto out; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_HOST_CAP_REQ_V01 , +QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_host_cap_req_msg_v01_ei, &req); +if (ret <0 ) { +ath11k_warn (ab,"Failed to send host capability request,err = %d\n" , ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) + goto out; + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"Host capability request failed, result: %d, err: %d\n" , + resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out; + } + +out: +return ret; +} + +static int ath11k_qmi_fw_ind_register_send (struct ath11k_base *ab) +{ +struct qmi_wlanfw_ind_register_req_msg_v01 *req; +struct qmi_wlanfw_ind_register_resp_msg_v01 *resp; +struct qmi_handle *handle = &ab->qmi.handle; +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) + goto resp_out; + + req->client_id_valid =1 ; + req->client_id =QMI_WLANFW_CLIENT_ID ; + req->fw_ready_enable_valid =1 ; + req->fw_ready_enable =1 ; + req->request_mem_enable_valid =1 ; + req->request_mem_enable =1 ; + req->fw_mem_ready_enable_valid =1 ; + req->fw_mem_ready_enable =1 ; + req->cal_done_enable_valid =1 ; + req->cal_done_enable =1 ; + req->fw_init_done_enable_valid =1 ; + req->fw_init_done_enable =1 ; + + req->pin_connect_result_enable_valid =0 ; + req->pin_connect_result_enable =0 ; + + ret =qmi_txn_init (handle, &txn, + qmi_wlanfw_ind_register_resp_msg_v01_ei, resp); +if (ret <0 ) + goto out; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_IND_REGISTER_REQ_V01 , +QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_ind_register_req_msg_v01_ei, req); +if (ret <0 ) { +ath11k_warn (ab,"Failed to send indication register request, err = %d\n" , + ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) { +ath11k_warn (ab,"failed to register fw indication %d\n" , ret); + goto out; + } + +if (resp->resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"FW Ind register request failed, result: %d, err: %d\n" , + resp->resp.result, resp->resp.error); + ret = -EINVAL ; + goto out; + } + +out: +kfree (resp); +resp_out: +kfree (req); +return ret; +} + +static int ath11k_qmi_respond_fw_mem_request (struct ath11k_base *ab) +{ +struct qmi_wlanfw_respond_mem_req_msg_v01 *req; +struct qmi_wlanfw_respond_mem_resp_msg_v01 resp; +struct qmi_txn txn = {}; +int ret =0 , i; + + req =kzalloc (sizeof (*req),GFP_KERNEL ); +if (!req) +return -ENOMEM ; + +memset (&resp,0 ,sizeof (resp)); + + req->mem_seg_len = ab->qmi.mem_seg_count; + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_respond_mem_resp_msg_v01_ei, &resp); +if (ret <0 ) + goto out; + +for (i =0 ; i < req->mem_seg_len ; i++) { + req->mem_seg[i].addr = ab->qmi.target_mem[i].paddr; + req->mem_seg[i].size = ab->qmi.target_mem[i].size; + req->mem_seg[i].type = ab->qmi.target_mem[i].type; + } + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_RESPOND_MEM_REQ_V01 , +QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_respond_mem_req_msg_v01_ei, req); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to respond memory request, err = %d\n" , + ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed memory request, err = %d\n" , ret); + goto out; + } + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"Respond mem req failed, result: %d, err: %d\n" , + resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out; + } +out: +kfree (req); +return ret; +} + +static int ath11k_qmi_alloc_target_mem_chunk (struct ath11k_base *ab) +{ +int i, idx; + +for (i =0 , idx =0 ; i < ab->qmi.mem_seg_count; i++) { +switch (ab->qmi.target_mem[i].type) { +case BDF_MEM_REGION_TYPE : + ab->qmi.target_mem[idx].paddr =ATH11K_QMI_BDF_ADDRESS ; + ab->qmi.target_mem[idx].vaddr =ATH11K_QMI_BDF_ADDRESS ; + ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size; + ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type; + idx++; +break ; +case CALDB_MEM_REGION_TYPE : +if (ab->qmi.target_mem[i].size >ATH11K_QMI_CALDB_SIZE ) { +ath11k_warn (ab,"qmi mem size is low to load caldata\n" ); +return -EINVAL ; + } +/* TODO ath11k does not support cold boot calibration */ + ab->qmi.target_mem[idx].paddr =0 ; + ab->qmi.target_mem[idx].vaddr =0 ; + ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size; + ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type; + idx++; +break ; +default : +ath11k_warn (ab,"qmi ignore invalid mem req type %d\n" , + ab->qmi.target_mem[i].type); +break ; + } + } + ab->qmi.mem_seg_count = idx; + +return 0 ; +} + +static int ath11k_qmi_request_target_cap (struct ath11k_base *ab) +{ +struct qmi_wlanfw_cap_req_msg_v01 req; +struct qmi_wlanfw_cap_resp_msg_v01 resp; +struct qmi_txn txn = {}; +int ret =0 ; + +memset (&req,0 ,sizeof (req)); +memset (&resp,0 ,sizeof (resp)); + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_cap_resp_msg_v01_ei, &resp); +if (ret <0 ) + goto out; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_CAP_REQ_V01 , +QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_cap_req_msg_v01_ei, &req); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send target cap request, err = %d\n" , + ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed target cap request %d\n" , ret); + goto out; + } + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"qmi targetcap req failed, result: %d, err: %d\n" , + resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out; + } + +if (resp.chip_info_valid) { + ab->qmi.target.chip_id = resp.chip_info.chip_id; + ab->qmi.target.chip_family = resp.chip_info.chip_family; + } + +if (resp.board_info_valid) + ab->qmi.target.board_id = resp.board_info.board_id; +else + ab->qmi.target.board_id =0xFF ; + +if (resp.soc_info_valid) + ab->qmi.target.soc_id = resp.soc_info.soc_id; + +if (resp.fw_version_info_valid) { + ab->qmi.target.fw_version = resp.fw_version_info.fw_version; +strlcpy (ab->qmi.target.fw_build_timestamp, + resp.fw_version_info.fw_build_timestamp, +sizeof (ab->qmi.target.fw_build_timestamp)); + } + +if (resp.fw_build_id_valid) +strlcpy (ab->qmi.target.fw_build_id, resp.fw_build_id, +sizeof (ab->qmi.target.fw_build_id)); + +ath11k_info (ab,"qmi target: chip_id: 0x%x, chip_family: 0x%x, board_id: 0x%x, soc_id: 0x%x\n" , + ab->qmi.target.chip_id, ab->qmi.target.chip_family, + ab->qmi.target.board_id, ab->qmi.target.soc_id); + +ath11k_info (ab,"qmi fw_version: 0x%x fw_build_timestamp: %s fw_build_id: %s" , + ab->qmi.target.fw_version, + ab->qmi.target.fw_build_timestamp, + ab->qmi.target.fw_build_id); + +out: +return ret; +} + +static int +ath11k_qmi_prepare_bdf_download (struct ath11k_base *ab,int type, +struct qmi_wlanfw_bdf_download_req_msg_v01 *req, +void __iomem *bdf_addr) +{ +struct device *dev = ab->dev; +char filename[ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE ]; +const struct firmware *fw_entry; +struct ath11k_board_data bd; +u32 fw_size; +int ret =0 ; + +memset (&bd,0 ,sizeof (bd)); + +switch (type) { +case ATH11K_QMI_FILE_TYPE_BDF_GOLDEN : + ret =ath11k_core_fetch_bdf (ab, &bd); +if (ret) { +ath11k_warn (ab,"qmi failed to load BDF\n" ); + goto out; + } + + fw_size =min_t (u32, ab->hw_params.fw.board_size, bd.len); +memcpy_toio (bdf_addr, bd.data, fw_size); +ath11k_core_free_bdf (ab, &bd); +break ; +case ATH11K_QMI_FILE_TYPE_CALDATA : +snprintf (filename,sizeof (filename), +"%s/%s" , ab->hw_params.fw.dir,ATH11K_QMI_DEFAULT_CAL_FILE_NAME ); + ret =request_firmware (&fw_entry, filename, dev); +if (ret) { +ath11k_warn (ab,"qmi failed to load CAL: %s\n" , filename); + goto out; + } + + fw_size =min_t (u32, ab->hw_params.fw.board_size, + fw_entry->size); + +memcpy_toio (bdf_addr +ATH11K_QMI_CALDATA_OFFSET , + fw_entry->data, fw_size); +ath11k_info (ab,"qmi downloading BDF: %s, size: %zu\n" , + filename, fw_entry->size); + +release_firmware (fw_entry); +break ; +default : + ret = -EINVAL ; + goto out; + } + + req->total_size = fw_size; + +out: +return ret; +} + +static int ath11k_qmi_load_bdf (struct ath11k_base *ab) +{ +struct qmi_wlanfw_bdf_download_req_msg_v01 *req; +struct qmi_wlanfw_bdf_download_resp_msg_v01 resp; +struct qmi_txn txn = {}; +void __iomem *bdf_addr =NULL ; +int type, ret; + + req =kzalloc (sizeof (*req),GFP_KERNEL ); +if (!req) +return -ENOMEM ; +memset (&resp,0 ,sizeof (resp)); + + bdf_addr =ioremap (ATH11K_QMI_BDF_ADDRESS ,ATH11K_QMI_BDF_MAX_SIZE ); +if (!bdf_addr) { +ath11k_warn (ab,"qmi ioremap error for BDF\n" ); + ret = -EIO ; + goto out; + } + +for (type =0 ; type <ATH11K_QMI_MAX_FILE_TYPE ; type++) { + req->valid =1 ; + req->file_id_valid =1 ; + req->file_id = ab->qmi.target.board_id; + req->total_size_valid =1 ; + req->seg_id_valid =1 ; + req->seg_id = type; + req->data_valid =0 ; + req->data_len =ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE ; + req->bdf_type =0 ; + req->bdf_type_valid =0 ; + req->end_valid =1 ; + req->end =1 ; + + ret =ath11k_qmi_prepare_bdf_download (ab, type, req, bdf_addr); +if (ret <0 ) + goto out_qmi_bdf; + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_bdf_download_resp_msg_v01_ei, + &resp); +if (ret <0 ) + goto out_qmi_bdf; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_BDF_DOWNLOAD_REQ_V01 , +QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_bdf_download_req_msg_v01_ei, req); +if (ret <0 ) { +qmi_txn_cancel (&txn); + goto out_qmi_bdf; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) + goto out_qmi_bdf; + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"qmi BDF download failed, result: %d, err: %d\n" , + resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out_qmi_bdf; + } + } +ath11k_info (ab,"qmi BDF downloaded\n" ); + +out_qmi_bdf: +iounmap (bdf_addr); +out: +kfree (req); +return ret; +} + +static int ath11k_qmi_wlanfw_m3_info_send (struct ath11k_base *ab) +{ +struct qmi_wlanfw_m3_info_req_msg_v01 req; +struct qmi_wlanfw_m3_info_resp_msg_v01 resp; +struct qmi_txn txn = {}; +int ret =0 ; + +memset (&req,0 ,sizeof (req)); +memset (&resp,0 ,sizeof (resp)); + req.addr =0 ; + req.size =0 ; + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_m3_info_resp_msg_v01_ei, &resp); +if (ret <0 ) + goto out; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_M3_INFO_REQ_V01 , +QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN , + qmi_wlanfw_m3_info_req_msg_v01_ei, &req); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send M3 information request, err = %d\n" , + ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed M3 information request %d\n" , ret); + goto out; + } + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"qmi M3 info request failed, result: %d, err: %d\n" , + resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out; + } +out: +return ret; +} + +static int ath11k_qmi_wlanfw_mode_send (struct ath11k_base *ab, +u32 mode) +{ +struct qmi_wlanfw_wlan_mode_req_msg_v01 req; +struct qmi_wlanfw_wlan_mode_resp_msg_v01 resp; +struct qmi_txn txn = {}; +int ret =0 ; + +memset (&req,0 ,sizeof (req)); +memset (&resp,0 ,sizeof (resp)); + + req.mode = mode; + req.hw_debug_valid =1 ; + req.hw_debug =0 ; + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_wlan_mode_resp_msg_v01_ei, &resp); +if (ret <0 ) + goto out; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_WLAN_MODE_REQ_V01 , +QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_wlan_mode_req_msg_v01_ei, &req); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send mode request, mode: %d, err = %d\n" , + mode, ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) { +if (mode ==ATH11K_FIRMWARE_MODE_OFF && ret == -ENETRESET ) { +ath11k_warn (ab,"WLFW service is dis-connected\n" ); +return 0 ; + } +ath11k_warn (ab,"qmi failed set mode request, mode: %d, err = %d\n" , + mode, ret); + goto out; + } + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"Mode request failed, mode: %d, result: %d err: %d\n" , + mode, resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out; + } + +out: +return ret; +} + +static int ath11k_qmi_wlanfw_wlan_cfg_send (struct ath11k_base *ab) +{ +struct qmi_wlanfw_wlan_cfg_req_msg_v01 *req; +struct qmi_wlanfw_wlan_cfg_resp_msg_v01 resp; +struct ce_pipe_config *ce_cfg; +struct service_to_pipe *svc_cfg; +struct qmi_txn txn = {}; +int ret =0 ; + + ce_cfg = (struct ce_pipe_config *)ab->qmi.ce_cfg.tgt_ce; + svc_cfg = (struct service_to_pipe *)ab->qmi.ce_cfg.svc_to_ce_map; + + req =kzalloc (sizeof (*req),GFP_KERNEL ); +if (!req) +return -ENOMEM ; + +memset (&resp,0 ,sizeof (resp)); + + req->host_version_valid =1 ; +strlcpy (req->host_version,ATH11K_HOST_VERSION_STRING , +sizeof (req->host_version)); + + req->tgt_cfg_valid =1 ; +/* This is number of CE configs */ + req->tgt_cfg_len = ((ab->qmi.ce_cfg.tgt_ce_len) / + (sizeof (struct ce_pipe_config ))) -1 ; +for (ret =0 ; ret <= req->tgt_cfg_len ; ret++) { + req->tgt_cfg[ret].pipe_num = ce_cfg[ret].pipenum; + req->tgt_cfg[ret].pipe_dir = ce_cfg[ret].pipedir; + req->tgt_cfg[ret].nentries = ce_cfg[ret].nentries; + req->tgt_cfg[ret].nbytes_max = ce_cfg[ret].nbytes_max; + req->tgt_cfg[ret].flags = ce_cfg[ret].flags; + } + + req->svc_cfg_valid =1 ; +/* This is number of Service/CE configs */ + req->svc_cfg_len = (ab->qmi.ce_cfg.svc_to_ce_map_len) / + (sizeof (struct service_to_pipe )); +for (ret =0 ; ret < req->svc_cfg_len; ret++) { + req->svc_cfg[ret].service_id = svc_cfg[ret].service_id; + req->svc_cfg[ret].pipe_dir = svc_cfg[ret].pipedir; + req->svc_cfg[ret].pipe_num = svc_cfg[ret].pipenum; + } + req->shadow_reg_valid =0 ; + req->shadow_reg_v2_valid =0 ; + + ret =qmi_txn_init (&ab->qmi.handle, &txn, + qmi_wlanfw_wlan_cfg_resp_msg_v01_ei, &resp); +if (ret <0 ) + goto out; + + ret =qmi_send_request (&ab->qmi.handle,NULL , &txn, +QMI_WLANFW_WLAN_CFG_REQ_V01 , +QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN , + qmi_wlanfw_wlan_cfg_req_msg_v01_ei, req); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send wlan config request, err = %d\n" , + ret); + goto out; + } + + ret =qmi_txn_wait (&txn,msecs_to_jiffies (ATH11K_QMI_WLANFW_TIMEOUT_MS )); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed wlan config request, err = %d\n" , ret); + goto out; + } + +if (resp.resp.result !=QMI_RESULT_SUCCESS_V01 ) { +ath11k_warn (ab,"qmi wlan config request failed, result: %d, err: %d\n" , + resp.resp.result, resp.resp.error); + ret = -EINVAL ; + goto out; + } + +out: +kfree (req); +return ret; +} + +void ath11k_qmi_firmware_stop (struct ath11k_base *ab) +{ +int ret; + + ret =ath11k_qmi_wlanfw_mode_send (ab,ATH11K_FIRMWARE_MODE_OFF ); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send wlan mode off\n" ); +return ; + } +} + +int ath11k_qmi_firmware_start (struct ath11k_base *ab, +u32 mode) +{ +int ret; + + ret =ath11k_qmi_wlanfw_wlan_cfg_send (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send wlan cfg:%d\n" , ret); +return ret; + } + + ret =ath11k_qmi_wlanfw_mode_send (ab, mode); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send wlan fw mode:%d\n" , ret); +return ret; + } + +return 0 ; +} + +static int +ath11k_qmi_driver_event_post (struct ath11k_qmi *qmi, +enum ath11k_qmi_event_type type, +void *data) +{ +struct ath11k_qmi_driver_event *event; + + event =kzalloc (sizeof (*event),GFP_ATOMIC ); +if (!event) +return -ENOMEM ; + + event->type = type; + event->data = data; + +spin_lock (&qmi->event_lock); +list_add_tail (&event->list, &qmi->event_list); +spin_unlock (&qmi->event_lock); + +queue_work (qmi->event_wq, &qmi->event_work); + +return 0 ; +} + +static void ath11k_qmi_event_server_arrive (struct ath11k_qmi *qmi) +{ +struct ath11k_base *ab = qmi->ab; +int ret; + + ret =ath11k_qmi_fw_ind_register_send (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send FW indication QMI:%d\n" , ret); +return ; + } + + ret =ath11k_qmi_host_cap_send (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send host cap QMI:%d\n" , ret); +return ; + } +} + +static void ath11k_qmi_event_mem_request (struct ath11k_qmi *qmi) +{ +struct ath11k_base *ab = qmi->ab; +int ret; + + ret =ath11k_qmi_respond_fw_mem_request (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to respond fw mem req:%d\n" , ret); +return ; + } +} + +static void ath11k_qmi_event_load_bdf (struct ath11k_qmi *qmi) +{ +struct ath11k_base *ab = qmi->ab; +int ret; + + ret =ath11k_qmi_request_target_cap (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to req target capabilities:%d\n" , ret); +return ; + } + + ret =ath11k_qmi_load_bdf (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to load board data file:%d\n" , ret); +return ; + } + + ret =ath11k_qmi_wlanfw_m3_info_send (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to send m3 info req:%d\n" , ret); +return ; + } +} + +static void ath11k_qmi_msg_mem_request_cb (struct qmi_handle *qmi_hdl, +struct sockaddr_qrtr *sq, +struct qmi_txn *txn, +const void *data) +{ + struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle); +struct ath11k_base *ab = qmi->ab; +const struct qmi_wlanfw_request_mem_ind_msg_v01 *msg = data; +int i, ret; + +ath11k_dbg (ab,ATH11K_DBG_QMI ,"qmi firmware request memory request\n" ); + +if (msg->mem_seg_len ==0 || + msg->mem_seg_len >ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 ) +ath11k_warn (ab,"Invalid memory segment length: %u\n" , + msg->mem_seg_len); + + ab->qmi.mem_seg_count = msg->mem_seg_len; + +for (i =0 ; i < qmi->mem_seg_count ; i++) { + ab->qmi.target_mem[i].type = msg->mem_seg[i].type; + ab->qmi.target_mem[i].size = msg->mem_seg[i].size; +ath11k_dbg (ab,ATH11K_DBG_QMI ,"qmi mem seg type %d size %d\n" , + msg->mem_seg[i].type, msg->mem_seg[i].size); + } + + ret =ath11k_qmi_alloc_target_mem_chunk (ab); +if (ret <0 ) { +ath11k_warn (ab,"qmi failed to alloc target memory:%d\n" , ret); +return ; + } + +ath11k_qmi_driver_event_post (qmi,ATH11K_QMI_EVENT_REQUEST_MEM ,NULL ); +} + +static void ath11k_qmi_msg_mem_ready_cb (struct qmi_handle *qmi_hdl, +struct sockaddr_qrtr *sq, +struct qmi_txn *txn, +const void *decoded) +{ + struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle); +struct ath11k_base *ab = qmi->ab; + +ath11k_dbg (ab,ATH11K_DBG_QMI ,"qmi firmware memory ready indication\n" ); +ath11k_qmi_driver_event_post (qmi,ATH11K_QMI_EVENT_FW_MEM_READY ,NULL ); +} + +static void ath11k_qmi_msg_fw_ready_cb (struct qmi_handle *qmi_hdl, +struct sockaddr_qrtr *sq, +struct qmi_txn *txn, +const void *decoded) +{ + struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle); +struct ath11k_base *ab = qmi->ab; + +ath11k_dbg (ab,ATH11K_DBG_QMI ,"qmi firmware ready\n" ); +ath11k_qmi_driver_event_post (qmi,ATH11K_QMI_EVENT_FW_READY ,NULL ); +} + +static void ath11k_qmi_msg_cold_boot_cal_done_cb (struct qmi_handle *qmi, +struct sockaddr_qrtr *sq, +struct qmi_txn *txn, +const void *decoded) +{ +} + +static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = { + { + .type =QMI_INDICATION , + .msg_id =QMI_WLFW_REQUEST_MEM_IND_V01 , + .ei = qmi_wlanfw_request_mem_ind_msg_v01_ei, + .decoded_size =sizeof (qmi_wlanfw_request_mem_ind_msg_v01_ei), + .fn = ath11k_qmi_msg_mem_request_cb, + }, + { + .type =QMI_INDICATION , + .msg_id =QMI_WLFW_FW_MEM_READY_IND_V01 , + .ei = qmi_wlanfw_mem_ready_ind_msg_v01_ei, + .decoded_size =sizeof (qmi_wlanfw_mem_ready_ind_msg_v01_ei), + .fn = ath11k_qmi_msg_mem_ready_cb, + }, + { + .type =QMI_INDICATION , + .msg_id =QMI_WLFW_FW_READY_IND_V01 , + .ei = qmi_wlanfw_fw_ready_ind_msg_v01_ei, + .decoded_size =sizeof (qmi_wlanfw_fw_ready_ind_msg_v01_ei), + .fn = ath11k_qmi_msg_fw_ready_cb, + }, + { + .type =QMI_INDICATION , + .msg_id =QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01 , + .ei = qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei, + .decoded_size = +sizeof (qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei), + .fn = ath11k_qmi_msg_cold_boot_cal_done_cb, + }, +}; + +static int ath11k_qmi_ops_new_server (struct qmi_handle *qmi_hdl, +struct qmi_service *service) +{ + struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle); +struct ath11k_base *ab = qmi->ab; +struct sockaddr_qrtr *sq = &qmi->sq; +int ret; + + sq->sq_family =AF_QIPCRTR ; + sq->sq_node = service->node; + sq->sq_port = service->port; + + ret =kernel_connect (qmi_hdl->sock, (struct sockaddr *)sq, +sizeof (*sq),0 ); +if (ret) { +ath11k_warn (ab,"qmi failed to connect to remote service %d\n" , ret); +return ret; + } + +ath11k_dbg (ab,ATH11K_DBG_QMI ,"qmi wifi fw qmi service connected\n" ); +ath11k_qmi_driver_event_post (qmi,ATH11K_QMI_EVENT_SERVER_ARRIVE ,NULL ); + +return 0 ; +} + +static void ath11k_qmi_ops_del_server (struct qmi_handle *qmi_hdl, +struct qmi_service *service) +{ + struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle); +struct ath11k_base *ab = qmi->ab; + +ath11k_dbg (ab,ATH11K_DBG_QMI ,"qmi wifi fw del server\n" ); +ath11k_qmi_driver_event_post (qmi,ATH11K_QMI_EVENT_SERVER_EXIT ,NULL ); +} + +static const struct qmi_ops ath11k_qmi_ops = { + .new_server = ath11k_qmi_ops_new_server, + .del_server = ath11k_qmi_ops_del_server, +}; + +static void ath11k_qmi_driver_event_work (struct work_struct *work) +{ + struct ath11k_qmi *qmi = container_of(work, struct ath11k_qmi, + event_work); +struct ath11k_qmi_driver_event *event; +struct ath11k_base *ab = qmi->ab; + +spin_lock (&qmi->event_lock); +while (!list_empty (&qmi->event_list)) { + event =list_first_entry (&qmi->event_list, + struct ath11k_qmi_driver_event, list); +list_del (&event->list); +spin_unlock (&qmi->event_lock); + +if (test_bit (ATH11K_FLAG_UNREGISTERING , &ab->dev_flags)) +return ; + +switch (event->type) { +case ATH11K_QMI_EVENT_SERVER_ARRIVE : +ath11k_qmi_event_server_arrive (qmi); +break ; +case ATH11K_QMI_EVENT_SERVER_EXIT : +set_bit (ATH11K_FLAG_CRASH_FLUSH , &ab->dev_flags); +set_bit (ATH11K_FLAG_RECOVERY , &ab->dev_flags); +break ; +case ATH11K_QMI_EVENT_REQUEST_MEM : +ath11k_qmi_event_mem_request (qmi); +break ; +case ATH11K_QMI_EVENT_FW_MEM_READY : +ath11k_qmi_event_load_bdf (qmi); +break ; +case ATH11K_QMI_EVENT_FW_READY : +if (test_bit (ATH11K_FLAG_REGISTERED , &ab->dev_flags)) { +queue_work (ab->workqueue, &ab->restart_work); +break ; + } + +ath11k_core_qmi_firmware_ready (ab); + ab->qmi.cal_done =1 ; +set_bit (ATH11K_FLAG_REGISTERED , &ab->dev_flags); + +break ; +case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE : +break ; +default : +ath11k_warn (ab,"invalid event type: %d" , event->type); +break ; + } +kfree (event); +spin_lock (&qmi->event_lock); + } +spin_unlock (&qmi->event_lock); +} + +int ath11k_qmi_init_service (struct ath11k_base *ab) +{ +int ret; + +memset (&ab->qmi.target,0 ,sizeof (struct target_info )); +memset (&ab->qmi.target_mem,0 ,sizeof (struct target_mem_chunk )); + ab->qmi.ab = ab; + + ab->qmi.target_mem_mode =ATH11K_QMI_TARGET_MEM_MODE_DEFAULT ; + ret =qmi_handle_init (&ab->qmi.handle,ATH11K_QMI_RESP_LEN_MAX , + &ath11k_qmi_ops, ath11k_qmi_msg_handlers); +if (ret <0 ) { +ath11k_warn (ab,"failed to initialize qmi handle\n" ); +return ret; + } + + ab->qmi.event_wq =alloc_workqueue ("ath11k_qmi_driver_event" , +WQ_UNBOUND ,1 ); +if (!ab->qmi.event_wq) { +ath11k_err (ab,"failed to allocate workqueue\n" ); +return -EFAULT ; + } + +INIT_LIST_HEAD (&ab->qmi.event_list); +spin_lock_init (&ab->qmi.event_lock); +INIT_WORK (&ab->qmi.event_work, ath11k_qmi_driver_event_work); + + ret =qmi_add_lookup (&ab->qmi.handle,ATH11K_QMI_WLFW_SERVICE_ID_V01 , +ATH11K_QMI_WLFW_SERVICE_VERS_V01 , +ATH11K_QMI_WLFW_SERVICE_INS_ID_V01 ); +if (ret <0 ) { +ath11k_warn (ab,"failed to add qmi lookup\n" ); +return ret; + } + +return ret; +} + +void ath11k_qmi_deinit_service (struct ath11k_base *ab) +{ +qmi_handle_release (&ab->qmi.handle); +cancel_work_sync (&ab->qmi.event_work); +destroy_workqueue (ab->qmi.event_wq); +} +
PATCH v3 36/49 ath11k: add qmi.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/qmi.h | 445 ++++++++++++++++++++++++++++++++++ 1 file changed, 445 insertions(+)
drivers/net/wireless/ath/ath11k/qmi.h new file +445 -0
@@ -0,0 +1,445 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ + +#ifndef ATH11K_QMI_H +#define ATH11K_QMI_H + +#include <linux/mutex.h> +#include <linux/soc/qcom/qmi.h> + +#define ATH11K_HOST_VERSION_STRING "WIN" +#define ATH11K_QMI_WLANFW_TIMEOUT_MS 5000 +#define ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE 64 +#define ATH11K_QMI_BDF_ADDRESS 0x4B0C0000 +#define ATH11K_QMI_BDF_MAX_SIZE (256 * 1024) +#define ATH11K_QMI_CALDATA_OFFSET (128 * 1024) +#define ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 128 +#define ATH11K_QMI_WLFW_SERVICE_ID_V01 0x45 +#define ATH11K_QMI_WLFW_SERVICE_VERS_V01 0x01 +#define ATH11K_QMI_WLFW_SERVICE_INS_ID_V01 0x02 +#define ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 32 +#define ATH11K_QMI_RESP_LEN_MAX 8192 +#define ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 32 +#define ATH11K_QMI_CALDB_SIZE 0x480000 +#define ATH11K_QMI_DEFAULT_CAL_FILE_NAME "caldata.bin" + +#define QMI_WLFW_REQUEST_MEM_IND_V01 0x0035 +#define QMI_WLFW_FW_MEM_READY_IND_V01 0x0037 +#define QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01 0x0021 +#define QMI_WLFW_FW_READY_IND_V01 0x0038 + +#define QMI_WLANFW_MAX_DATA_SIZE_V01 6144 +#define ATH11K_FIRMWARE_MODE_OFF 4 +#define ATH11K_QMI_TARGET_MEM_MODE_DEFAULT 0 + +struct ath11k_base ; + +enum ath11k_qmi_file_type { +ATH11K_QMI_FILE_TYPE_BDF_GOLDEN , +ATH11K_QMI_FILE_TYPE_CALDATA , +ATH11K_QMI_MAX_FILE_TYPE , +}; + +enum ath11k_qmi_event_type { +ATH11K_QMI_EVENT_SERVER_ARRIVE , +ATH11K_QMI_EVENT_SERVER_EXIT , +ATH11K_QMI_EVENT_REQUEST_MEM , +ATH11K_QMI_EVENT_FW_MEM_READY , +ATH11K_QMI_EVENT_FW_READY , +ATH11K_QMI_EVENT_COLD_BOOT_CAL_START , +ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE , +ATH11K_QMI_EVENT_REGISTER_DRIVER , +ATH11K_QMI_EVENT_UNREGISTER_DRIVER , +ATH11K_QMI_EVENT_RECOVERY , +ATH11K_QMI_EVENT_FORCE_FW_ASSERT , +ATH11K_QMI_EVENT_POWER_UP , +ATH11K_QMI_EVENT_POWER_DOWN , +ATH11K_QMI_EVENT_MAX , +}; + +struct ath11k_qmi_driver_event { +struct list_head list; +enum ath11k_qmi_event_type type; +void *data; +}; + +struct ath11k_qmi_ce_cfg { +const u8 *tgt_ce; +int tgt_ce_len; +const u8 *svc_to_ce_map; +int svc_to_ce_map_len; +const u8 *shadow_reg; +int shadow_reg_len; +u8 *shadow_reg_v2; +int shadow_reg_v2_len; +}; + +struct ath11k_qmi_event_msg { +struct list_head list; +enum ath11k_qmi_event_type type; +}; + +struct target_mem_chunk { +u32 size; +u32 type; +dma_addr_t paddr; +u32 vaddr; +}; + +struct target_info { +u32 chip_id; +u32 chip_family; +u32 board_id; +u32 soc_id; +u32 fw_version; +char fw_build_timestamp[ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 +1 ]; +char fw_build_id[ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 +1 ]; +}; + +struct ath11k_qmi { +struct ath11k_base *ab; +struct qmi_handle handle; +struct sockaddr_qrtr sq; +struct work_struct event_work; +struct workqueue_struct *event_wq; +struct list_head event_list; +spinlock_t event_lock;/* spinlock for qmi event list */ +struct ath11k_qmi_ce_cfg ce_cfg; +struct target_mem_chunk target_mem[ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 ]; +u32 mem_seg_count; +u32 target_mem_mode; +u8 cal_done; +struct target_info target; +}; + +#define QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN 189 +#define QMI_WLANFW_HOST_CAP_REQ_V01 0x0034 +#define QMI_WLANFW_HOST_CAP_RESP_MSG_V01_MAX_LEN 7 +#define QMI_WLFW_HOST_CAP_RESP_V01 0x0034 +#define QMI_WLFW_MAX_NUM_GPIO_V01 32 +#define QMI_IPQ8074_FW_MEM_MODE 0xFF +#define HOST_DDR_REGION_TYPE 0x1 +#define BDF_MEM_REGION_TYPE 0x2 +#define CALDB_MEM_REGION_TYPE 0x4 + +struct qmi_wlanfw_host_cap_req_msg_v01 { +u8 num_clients_valid; +u32 num_clients; +u8 wake_msi_valid; +u32 wake_msi; +u8 gpios_valid; +u32 gpios_len; +u32 gpios[QMI_WLFW_MAX_NUM_GPIO_V01 ]; +u8 nm_modem_valid; +u8 nm_modem; +u8 bdf_support_valid; +u8 bdf_support; +u8 bdf_cache_support_valid; +u8 bdf_cache_support; +u8 m3_support_valid; +u8 m3_support; +u8 m3_cache_support_valid; +u8 m3_cache_support; +u8 cal_filesys_support_valid; +u8 cal_filesys_support; +u8 cal_cache_support_valid; +u8 cal_cache_support; +u8 cal_done_valid; +u8 cal_done; +u8 mem_bucket_valid; +u32 mem_bucket; +u8 mem_cfg_mode_valid; +u8 mem_cfg_mode; +}; + +struct qmi_wlanfw_host_cap_resp_msg_v01 { +struct qmi_response_type_v01 resp; +}; + +#define QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN 54 +#define QMI_WLANFW_IND_REGISTER_REQ_V01 0x0020 +#define QMI_WLANFW_IND_REGISTER_RESP_MSG_V01_MAX_LEN 18 +#define QMI_WLANFW_IND_REGISTER_RESP_V01 0x0020 +#define QMI_WLANFW_CLIENT_ID 0x4b4e454c + +struct qmi_wlanfw_ind_register_req_msg_v01 { +u8 fw_ready_enable_valid; +u8 fw_ready_enable; +u8 initiate_cal_download_enable_valid; +u8 initiate_cal_download_enable; +u8 initiate_cal_update_enable_valid; +u8 initiate_cal_update_enable; +u8 msa_ready_enable_valid; +u8 msa_ready_enable; +u8 pin_connect_result_enable_valid; +u8 pin_connect_result_enable; +u8 client_id_valid; +u32 client_id; +u8 request_mem_enable_valid; +u8 request_mem_enable; +u8 fw_mem_ready_enable_valid; +u8 fw_mem_ready_enable; +u8 fw_init_done_enable_valid; +u8 fw_init_done_enable; +u8 rejuvenate_enable_valid; +u32 rejuvenate_enable; +u8 xo_cal_enable_valid; +u8 xo_cal_enable; +u8 cal_done_enable_valid; +u8 cal_done_enable; +}; + +struct qmi_wlanfw_ind_register_resp_msg_v01 { +struct qmi_response_type_v01 resp; +u8 fw_status_valid; +u64 fw_status; +}; + +#define QMI_WLANFW_REQUEST_MEM_IND_MSG_V01_MAX_LEN 1124 +#define QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN 548 +#define QMI_WLANFW_RESPOND_MEM_RESP_MSG_V01_MAX_LEN 7 +#define QMI_WLANFW_REQUEST_MEM_IND_V01 0x0035 +#define QMI_WLANFW_RESPOND_MEM_REQ_V01 0x0036 +#define QMI_WLANFW_RESPOND_MEM_RESP_V01 0x0036 +#define QMI_WLANFW_MAX_NUM_MEM_CFG_V01 2 + +struct qmi_wlanfw_mem_cfg_s_v01 { +u64 offset; +u32 size; +u8 secure_flag; +}; + +enum qmi_wlanfw_mem_type_enum_v01 { +WLANFW_MEM_TYPE_ENUM_MIN_VAL_V01 =INT_MIN , +QMI_WLANFW_MEM_TYPE_MSA_V01 =0 , +QMI_WLANFW_MEM_TYPE_DDR_V01 =1 , +QMI_WLANFW_MEM_BDF_V01 =2 , +QMI_WLANFW_MEM_M3_V01 =3 , +QMI_WLANFW_MEM_CAL_V01 =4 , +QMI_WLANFW_MEM_DPD_V01 =5 , +WLANFW_MEM_TYPE_ENUM_MAX_VAL_V01 =INT_MAX , +}; + +struct qmi_wlanfw_mem_seg_s_v01 { +u32 size; +enum qmi_wlanfw_mem_type_enum_v01 type; +u32 mem_cfg_len; +struct qmi_wlanfw_mem_cfg_s_v01 mem_cfg[QMI_WLANFW_MAX_NUM_MEM_CFG_V01 ]; +}; + +struct qmi_wlanfw_request_mem_ind_msg_v01 { +u32 mem_seg_len; +struct qmi_wlanfw_mem_seg_s_v01 mem_seg[ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 ]; +}; + +struct qmi_wlanfw_mem_seg_resp_s_v01 { +u64 addr; +u32 size; +enum qmi_wlanfw_mem_type_enum_v01 type; +u8 restore; +}; + +struct qmi_wlanfw_respond_mem_req_msg_v01 { +u32 mem_seg_len; +struct qmi_wlanfw_mem_seg_resp_s_v01 mem_seg[ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01 ]; +}; + +struct qmi_wlanfw_respond_mem_resp_msg_v01 { +struct qmi_response_type_v01 resp; +}; + +struct qmi_wlanfw_fw_mem_ready_ind_msg_v01 { +char placeholder; +}; + +#define QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN 0 +#define QMI_WLANFW_CAP_RESP_MSG_V01_MAX_LEN 207 +#define QMI_WLANFW_CAP_REQ_V01 0x0024 +#define QMI_WLANFW_CAP_RESP_V01 0x0024 + +enum qmi_wlanfw_pipedir_enum_v01 { +QMI_WLFW_PIPEDIR_NONE_V01 =0 , +QMI_WLFW_PIPEDIR_IN_V01 =1 , +QMI_WLFW_PIPEDIR_OUT_V01 =2 , +QMI_WLFW_PIPEDIR_INOUT_V01 =3 , +}; + +struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 { +__le32 pipe_num; +__le32 pipe_dir; +__le32 nentries; +__le32 nbytes_max; +__le32 flags; +}; + +struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01 { +__le32 service_id; +__le32 pipe_dir; +__le32 pipe_num; +}; + +struct qmi_wlanfw_shadow_reg_cfg_s_v01 { +u16 id; +u16 offset; +}; + +struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01 { +u32 addr; +}; + +struct qmi_wlanfw_memory_region_info_s_v01 { +u64 region_addr; +u32 size; +u8 secure_flag; +}; + +struct qmi_wlanfw_rf_chip_info_s_v01 { +u32 chip_id; +u32 chip_family; +}; + +struct qmi_wlanfw_rf_board_info_s_v01 { +u32 board_id; +}; + +struct qmi_wlanfw_soc_info_s_v01 { +u32 soc_id; +}; + +struct qmi_wlanfw_fw_version_info_s_v01 { +u32 fw_version; +char fw_build_timestamp[ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 +1 ]; +}; + +enum qmi_wlanfw_cal_temp_id_enum_v01 { +QMI_WLANFW_CAL_TEMP_IDX_0_V01 =0 , +QMI_WLANFW_CAL_TEMP_IDX_1_V01 =1 , +QMI_WLANFW_CAL_TEMP_IDX_2_V01 =2 , +QMI_WLANFW_CAL_TEMP_IDX_3_V01 =3 , +QMI_WLANFW_CAL_TEMP_IDX_4_V01 =4 , +QMI_WLANFW_CAL_TEMP_ID_MAX_V01 =0xFF , +}; + +struct qmi_wlanfw_cap_resp_msg_v01 { +struct qmi_response_type_v01 resp; +u8 chip_info_valid; +struct qmi_wlanfw_rf_chip_info_s_v01 chip_info; +u8 board_info_valid; +struct qmi_wlanfw_rf_board_info_s_v01 board_info; +u8 soc_info_valid; +struct qmi_wlanfw_soc_info_s_v01 soc_info; +u8 fw_version_info_valid; +struct qmi_wlanfw_fw_version_info_s_v01 fw_version_info; +u8 fw_build_id_valid; +char fw_build_id[ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 +1 ]; +u8 num_macs_valid; +u8 num_macs; +}; + +struct qmi_wlanfw_cap_req_msg_v01 { +char placeholder; +}; + +#define QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN 6182 +#define QMI_WLANFW_BDF_DOWNLOAD_RESP_MSG_V01_MAX_LEN 7 +#define QMI_WLANFW_BDF_DOWNLOAD_RESP_V01 0x0025 +#define QMI_WLANFW_BDF_DOWNLOAD_REQ_V01 0x0025 +/* TODO: Need to check with MCL and FW team that data can be pointer and +* can be last element in structure +*/ +struct qmi_wlanfw_bdf_download_req_msg_v01 { +u8 valid; +u8 file_id_valid; +enum qmi_wlanfw_cal_temp_id_enum_v01 file_id; +u8 total_size_valid; +u32 total_size; +u8 seg_id_valid; +u32 seg_id; +u8 data_valid; +u32 data_len; +u8 data[QMI_WLANFW_MAX_DATA_SIZE_V01 ]; +u8 end_valid; +u8 end; +u8 bdf_type_valid; +u8 bdf_type; + +}; + +struct qmi_wlanfw_bdf_download_resp_msg_v01 { +struct qmi_response_type_v01 resp; +}; + +#define QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN 18 +#define QMI_WLANFW_M3_INFO_RESP_MSG_V01_MAX_MSG_LEN 7 +#define QMI_WLANFW_M3_INFO_RESP_V01 0x003C +#define QMI_WLANFW_M3_INFO_REQ_V01 0x003C + +struct qmi_wlanfw_m3_info_req_msg_v01 { +u64 addr; +u32 size; +}; + +struct qmi_wlanfw_m3_info_resp_msg_v01 { +struct qmi_response_type_v01 resp; +}; + +#define QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN 11 +#define QMI_WLANFW_WLAN_MODE_RESP_MSG_V01_MAX_LEN 7 +#define QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN 803 +#define QMI_WLANFW_WLAN_CFG_RESP_MSG_V01_MAX_LEN 7 +#define QMI_WLANFW_WLAN_MODE_REQ_V01 0x0022 +#define QMI_WLANFW_WLAN_MODE_RESP_V01 0x0022 +#define QMI_WLANFW_WLAN_CFG_REQ_V01 0x0023 +#define QMI_WLANFW_WLAN_CFG_RESP_V01 0x0023 +#define QMI_WLANFW_MAX_STR_LEN_V01 16 +#define QMI_WLANFW_MAX_NUM_CE_V01 12 +#define QMI_WLANFW_MAX_NUM_SVC_V01 24 +#define QMI_WLANFW_MAX_NUM_SHADOW_REG_V01 24 +#define QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01 36 + +struct qmi_wlanfw_wlan_mode_req_msg_v01 { +u32 mode; +u8 hw_debug_valid; +u8 hw_debug; +}; + +struct qmi_wlanfw_wlan_mode_resp_msg_v01 { +struct qmi_response_type_v01 resp; +}; + +struct qmi_wlanfw_wlan_cfg_req_msg_v01 { +u8 host_version_valid; +char host_version[QMI_WLANFW_MAX_STR_LEN_V01 +1 ]; +u8 tgt_cfg_valid; +u32 tgt_cfg_len; +struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01 + tgt_cfg[QMI_WLANFW_MAX_NUM_CE_V01 ]; +u8 svc_cfg_valid; +u32 svc_cfg_len; +struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01 + svc_cfg[QMI_WLANFW_MAX_NUM_SVC_V01 ]; +u8 shadow_reg_valid; +u32 shadow_reg_len; +struct qmi_wlanfw_shadow_reg_cfg_s_v01 + shadow_reg[QMI_WLANFW_MAX_NUM_SHADOW_REG_V01 ]; +u8 shadow_reg_v2_valid; +u32 shadow_reg_v2_len; +struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01 + shadow_reg_v2[QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01 ]; +}; + +struct qmi_wlanfw_wlan_cfg_resp_msg_v01 { +struct qmi_response_type_v01 resp; +}; + +int ath11k_qmi_firmware_start (struct ath11k_base *ab, +u32 mode); +void ath11k_qmi_firmware_stop (struct ath11k_base *ab); +void ath11k_qmi_event_work (struct work_struct *work); +void ath11k_qmi_msg_recv_work (struct work_struct *work); +void ath11k_qmi_deinit_service (struct ath11k_base *ab); +int ath11k_qmi_init_service (struct ath11k_base *ab); + +#endif
PATCH v3 37/49 ath11k: add reg.c
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/reg.c | 701 ++++++++++++++++++++++++++++++++++ 1 file changed, 701 insertions(+)
drivers/net/wireless/ath/ath11k/reg.c new file +701 -0
@@ -0,0 +1,701 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ +#include "core.h" +#include "debug.h" + +/* World regdom to be used in case default regd from fw is unavailable */ +#define ATH11K_2GHZ_CH01_11 REG_RULE(2412 - 10, 2462 + 10, 40, 0, 20, 0) +#define ATH11K_5GHZ_5150_5350 REG_RULE(5150 - 10, 5350 + 10, 80, 0, 30,\ + NL80211_RRF_NO_IR) +#define ATH11K_5GHZ_5725_5850 REG_RULE(5725 - 10, 5850 + 10, 80, 0, 30,\ + NL80211_RRF_NO_IR) + +#define ETSI_WEATHER_RADAR_BAND_LOW 5590 +#define ETSI_WEATHER_RADAR_BAND_HIGH 5650 +#define ETSI_WEATHER_RADAR_BAND_CAC_TIMEOUT 600000 + +static const struct ieee80211_regdomain ath11k_world_regd = { + .n_reg_rules =3 , + .alpha2 ="00" , + .reg_rules = { +ATH11K_2GHZ_CH01_11 , +ATH11K_5GHZ_5150_5350 , +ATH11K_5GHZ_5725_5850 , + } +}; + +static bool ath11k_regdom_changes (struct ath11k *ar,char *alpha2) +{ +const struct ieee80211_regdomain *regd; + + regd =rcu_dereference_rtnl (ar->hw->wiphy->regd); +/* This can happen during wiphy registration where the previous +* user request is received before we update the regd received +* from firmware. +*/ +if (!regd) +return true; + +return memcmp (regd->alpha2, alpha2,2 ) !=0 ; +} + +static void +ath11k_reg_notifier (struct wiphy *wiphy,struct regulatory_request *request) +{ +struct ieee80211_hw *hw =wiphy_to_ieee80211_hw (wiphy); +struct wmi_init_country_params init_country_param; +struct ath11k *ar = hw->priv; +int ret; + +ath11k_dbg (ar->ab,ATH11K_DBG_REG , +"Regulatory Notification received for %s\n" ,wiphy_name (wiphy)); + +/* Currently supporting only General User Hints. Cell base user +* hints to be handled later. +* Hints from other sources like Core, Beacons are not expected for +* self managed wiphy's +*/ +if (!(request->initiator ==NL80211_REGDOM_SET_BY_USER && + request->user_reg_hint_type ==NL80211_USER_REG_HINT_USER )) { +ath11k_warn (ar->ab,"Unexpected Regulatory event for this wiphy\n" ); +return ; + } + +if (!IS_ENABLED (CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS )) { +ath11k_dbg (ar->ab,ATH11K_DBG_REG , +"Country Setting is not allowed\n" ); +return ; + } + +if (!ath11k_regdom_changes (ar, request->alpha2)) { +ath11k_dbg (ar->ab,ATH11K_DBG_REG ,"Country is already set\n" ); +return ; + } + +/* Set the country code to the firmware and wait for +* the WMI_REG_CHAN_LIST_CC EVENT for updating the +* reg info +*/ + init_country_param.flags =ALPHA_IS_SET ; +memcpy (&init_country_param.cc_info.alpha2, request->alpha2,2 ); + + ret =ath11k_wmi_send_init_country_cmd (ar, init_country_param); +if (ret) +ath11k_warn (ar->ab, +"INIT Country code set to fw failed : %d\n" , ret); +} + +int ath11k_reg_update_chan_list (struct ath11k *ar) +{ +struct ieee80211_supported_band **bands; +struct scan_chan_list_params *params; +struct ieee80211_channel *channel; +struct ieee80211_hw *hw = ar->hw; +struct channel_param *ch; +enum nl80211_band band; +int num_channels =0 ; +int params_len; +int i, ret; + + bands = hw->wiphy->bands; +for (band =0 ; band <NUM_NL80211_BANDS ; band++) { +if (!bands[band]) +continue ; + +for (i =0 ; i < bands[band]->n_channels; i++) { +if (bands[band]->channels[i].flags & +IEEE80211_CHAN_DISABLED ) +continue ; + + num_channels++; + } + } + +if (WARN_ON (!num_channels)) +return -EINVAL ; + + params_len =sizeof (struct scan_chan_list_params ) + + num_channels *sizeof (struct channel_param ); + params =kzalloc (params_len,GFP_KERNEL ); + +if (!params) +return -ENOMEM ; + + params->pdev_id = ar->pdev->pdev_id; + params->nallchans = num_channels; + + ch = params->ch_param; + +for (band =0 ; band <NUM_NL80211_BANDS ; band++) { +if (!bands[band]) +continue ; + +for (i =0 ; i < bands[band]->n_channels; i++) { + channel = &bands[band]->channels[i]; + +if (channel->flags &IEEE80211_CHAN_DISABLED ) +continue ; + +/* TODO: Set to true/false based on some condition? */ + ch->allow_ht = true; + ch->allow_vht = true; + + ch->dfs_set = + !!(channel->flags &IEEE80211_CHAN_RADAR ); + ch->is_chan_passive = !!(channel->flags & +IEEE80211_CHAN_NO_IR ); + ch->is_chan_passive |= ch->dfs_set; + ch->mhz = channel->center_freq; + ch->cfreq1 = channel->center_freq; + ch->minpower =0 ; + ch->maxpower = channel->max_power *2 ; + ch->maxregpower = channel->max_reg_power *2 ; + ch->antennamax = channel->max_antenna_gain *2 ; + +/* TODO: Use appropriate phymodes */ +if (channel->band ==NL80211_BAND_2GHZ ) + ch->phy_mode =MODE_11G ; +else + ch->phy_mode =MODE_11A ; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"mac channel [%d/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n" , + i, params->nallchans, + ch->mhz, ch->maxpower, ch->maxregpower, + ch->antennamax, ch->phy_mode); + + ch++; +/* TODO: use quarrter/half rate, cfreq12, dfs_cfreq2 +* set_agile, reg_class_idx +*/ + } + } + + ret =ath11k_wmi_send_scan_chan_list_cmd (ar, params); +kfree (params); + +return ret; +} + +static void ath11k_copy_regd (struct ieee80211_regdomain *regd_orig, +struct ieee80211_regdomain *regd_copy) +{ +u8 i; + +/* The caller should have checked error conditions */ +memcpy (regd_copy, regd_orig,sizeof (*regd_orig)); + +for (i =0 ; i < regd_orig->n_reg_rules; i++) +memcpy (®d_copy->reg_rules[i], ®d_orig->reg_rules[i], +sizeof (struct ieee80211_reg_rule )); +} + +int ath11k_regd_update (struct ath11k *ar,bool init) +{ +struct ieee80211_regdomain *regd, *regd_copy =NULL ; +int ret, regd_len, pdev_id; +struct ath11k_base *ab; + + ab = ar->ab; + pdev_id = ar->pdev_idx; + +spin_lock (&ab->base_lock); + +if (init) { +/* Apply the regd received during init through +* WMI_REG_CHAN_LIST_CC event. In case of failure to +* receive the regd, initialize with a default world +* regulatory. +*/ +if (ab->default_regd[pdev_id]) { + regd = ab->default_regd[pdev_id]; + }else { +ath11k_warn (ab, +"failed to receive default regd during init\n" ); + regd = (struct ieee80211_regdomain *)&ath11k_world_regd; + } + }else { + regd = ab->new_regd[pdev_id]; + } + +if (!regd) { + ret = -EINVAL ; +spin_unlock (&ab->base_lock); + goto err; + } + + regd_len =sizeof (*regd) + (regd->n_reg_rules * +sizeof (struct ieee80211_reg_rule )); + + regd_copy =kzalloc (regd_len,GFP_ATOMIC ); +if (regd_copy) +ath11k_copy_regd (regd, regd_copy); + +spin_unlock (&ab->base_lock); + +if (!regd_copy) { + ret = -ENOMEM ; + goto err; + } + +rtnl_lock (); + ret =regulatory_set_wiphy_regd_sync_rtnl (ar->hw->wiphy, regd_copy); +rtnl_unlock (); + +kfree (regd_copy); + +if (ret) + goto err; + +if (ar->state ==ATH11K_STATE_ON ) { + ret =ath11k_reg_update_chan_list (ar); +if (ret) + goto err; + } + +return 0 ; +err: +ath11k_warn (ab,"failed to perform regd update : %d\n" , ret); +return ret; +} + +static enum nl80211_dfs_regions +ath11k_map_fw_dfs_region (enum ath11k_dfs_region dfs_region) +{ +switch (dfs_region) { +case ATH11K_DFS_REG_FCC : +case ATH11K_DFS_REG_CN : +return NL80211_DFS_FCC ; +case ATH11K_DFS_REG_ETSI : +case ATH11K_DFS_REG_KR : +return NL80211_DFS_ETSI ; +case ATH11K_DFS_REG_MKK : +return NL80211_DFS_JP ; +default : +return NL80211_DFS_UNSET ; + } +} + +static u32 ath11k_map_fw_reg_flags (u16 reg_flags) +{ +u32 flags =0 ; + +if (reg_flags ®ULATORY_CHAN_NO_IR ) + flags =NL80211_RRF_NO_IR ; + +if (reg_flags ®ULATORY_CHAN_RADAR ) + flags |=NL80211_RRF_DFS ; + +if (reg_flags ®ULATORY_CHAN_NO_OFDM ) + flags |=NL80211_RRF_NO_OFDM ; + +if (reg_flags ®ULATORY_CHAN_INDOOR_ONLY ) + flags |=NL80211_RRF_NO_OUTDOOR ; + +if (reg_flags ®ULATORY_CHAN_NO_HT40 ) + flags |=NL80211_RRF_NO_HT40 ; + +if (reg_flags ®ULATORY_CHAN_NO_80MHZ ) + flags |=NL80211_RRF_NO_80MHZ ; + +if (reg_flags ®ULATORY_CHAN_NO_160MHZ ) + flags |=NL80211_RRF_NO_160MHZ ; + +return flags; +} + +static bool +ath11k_reg_can_intersect (struct ieee80211_reg_rule *rule1, +struct ieee80211_reg_rule *rule2) +{ +u32 start_freq1, end_freq1; +u32 start_freq2, end_freq2; + + start_freq1 = rule1->freq_range.start_freq_khz; + start_freq2 = rule2->freq_range.start_freq_khz; + + end_freq1 = rule1->freq_range.end_freq_khz; + end_freq2 = rule2->freq_range.end_freq_khz; + +if ((start_freq1 >= start_freq2 && + start_freq1 < end_freq2) || + (start_freq2 > start_freq1 && + start_freq2 < end_freq1)) +return true; + +/* TODO: Should we restrict intersection feasibility +* based on min bandwidth of the intersected region also, +* say the intersected rule should have a min bandwidth +* of 20MHz? +*/ + +return false; +} + +static void ath11k_reg_intersect_rules (struct ieee80211_reg_rule *rule1, +struct ieee80211_reg_rule *rule2, +struct ieee80211_reg_rule *new_rule) +{ +u32 start_freq1, end_freq1; +u32 start_freq2, end_freq2; +u32 freq_diff, max_bw; + + start_freq1 = rule1->freq_range.start_freq_khz; + start_freq2 = rule2->freq_range.start_freq_khz; + + end_freq1 = rule1->freq_range.end_freq_khz; + end_freq2 = rule2->freq_range.end_freq_khz; + + new_rule->freq_range.start_freq_khz =max_t (u32, start_freq1, + start_freq2); + new_rule->freq_range.end_freq_khz =min_t (u32, end_freq1, end_freq2); + + freq_diff = new_rule->freq_range.end_freq_khz - + new_rule->freq_range.start_freq_khz; + max_bw =min_t (u32, rule1->freq_range.max_bandwidth_khz, + rule2->freq_range.max_bandwidth_khz); + new_rule->freq_range.max_bandwidth_khz =min_t (u32, max_bw, freq_diff); + + new_rule->power_rule.max_antenna_gain = +min_t (u32, rule1->power_rule.max_antenna_gain, + rule2->power_rule.max_antenna_gain); + + new_rule->power_rule.max_eirp =min_t (u32, rule1->power_rule.max_eirp, + rule2->power_rule.max_eirp); + +/* Use the flags of both the rules */ + new_rule->flags = rule1->flags | rule2->flags; + +/* To be safe, lts use the max cac timeout of both rules */ + new_rule->dfs_cac_ms =max_t (u32, rule1->dfs_cac_ms, + rule2->dfs_cac_ms); +} + +static struct ieee80211_regdomain * +ath11k_regd_intersect (struct ieee80211_regdomain *default_regd, +struct ieee80211_regdomain *curr_regd) +{ +u8 num_old_regd_rules, num_curr_regd_rules, num_new_regd_rules; +struct ieee80211_reg_rule *old_rule, *curr_rule, *new_rule; +struct ieee80211_regdomain *new_regd =NULL ; +u8 i, j, k; + + num_old_regd_rules = default_regd->n_reg_rules; + num_curr_regd_rules = curr_regd->n_reg_rules; + num_new_regd_rules =0 ; + +/* Find the number of intersecting rules to allocate new regd memory */ +for (i =0 ; i < num_old_regd_rules; i++) { + old_rule = default_regd->reg_rules + i; +for (j =0 ; j < num_curr_regd_rules; j++) { + curr_rule = curr_regd->reg_rules + j; + +if (ath11k_reg_can_intersect (old_rule, curr_rule)) + num_new_regd_rules++; + } + } + +if (!num_new_regd_rules) +return NULL ; + + new_regd =kzalloc (sizeof (*new_regd) + (num_new_regd_rules * +sizeof (struct ieee80211_reg_rule )), +GFP_ATOMIC ); + +if (!new_regd) +return NULL ; + +/* We set the new country and dfs region directly and only trim +* the freq, power, antenna gain by intersecting with the +* default regdomain. Also MAX of the dfs cac timeout is selected. +*/ + new_regd->n_reg_rules = num_new_regd_rules; +memcpy (new_regd->alpha2, curr_regd->alpha2,sizeof (new_regd->alpha2)); + new_regd->dfs_region = curr_regd->dfs_region; + new_rule = new_regd->reg_rules; + +for (i =0 , k =0 ; i < num_old_regd_rules; i++) { + old_rule = default_regd->reg_rules + i; +for (j =0 ; j < num_curr_regd_rules; j++) { + curr_rule = curr_regd->reg_rules + j; + +if (ath11k_reg_can_intersect (old_rule, curr_rule)) +ath11k_reg_intersect_rules (old_rule, curr_rule, + (new_rule + k++)); + } + } +return new_regd; +} + +static const char * +ath11k_reg_get_regdom_str (enum nl80211_dfs_regions dfs_region) +{ +switch (dfs_region) { +case NL80211_DFS_FCC : +return "FCC" ; +case NL80211_DFS_ETSI : +return "ETSI" ; +case NL80211_DFS_JP : +return "JP" ; +default : +return "UNSET" ; + } +} + +static u16 +ath11k_reg_adjust_bw (u16 start_freq,u16 end_freq,u16 max_bw) +{ +u16 bw; + + bw = end_freq - start_freq; + bw =min_t (u16, bw, max_bw); + +if (bw >=80 && bw <160 ) + bw =80 ; +else if (bw >=40 && bw <80 ) + bw =40 ; +else if (bw <40 ) + bw =20 ; + +return bw; +} + +static void +ath11k_reg_update_rule (struct ieee80211_reg_rule *reg_rule,u32 start_freq, +u32 end_freq,u32 bw,u32 ant_gain,u32 reg_pwr, +u32 reg_flags) +{ + reg_rule->freq_range.start_freq_khz =MHZ_TO_KHZ (start_freq); + reg_rule->freq_range.end_freq_khz =MHZ_TO_KHZ (end_freq); + reg_rule->freq_range.max_bandwidth_khz =MHZ_TO_KHZ (bw); + reg_rule->power_rule.max_antenna_gain =DBI_TO_MBI (ant_gain); + reg_rule->power_rule.max_eirp =DBM_TO_MBM (reg_pwr); + reg_rule->flags = reg_flags; +} + +static void +ath11k_reg_update_weather_radar_band (struct ath11k_base *ab, +struct ieee80211_regdomain *regd, +struct cur_reg_rule *reg_rule, +u8 *rule_idx,u32 flags,u16 max_bw) +{ +u32 end_freq; +u16 bw; +u8 i; + + i = *rule_idx; + + bw =ath11k_reg_adjust_bw (reg_rule->start_freq, +ETSI_WEATHER_RADAR_BAND_LOW , max_bw); + +ath11k_reg_update_rule (regd->reg_rules + i, reg_rule->start_freq, +ETSI_WEATHER_RADAR_BAND_LOW , bw, + reg_rule->ant_gain, reg_rule->reg_power, + flags); + +ath11k_dbg (ab,ATH11K_DBG_REG , +"\t%d. (%d - %d @ %d) (%d, %d) (%d ms) (FLAGS %d)\n" , + i +1 , reg_rule->start_freq,ETSI_WEATHER_RADAR_BAND_LOW , + bw, reg_rule->ant_gain, reg_rule->reg_power, + regd->reg_rules[i].dfs_cac_ms, + flags); + +if (reg_rule->end_freq >ETSI_WEATHER_RADAR_BAND_HIGH ) + end_freq =ETSI_WEATHER_RADAR_BAND_HIGH ; +else + end_freq = reg_rule->end_freq; + + bw =ath11k_reg_adjust_bw (ETSI_WEATHER_RADAR_BAND_LOW , end_freq, + max_bw); + + i++; + +ath11k_reg_update_rule (regd->reg_rules + i, +ETSI_WEATHER_RADAR_BAND_LOW , end_freq, bw, + reg_rule->ant_gain, reg_rule->reg_power, + flags); + + regd->reg_rules[i].dfs_cac_ms =ETSI_WEATHER_RADAR_BAND_CAC_TIMEOUT ; + +ath11k_dbg (ab,ATH11K_DBG_REG , +"\t%d. (%d - %d @ %d) (%d, %d) (%d ms) (FLAGS %d)\n" , + i +1 ,ETSI_WEATHER_RADAR_BAND_LOW , end_freq, + bw, reg_rule->ant_gain, reg_rule->reg_power, + regd->reg_rules[i].dfs_cac_ms, + flags); + +if (end_freq == reg_rule->end_freq) { + regd->n_reg_rules--; + *rule_idx = i; +return ; + } + + bw =ath11k_reg_adjust_bw (ETSI_WEATHER_RADAR_BAND_HIGH , + reg_rule->end_freq, max_bw); + + i++; + +ath11k_reg_update_rule (regd->reg_rules + i,ETSI_WEATHER_RADAR_BAND_HIGH , + reg_rule->end_freq, bw, + reg_rule->ant_gain, reg_rule->reg_power, + flags); + +ath11k_dbg (ab,ATH11K_DBG_REG , +"\t%d. (%d - %d @ %d) (%d, %d) (%d ms) (FLAGS %d)\n" , + i +1 ,ETSI_WEATHER_RADAR_BAND_HIGH , reg_rule->end_freq, + bw, reg_rule->ant_gain, reg_rule->reg_power, + regd->reg_rules[i].dfs_cac_ms, + flags); + + *rule_idx = i; +} + +struct ieee80211_regdomain * +ath11k_reg_build_regd (struct ath11k_base *ab, +struct cur_regulatory_info *reg_info,bool intersect) +{ +struct ieee80211_regdomain *tmp_regd, *default_regd, *new_regd =NULL ; +struct cur_reg_rule *reg_rule; +u8 i =0 , j =0 ; +u8 num_rules; +u16 max_bw; +u32 flags; +char alpha2[3 ]; + + num_rules = reg_info->num_5g_reg_rules + reg_info->num_2g_reg_rules; + +if (!num_rules) + goto ret; + +/* Add max additional rules to accommodate weather radar band */ +if (reg_info->dfs_region ==ATH11K_DFS_REG_ETSI ) + num_rules +=2 ; + + tmp_regd =kzalloc (sizeof (*tmp_regd) + + (num_rules *sizeof (struct ieee80211_reg_rule )), +GFP_ATOMIC ); +if (!tmp_regd) + goto ret; + + tmp_regd->n_reg_rules = num_rules; +memcpy (tmp_regd->alpha2, reg_info->alpha2,REG_ALPHA2_LEN +1 ); +memcpy (alpha2, reg_info->alpha2,REG_ALPHA2_LEN +1 ); + alpha2[2 ] ='\0' ; + tmp_regd->dfs_region =ath11k_map_fw_dfs_region (reg_info->dfs_region); + +ath11k_dbg (ab,ATH11K_DBG_REG , +"\r\nCountry %s, CFG Regdomain %s FW Regdomain %d, num_reg_rules %d\n" , + alpha2,ath11k_reg_get_regdom_str (tmp_regd->dfs_region), + reg_info->dfs_region, num_rules); +/* Update reg_rules[] below. Firmware is expected to +* send these rules in order(2G rules first and then 5G) +*/ +for (; i < tmp_regd->n_reg_rules; i++) { +if (reg_info->num_2g_reg_rules && + (i < reg_info->num_2g_reg_rules)) { + reg_rule = reg_info->reg_rules_2g_ptr + i; + max_bw =min_t (u16, reg_rule->max_bw, + reg_info->max_bw_2g); + flags =0 ; + }else if (reg_info->num_5g_reg_rules && + (j < reg_info->num_5g_reg_rules)) { + reg_rule = reg_info->reg_rules_5g_ptr + j++; + max_bw =min_t (u16, reg_rule->max_bw, + reg_info->max_bw_5g); + +/* FW doesn't pass NL80211_RRF_AUTO_BW flag for +* BW Auto correction, we can enable this by default +* for all 5G rules here. The regulatory core performs +* BW correction if required and applies flags as +* per other BW rule flags we pass from here +*/ + flags =NL80211_RRF_AUTO_BW ; + }else { +break ; + } + + flags |=ath11k_map_fw_reg_flags (reg_rule->flags); + +ath11k_reg_update_rule (tmp_regd->reg_rules + i, + reg_rule->start_freq, + reg_rule->end_freq, max_bw, + reg_rule->ant_gain, reg_rule->reg_power, + flags); + +/* Update dfs cac timeout if the dfs domain is ETSI and the +* new rule covers weather radar band. +* Default value of '0' corresponds to 60s timeout, so no +* need to update that for other rules. +*/ +if (flags &NL80211_RRF_DFS && + reg_info->dfs_region ==ATH11K_DFS_REG_ETSI && + (reg_rule->end_freq >ETSI_WEATHER_RADAR_BAND_LOW && + reg_rule->start_freq <ETSI_WEATHER_RADAR_BAND_HIGH )){ +ath11k_reg_update_weather_radar_band (ab, tmp_regd, + reg_rule, &i, + flags, max_bw); +continue ; + } + +ath11k_dbg (ab,ATH11K_DBG_REG , +"\t%d. (%d - %d @ %d) (%d, %d) (%d ms) (FLAGS %d)\n" , + i +1 , reg_rule->start_freq, reg_rule->end_freq, + max_bw, reg_rule->ant_gain, reg_rule->reg_power, + tmp_regd->reg_rules[i].dfs_cac_ms, + flags); + } + +if (intersect) { + default_regd = ab->default_regd[reg_info->phy_id]; + +/* Get a new regd by intersecting the received regd with +* our default regd. +*/ + new_regd =ath11k_regd_intersect (default_regd, tmp_regd); +kfree (tmp_regd); +if (!new_regd) { +ath11k_warn (ab,"Unable to create intersected regdomain\n" ); + goto ret; + } + }else { + new_regd = tmp_regd; + } + +ret: +return new_regd; +} + +void ath11k_regd_update_work (struct work_struct *work) +{ + struct ath11k *ar = container_of(work, struct ath11k, + regd_update_work); +int ret; + + ret =ath11k_regd_update (ar, false); +if (ret) { +/* Firmware has already moved to the new regd. We need +* to maintain channel consistency across FW, Host driver +* and userspace. Hence as a fallback mechanism we can set +* the prev or default country code to the firmware. +*/ +/* TODO: Implement Fallback Mechanism */ + } +} + +void ath11k_reg_init (struct ath11k *ar) +{ + ar->hw->wiphy->regulatory_flags =REGULATORY_WIPHY_SELF_MANAGED ; + ar->hw->wiphy->reg_notifier = ath11k_reg_notifier; +} + +void ath11k_reg_free (struct ath11k_base *ab) +{ +int i; + +for (i =0 ; i <MAX_RADIOS ; i++) { +kfree (ab->default_regd[i]); +kfree (ab->new_regd[i]); + } +}
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
PATCH v3 38/49 ath11k: add reg.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/reg.h | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+)
drivers/net/wireless/ath/ath11k/reg.h new file +35 -0
@@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2019 The Linux Foundation. All rights reserved. +*/ + +#ifndef ATH11K_REG_H +#define ATH11K_REG_H + +#include <linux/kernel.h> +#include <net/regulatory.h> + +struct ath11k_base ; +struct ath11k ; + +/* DFS regdomains supported by Firmware */ +enum ath11k_dfs_region { +ATH11K_DFS_REG_UNSET , +ATH11K_DFS_REG_FCC , +ATH11K_DFS_REG_ETSI , +ATH11K_DFS_REG_MKK , +ATH11K_DFS_REG_CN , +ATH11K_DFS_REG_KR , +ATH11K_DFS_REG_UNDEF , +}; + +/* ATH11K Regulatory API's */ +void ath11k_reg_init (struct ath11k *ar); +void ath11k_reg_free (struct ath11k_base *ab); +void ath11k_regd_update_work (struct work_struct *work); +struct ieee80211_regdomain * +ath11k_reg_build_regd (struct ath11k_base *ab, +struct cur_regulatory_info *reg_info,bool intersect); +int ath11k_regd_update (struct ath11k *ar,bool init); +int ath11k_reg_update_chan_list (struct ath11k *ar); +#endif
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
PATCH v3 39/49 ath11k: add rx_desc.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/rx_desc.h | 1212 +++++++++++++++++++++++++++++ 1 file changed, 1212 insertions(+)
drivers/net/wireless/ath/ath11k/rx_desc.h new file +1212 -0
@@ -0,0 +1,1212 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ +#ifndef ATH11K_RX_DESC_H +#define ATH11K_RX_DESC_H + +enum rx_desc_rxpcu_filter { +RX_DESC_RXPCU_FILTER_PASS , +RX_DESC_RXPCU_FILTER_MONITOR_CLIENT , +RX_DESC_RXPCU_FILTER_MONITOR_OTHER , +}; + +/* rxpcu_filter_pass +* This MPDU passed the normal frame filter programming of rxpcu. +* +* rxpcu_filter_monitor_client +* This MPDU did not pass the regular frame filter and would +* have been dropped, were it not for the frame fitting into the +* 'monitor_client' category. +* +* rxpcu_filter_monitor_other +* This MPDU did not pass the regular frame filter and also did +* not pass the rxpcu_monitor_client filter. It would have been +* dropped accept that it did pass the 'monitor_other' category. +*/ + +#define RX_DESC_INFO0_RXPCU_MPDU_FITLER GENMASK(1, 0) +#define RX_DESC_INFO0_SW_FRAME_GRP_ID GENMASK(8, 2) + +enum rx_desc_sw_frame_grp_id { +RX_DESC_SW_FRAME_GRP_ID_NDP_FRAME , +RX_DESC_SW_FRAME_GRP_ID_MCAST_DATA , +RX_DESC_SW_FRAME_GRP_ID_UCAST_DATA , +RX_DESC_SW_FRAME_GRP_ID_NULL_DATA , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0000 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0001 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0010 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0011 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0100 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0101 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0110 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_0111 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1000 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1001 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1010 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1011 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1100 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1101 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1110 , +RX_DESC_SW_FRAME_GRP_ID_MGMT_1111 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0000 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0001 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0010 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0011 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0100 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0101 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0110 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_0111 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1000 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1001 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1010 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1011 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1100 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1101 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1110 , +RX_DESC_SW_FRAME_GRP_ID_CTRL_1111 , +RX_DESC_SW_FRAME_GRP_ID_UNSUPPORTED , +RX_DESC_SW_FRAME_GRP_ID_PHY_ERR , +}; + +enum rx_desc_decap_type { +RX_DESC_DECAP_TYPE_RAW , +RX_DESC_DECAP_TYPE_NATIVE_WIFI , +RX_DESC_DECAP_TYPE_ETHERNET2_DIX , +RX_DESC_DECAP_TYPE_8023 , +}; + +enum rx_desc_decrypt_status_code { +RX_DESC_DECRYPT_STATUS_CODE_OK , +RX_DESC_DECRYPT_STATUS_CODE_UNPROTECTED_FRAME , +RX_DESC_DECRYPT_STATUS_CODE_DATA_ERR , +RX_DESC_DECRYPT_STATUS_CODE_KEY_INVALID , +RX_DESC_DECRYPT_STATUS_CODE_PEER_ENTRY_INVALID , +RX_DESC_DECRYPT_STATUS_CODE_OTHER , +}; + +#define RX_ATTENTION_INFO1_FIRST_MPDU BIT(0) +#define RX_ATTENTION_INFO1_RSVD_1A BIT(1) +#define RX_ATTENTION_INFO1_MCAST_BCAST BIT(2) +#define RX_ATTENTION_INFO1_AST_IDX_NOT_FOUND BIT(3) +#define RX_ATTENTION_INFO1_AST_IDX_TIMEDOUT BIT(4) +#define RX_ATTENTION_INFO1_POWER_MGMT BIT(5) +#define RX_ATTENTION_INFO1_NON_QOS BIT(6) +#define RX_ATTENTION_INFO1_NULL_DATA BIT(7) +#define RX_ATTENTION_INFO1_MGMT_TYPE BIT(8) +#define RX_ATTENTION_INFO1_CTRL_TYPE BIT(9) +#define RX_ATTENTION_INFO1_MORE_DATA BIT(10) +#define RX_ATTENTION_INFO1_EOSP BIT(11) +#define RX_ATTENTION_INFO1_A_MSDU_ERROR BIT(12) +#define RX_ATTENTION_INFO1_FRAGMENT BIT(13) +#define RX_ATTENTION_INFO1_ORDER BIT(14) +#define RX_ATTENTION_INFO1_CCE_MATCH BIT(15) +#define RX_ATTENTION_INFO1_OVERFLOW_ERR BIT(16) +#define RX_ATTENTION_INFO1_MSDU_LEN_ERR BIT(17) +#define RX_ATTENTION_INFO1_TCP_UDP_CKSUM_FAIL BIT(18) +#define RX_ATTENTION_INFO1_IP_CKSUM_FAIL BIT(19) +#define RX_ATTENTION_INFO1_SA_IDX_INVALID BIT(20) +#define RX_ATTENTION_INFO1_DA_IDX_INVALID BIT(21) +#define RX_ATTENTION_INFO1_RSVD_1B BIT(22) +#define RX_ATTENTION_INFO1_RX_IN_TX_DECRYPT_BYP BIT(23) +#define RX_ATTENTION_INFO1_ENCRYPT_REQUIRED BIT(24) +#define RX_ATTENTION_INFO1_DIRECTED BIT(25) +#define RX_ATTENTION_INFO1_BUFFER_FRAGMENT BIT(26) +#define RX_ATTENTION_INFO1_MPDU_LEN_ERR BIT(27) +#define RX_ATTENTION_INFO1_TKIP_MIC_ERR BIT(28) +#define RX_ATTENTION_INFO1_DECRYPT_ERR BIT(29) +#define RX_ATTENTION_INFO1_UNDECRYPT_FRAME_ERR BIT(30) +#define RX_ATTENTION_INFO1_FCS_ERR BIT(31) + +#define RX_ATTENTION_INFO2_FLOW_IDX_TIMEOUT BIT(0) +#define RX_ATTENTION_INFO2_FLOW_IDX_INVALID BIT(1) +#define RX_ATTENTION_INFO2_WIFI_PARSER_ERR BIT(2) +#define RX_ATTENTION_INFO2_AMSDU_PARSER_ERR BIT(3) +#define RX_ATTENTION_INFO2_SA_IDX_TIMEOUT BIT(4) +#define RX_ATTENTION_INFO2_DA_IDX_TIMEOUT BIT(5) +#define RX_ATTENTION_INFO2_MSDU_LIMIT_ERR BIT(6) +#define RX_ATTENTION_INFO2_DA_IS_VALID BIT(7) +#define RX_ATTENTION_INFO2_DA_IS_MCBC BIT(8) +#define RX_ATTENTION_INFO2_SA_IS_VALID BIT(9) +#define RX_ATTENTION_INFO2_DCRYPT_STATUS_CODE GENMASK(12, 10) +#define RX_ATTENTION_INFO2_RX_BITMAP_NOT_UPDED BIT(13) +#define RX_ATTENTION_INFO2_MSDU_DONE BIT(31) + +struct rx_attention { +__le16 info0; +__le16 phy_ppdu_id; +__le32 info1; +__le32 info2; +} __packed; + +/* rx_attention +* +* rxpcu_mpdu_filter_in_category +* Field indicates what the reason was that this mpdu frame +* was allowed to come into the receive path by rxpcu. Values +* are defined in enum %RX_DESC_RXPCU_FILTER_*. +* +* sw_frame_group_id +* SW processes frames based on certain classifications. Values +* are defined in enum %RX_DESC_SW_FRAME_GRP_ID_*. +* +* phy_ppdu_id +* A ppdu counter value that PHY increments for every PPDU +* received. The counter value wraps around. +* +* first_mpdu +* Indicates the first MSDU of the PPDU. If both first_mpdu +* and last_mpdu are set in the MSDU then this is a not an +* A-MPDU frame but a stand alone MPDU. Interior MPDU in an +* A-MPDU shall have both first_mpdu and last_mpdu bits set to +* 0. The PPDU start status will only be valid when this bit +* is set. +* +* mcast_bcast +* Multicast / broadcast indicator. Only set when the MAC +* address 1 bit 0 is set indicating mcast/bcast and the BSSID +* matches one of the 4 BSSID registers. Only set when +* first_msdu is set. +* +* ast_index_not_found +* Only valid when first_msdu is set. Indicates no AST matching +* entries within the the max search count. +* +* ast_index_timeout +* Only valid when first_msdu is set. Indicates an unsuccessful +* search in the address search table due to timeout. +* +* power_mgmt +* Power management bit set in the 802.11 header. Only set +* when first_msdu is set. +* +* non_qos +* Set if packet is not a non-QoS data frame. Only set when +* first_msdu is set. +* +* null_data +* Set if frame type indicates either null data or QoS null +* data format. Only set when first_msdu is set. +* +* mgmt_type +* Set if packet is a management packet. Only set when +* first_msdu is set. +* +* ctrl_type +* Set if packet is a control packet. Only set when first_msdu +* is set. +* +* more_data +* Set if more bit in frame control is set. Only set when +* first_msdu is set. +* +* eosp +* Set if the EOSP (end of service period) bit in the QoS +* control field is set. Only set when first_msdu is set. +* +* a_msdu_error +* Set if number of MSDUs in A-MSDU is above a threshold or if the +* size of the MSDU is invalid. This receive buffer will contain +* all of the remainder of MSDUs in this MPDU w/o decapsulation. +* +* fragment +* Indicates that this is an 802.11 fragment frame. This is +* set when either the more_frag bit is set in the frame +* control or the fragment number is not zero. Only set when +* first_msdu is set. +* +* order +* Set if the order bit in the frame control is set. Only set +* when first_msdu is set. +* +* cce_match +* Indicates that this status has a corresponding MSDU that +* requires FW processing. The OLE will have classification +* ring mask registers which will indicate the ring(s) for +* packets and descriptors which need FW attention. +* +* overflow_err +* PCU Receive FIFO does not have enough space to store the +* full receive packet. Enough space is reserved in the +* receive FIFO for the status is written. This MPDU remaining +* packets in the PPDU will be filtered and no Ack response +* will be transmitted. +* +* msdu_length_err +* Indicates that the MSDU length from the 802.3 encapsulated +* length field extends beyond the MPDU boundary. +* +* tcp_udp_chksum_fail +* Indicates that the computed checksum (tcp_udp_chksum) did +* not match the checksum in the TCP/UDP header. +* +* ip_chksum_fail +* Indicates that the computed checksum did not match the +* checksum in the IP header. +* +* sa_idx_invalid +* Indicates no matching entry was found in the address search +* table for the source MAC address. +* +* da_idx_invalid +* Indicates no matching entry was found in the address search +* table for the destination MAC address. +* +* rx_in_tx_decrypt_byp +* Indicates that RX packet is not decrypted as Crypto is busy +* with TX packet processing. +* +* encrypt_required +* Indicates that this data type frame is not encrypted even if +* the policy for this MPDU requires encryption as indicated in +* the peer table key type. +* +* directed +* MPDU is a directed packet which means that the RA matched +* our STA addresses. In proxySTA it means that the TA matched +* an entry in our address search table with the corresponding +* 'no_ack' bit is the address search entry cleared. +* +* buffer_fragment +* Indicates that at least one of the rx buffers has been +* fragmented. If set the FW should look at the rx_frag_info +* descriptor described below. +* +* mpdu_length_err +* Indicates that the MPDU was pre-maturely terminated +* resulting in a truncated MPDU. Don't trust the MPDU length +* field. +* +* tkip_mic_err +* Indicates that the MPDU Michael integrity check failed +* +* decrypt_err +* Indicates that the MPDU decrypt integrity check failed +* +* fcs_err +* Indicates that the MPDU FCS check failed +* +* flow_idx_timeout +* Indicates an unsuccessful flow search due to the expiring of +* the search timer. +* +* flow_idx_invalid +* flow id is not valid. +* +* amsdu_parser_error +* A-MSDU could not be properly de-agregated. +* +* sa_idx_timeout +* Indicates an unsuccessful search for the source MAC address +* due to the expiring of the search timer. +* +* da_idx_timeout +* Indicates an unsuccessful search for the destination MAC +* address due to the expiring of the search timer. +* +* msdu_limit_error +* Indicates that the MSDU threshold was exceeded and thus +* all the rest of the MSDUs will not be scattered and will not +* be decasulated but will be DMA'ed in RAW format as a single +* MSDU buffer. +* +* da_is_valid +* Indicates that OLE found a valid DA entry. +* +* da_is_mcbc +* Field Only valid if da_is_valid is set. Indicates the DA address +* was a Multicast or Broadcast address. +* +* sa_is_valid +* Indicates that OLE found a valid SA entry. +* +* decrypt_status_code +* Field provides insight into the decryption performed. Values are +* defined in enum %RX_DESC_DECRYPT_STATUS_CODE*. +* +* rx_bitmap_not_updated +* Frame is received, but RXPCU could not update the receive bitmap +* due to (temporary) fifo constraints. +* +* msdu_done +* If set indicates that the RX packet data, RX header data, RX +* PPDU start descriptor, RX MPDU start/end descriptor, RX MSDU +* start/end descriptors and RX Attention descriptor are all +* valid. This bit must be in the last octet of the +* descriptor. +*/ + +#define RX_MPDU_START_INFO0_NDP_FRAME BIT(9) +#define RX_MPDU_START_INFO0_PHY_ERR BIT(10) +#define RX_MPDU_START_INFO0_PHY_ERR_MPDU_HDR BIT(11) +#define RX_MPDU_START_INFO0_PROTO_VER_ERR BIT(12) +#define RX_MPDU_START_INFO0_AST_LOOKUP_VALID BIT(13) + +#define RX_MPDU_START_INFO1_MPDU_CTRL_VALID BIT(0) +#define RX_MPDU_START_INFO1_MPDU_DUR_VALID BIT(1) +#define RX_MPDU_START_INFO1_MAC_ADDR1_VALID BIT(2) +#define RX_MPDU_START_INFO1_MAC_ADDR2_VALID BIT(3) +#define RX_MPDU_START_INFO1_MAC_ADDR3_VALID BIT(4) +#define RX_MPDU_START_INFO1_MAC_ADDR4_VALID BIT(5) +#define RX_MPDU_START_INFO1_MPDU_SEQ_CTRL_VALID BIT(6) +#define RX_MPDU_START_INFO1_MPDU_QOS_CTRL_VALID BIT(7) +#define RX_MPDU_START_INFO1_MPDU_HT_CTRL_VALID BIT(8) +#define RX_MPDU_START_INFO1_ENCRYPT_INFO_VALID BIT(9) +#define RX_MPDU_START_INFO1_MPDU_FRAG_NUMBER GENMASK(13, 10) +#define RX_MPDU_START_INFO1_MORE_FRAG_FLAG BIT(14) +#define RX_MPDU_START_INFO1_FROM_DS BIT(16) +#define RX_MPDU_START_INFO1_TO_DS BIT(17) +#define RX_MPDU_START_INFO1_ENCRYPTED BIT(18) +#define RX_MPDU_START_INFO1_MPDU_RETRY BIT(19) +#define RX_MPDU_START_INFO1_MPDU_SEQ_NUM GENMASK(31, 20) + +#define RX_MPDU_START_INFO2_EPD_EN BIT(0) +#define RX_MPDU_START_INFO2_ALL_FRAME_ENCPD BIT(1) +#define RX_MPDU_START_INFO2_ENC_TYPE GENMASK(5, 2) +#define RX_MPDU_START_INFO2_VAR_WEP_KEY_WIDTH GENMASK(7, 6) +#define RX_MPDU_START_INFO2_MESH_STA BIT(8) +#define RX_MPDU_START_INFO2_BSSID_HIT BIT(9) +#define RX_MPDU_START_INFO2_BSSID_NUM GENMASK(13, 10) +#define RX_MPDU_START_INFO2_TID GENMASK(17, 14) + +#define RX_MPDU_START_INFO3_REO_DEST_IND GENMASK(4, 0) +#define RX_MPDU_START_INFO3_FLOW_ID_TOEPLITZ BIT(7) +#define RX_MPDU_START_INFO3_PKT_SEL_FP_UCAST_DATA BIT(8) +#define RX_MPDU_START_INFO3_PKT_SEL_FP_MCAST_DATA BIT(9) +#define RX_MPDU_START_INFO3_PKT_SEL_FP_CTRL_BAR BIT(10) +#define RX_MPDU_START_INFO3_RXDMA0_SRC_RING_SEL GENMASK(12, 11) +#define RX_MPDU_START_INFO3_RXDMA0_DST_RING_SEL GENMASK(14, 13) + +#define RX_MPDU_START_INFO4_REO_QUEUE_DESC_HI GENMASK(7, 0) +#define RX_MPDU_START_INFO4_RECV_QUEUE_NUM GENMASK(23, 8) +#define RX_MPDU_START_INFO4_PRE_DELIM_ERR_WARN BIT(24) +#define RX_MPDU_START_INFO4_FIRST_DELIM_ERR BIT(25) + +#define RX_MPDU_START_INFO5_KEY_ID GENMASK(7, 0) +#define RX_MPDU_START_INFO5_NEW_PEER_ENTRY BIT(8) +#define RX_MPDU_START_INFO5_DECRYPT_NEEDED BIT(9) +#define RX_MPDU_START_INFO5_DECAP_TYPE GENMASK(11, 10) +#define RX_MPDU_START_INFO5_VLAN_TAG_C_PADDING BIT(12) +#define RX_MPDU_START_INFO5_VLAN_TAG_S_PADDING BIT(13) +#define RX_MPDU_START_INFO5_STRIP_VLAN_TAG_C BIT(14) +#define RX_MPDU_START_INFO5_STRIP_VLAN_TAG_S BIT(15) +#define RX_MPDU_START_INFO5_PRE_DELIM_COUNT GENMASK(27, 16) +#define RX_MPDU_START_INFO5_AMPDU_FLAG BIT(28) +#define RX_MPDU_START_INFO5_BAR_FRAME BIT(29) + +#define RX_MPDU_START_INFO6_MPDU_LEN GENMASK(13, 0) +#define RX_MPDU_START_INFO6_FIRST_MPDU BIT(14) +#define RX_MPDU_START_INFO6_MCAST_BCAST BIT(15) +#define RX_MPDU_START_INFO6_AST_IDX_NOT_FOUND BIT(16) +#define RX_MPDU_START_INFO6_AST_IDX_TIMEOUT BIT(17) +#define RX_MPDU_START_INFO6_POWER_MGMT BIT(18) +#define RX_MPDU_START_INFO6_NON_QOS BIT(19) +#define RX_MPDU_START_INFO6_NULL_DATA BIT(20) +#define RX_MPDU_START_INFO6_MGMT_TYPE BIT(21) +#define RX_MPDU_START_INFO6_CTRL_TYPE BIT(22) +#define RX_MPDU_START_INFO6_MORE_DATA BIT(23) +#define RX_MPDU_START_INFO6_EOSP BIT(24) +#define RX_MPDU_START_INFO6_FRAGMENT BIT(25) +#define RX_MPDU_START_INFO6_ORDER BIT(26) +#define RX_MPDU_START_INFO6_UAPSD_TRIGGER BIT(27) +#define RX_MPDU_START_INFO6_ENCRYPT_REQUIRED BIT(28) +#define RX_MPDU_START_INFO6_DIRECTED BIT(29) + +#define RX_MPDU_START_RAW_MPDU BIT(0) + +struct rx_mpdu_start { +__le16 info0; +__le16 phy_ppdu_id; +__le16 ast_index; +__le16 sw_peer_id; +__le32 info1; +__le32 info2; +__le32 pn[4 ]; +__le32 peer_meta_data; +__le32 info3; +__le32 reo_queue_desc_lo; +__le32 info4; +__le32 info5; +__le32 info6; +__le16 frame_ctrl; +__le16 duration; +u8 addr1[ETH_ALEN ]; +u8 addr2[ETH_ALEN ]; +u8 addr3[ETH_ALEN ]; +__le16 seq_ctrl; +u8 addr4[ETH_ALEN ]; +__le16 qos_ctrl; +__le32 ht_ctrl; +__le32 raw; +} __packed; + +/* rx_mpdu_start +* +* rxpcu_mpdu_filter_in_category +* Field indicates what the reason was that this mpdu frame +* was allowed to come into the receive path by rxpcu. Values +* are defined in enum %RX_DESC_RXPCU_FILTER_*. +* Note: for ndp frame, if it was expected because the preceding +* NDPA was filter_pass, the setting rxpcu_filter_pass will be +* used. This setting will also be used for every ndp frame in +* case Promiscuous mode is enabled. +* +* sw_frame_group_id +* SW processes frames based on certain classifications. Values +* are defined in enum %RX_DESC_SW_FRAME_GRP_ID_*. +* +* ndp_frame +* Indicates that the received frame was an NDP frame. +* +* phy_err +* Indicates that PHY error was received before MAC received data. +* +* phy_err_during_mpdu_header +* PHY error was received before MAC received the complete MPDU +* header which was needed for proper decoding. +* +* protocol_version_err +* RXPCU detected a version error in the frame control field. +* +* ast_based_lookup_valid +* AST based lookup for this frame has found a valid result. +* +* phy_ppdu_id +* A ppdu counter value that PHY increments for every PPDU +* received. The counter value wraps around. +* +* ast_index +* This field indicates the index of the AST entry corresponding +* to this MPDU. It is provided by the GSE module instantiated in +* RXPCU. A value of 0xFFFF indicates an invalid AST index. +* +* sw_peer_id +* This field indicates a unique peer identifier. It is set equal +* to field 'sw_peer_id' from the AST entry. +* +* mpdu_frame_control_valid, mpdu_duration_valid, mpdu_qos_control_valid, +* mpdu_ht_control_valid, frame_encryption_info_valid +* Indicates that each fields have valid entries. +* +* mac_addr_adx_valid +* Corresponding mac_addr_adx_{lo/hi} has valid entries. +* +* from_ds, to_ds +* Valid only when mpdu_frame_control_valid is set. Indicates that +* frame is received from DS and sent to DS. +* +* encrypted +* Protected bit from the frame control. +* +* mpdu_retry +* Retry bit from frame control. Only valid when first_msdu is set. +* +* mpdu_sequence_number +* The sequence number from the 802.11 header. +* +* epd_en +* If set, use EPD instead of LPD. +* +* all_frames_shall_be_encrypted +* If set, all frames (data only?) shall be encrypted. If not, +* RX CRYPTO shall set an error flag. +* +* encrypt_type +* Values are defined in enum %HAL_ENCRYPT_TYPE_. +* +* mesh_sta +* Indicates a Mesh (11s) STA. +* +* bssid_hit +* BSSID of the incoming frame matched one of the 8 BSSID +* register values. +* +* bssid_number +* This number indicates which one out of the 8 BSSID register +* values matched the incoming frame. +* +* tid +* TID field in the QoS control field +* +* pn +* The PN number. +* +* peer_meta_data +* Meta data that SW has programmed in the Peer table entry +* of the transmitting STA. +* +* rx_reo_queue_desc_addr_lo +* Address (lower 32 bits) of the REO queue descriptor. +* +* rx_reo_queue_desc_addr_hi +* Address (upper 8 bits) of the REO queue descriptor. +* +* receive_queue_number +* Indicates the MPDU queue ID to which this MPDU link +* descriptor belongs. +* +* pre_delim_err_warning +* Indicates that a delimiter FCS error was found in between the +* previous MPDU and this MPDU. Note that this is just a warning, +* and does not mean that this MPDU is corrupted in any way. If +* it is, there will be other errors indicated such as FCS or +* decrypt errors. +* +* first_delim_err +* Indicates that the first delimiter had a FCS failure. +* +* key_id +* The key ID octet from the IV. +* +* new_peer_entry +* Set if new RX_PEER_ENTRY TLV follows. If clear, RX_PEER_ENTRY +* doesn't follow so RX DECRYPTION module either uses old peer +* entry or not decrypt. +* +* decrypt_needed +* When RXPCU sets bit 'ast_index_not_found or ast_index_timeout', +* RXPCU will also ensure that this bit is NOT set. CRYPTO for that +* reason only needs to evaluate this bit and non of the other ones +* +* decap_type +* Used by the OLE during decapsulation. Values are defined in +* enum %MPDU_START_DECAP_TYPE_*. +* +* rx_insert_vlan_c_tag_padding +* rx_insert_vlan_s_tag_padding +* Insert 4 byte of all zeros as VLAN tag or double VLAN tag if +* the rx payload does not have VLAN. +* +* strip_vlan_c_tag_decap +* strip_vlan_s_tag_decap +* Strip VLAN or double VLAN during decapsulation. +* +* pre_delim_count +* The number of delimiters before this MPDU. Note that this +* number is cleared at PPDU start. If this MPDU is the first +* received MPDU in the PPDU and this MPDU gets filtered-in, +* this field will indicate the number of delimiters located +* after the last MPDU in the previous PPDU. +* +* If this MPDU is located after the first received MPDU in +* an PPDU, this field will indicate the number of delimiters +* located between the previous MPDU and this MPDU. +* +* ampdu_flag +* Received frame was part of an A-MPDU. +* +* bar_frame +* Received frame is a BAR frame +* +* mpdu_length +* MPDU length before decapsulation. +* +* first_mpdu..directed +* See definition in RX attention descriptor +* +*/ + +enum rx_msdu_start_pkt_type { +RX_MSDU_START_PKT_TYPE_11A , +RX_MSDU_START_PKT_TYPE_11B , +RX_MSDU_START_PKT_TYPE_11N , +RX_MSDU_START_PKT_TYPE_11AC , +RX_MSDU_START_PKT_TYPE_11AX , +}; + +enum rx_msdu_start_sgi { +RX_MSDU_START_SGI_0_8_US , +RX_MSDU_START_SGI_0_4_US , +RX_MSDU_START_SGI_1_6_US , +RX_MSDU_START_SGI_3_2_US , +}; + +enum rx_msdu_start_recv_bw { +RX_MSDU_START_RECV_BW_20MHZ , +RX_MSDU_START_RECV_BW_40MHZ , +RX_MSDU_START_RECV_BW_80MHZ , +RX_MSDU_START_RECV_BW_160MHZ , +}; + +enum rx_msdu_start_reception_type { +RX_MSDU_START_RECEPTION_TYPE_SU , +RX_MSDU_START_RECEPTION_TYPE_DL_MU_MIMO , +RX_MSDU_START_RECEPTION_TYPE_DL_MU_OFDMA , +RX_MSDU_START_RECEPTION_TYPE_DL_MU_OFDMA_MIMO , +RX_MSDU_START_RECEPTION_TYPE_UL_MU_MIMO , +RX_MSDU_START_RECEPTION_TYPE_UL_MU_OFDMA , +RX_MSDU_START_RECEPTION_TYPE_UL_MU_OFDMA_MIMO , +}; + +#define RX_MSDU_START_INFO1_MSDU_LENGTH GENMASK(13, 0) +#define RX_MSDU_START_INFO1_RSVD_1A BIT(14) +#define RX_MSDU_START_INFO1_IPSEC_ESP BIT(15) +#define RX_MSDU_START_INFO1_L3_OFFSET GENMASK(22, 16) +#define RX_MSDU_START_INFO1_IPSEC_AH BIT(23) +#define RX_MSDU_START_INFO1_L4_OFFSET GENMASK(31, 24) + +#define RX_MSDU_START_INFO2_MSDU_NUMBER GENMASK(7, 0) +#define RX_MSDU_START_INFO2_DECAP_TYPE GENMASK(9, 8) +#define RX_MSDU_START_INFO2_IPV4 BIT(10) +#define RX_MSDU_START_INFO2_IPV6 BIT(11) +#define RX_MSDU_START_INFO2_TCP BIT(12) +#define RX_MSDU_START_INFO2_UDP BIT(13) +#define RX_MSDU_START_INFO2_IP_FRAG BIT(14) +#define RX_MSDU_START_INFO2_TCP_ONLY_ACK BIT(15) +#define RX_MSDU_START_INFO2_DA_IS_BCAST_MCAST BIT(16) +#define RX_MSDU_START_INFO2_SELECTED_TOEPLITZ_HASH GENMASK(18, 17) +#define RX_MSDU_START_INFO2_IP_FIXED_HDR_VALID BIT(19) +#define RX_MSDU_START_INFO2_IP_EXTN_HDR_VALID BIT(20) +#define RX_MSDU_START_INFO2_IP_TCP_UDP_HDR_VALID BIT(21) +#define RX_MSDU_START_INFO2_MESH_CTRL_PRESENT BIT(22) +#define RX_MSDU_START_INFO2_LDPC BIT(23) +#define RX_MSDU_START_INFO2_IP4_IP6_NXT_HDR GENMASK(31, 24) +#define RX_MSDU_START_INFO2_DECAP_FORMAT GENMASK(9, 8) + +#define RX_MSDU_START_INFO3_USER_RSSI GENMASK(7, 0) +#define RX_MSDU_START_INFO3_PKT_TYPE GENMASK(11, 8) +#define RX_MSDU_START_INFO3_STBC BIT(12) +#define RX_MSDU_START_INFO3_SGI GENMASK(14, 13) +#define RX_MSDU_START_INFO3_RATE_MCS GENMASK(18, 15) +#define RX_MSDU_START_INFO3_RECV_BW GENMASK(20, 19) +#define RX_MSDU_START_INFO3_RECEPTION_TYPE GENMASK(23, 21) +#define RX_MSDU_START_INFO3_MIMO_SS_BITMAP GENMASK(31, 24) + +struct rx_msdu_start { +__le16 info0; +__le16 phy_ppdu_id; +__le32 info1; +__le32 info2; +__le32 toeplitz_hash; +__le32 flow_id_toeplitz; +__le32 info3; +__le32 ppdu_start_timestamp; +__le32 phy_meta_data; +} __packed; + +/* rx_msdu_start +* +* rxpcu_mpdu_filter_in_category +* Field indicates what the reason was that this mpdu frame +* was allowed to come into the receive path by rxpcu. Values +* are defined in enum %RX_DESC_RXPCU_FILTER_*. +* +* sw_frame_group_id +* SW processes frames based on certain classifications. Values +* are defined in enum %RX_DESC_SW_FRAME_GRP_ID_*. +* +* phy_ppdu_id +* A ppdu counter value that PHY increments for every PPDU +* received. The counter value wraps around. +* +* msdu_length +* MSDU length in bytes after decapsulation. +* +* ipsec_esp +* Set if IPv4/v6 packet is using IPsec ESP. +* +* l3_offset +* Depending upon mode bit, this field either indicates the +* L3 offset in bytes from the start of the RX_HEADER or the IP +* offset in bytes from the start of the packet after +* decapsulation. The latter is only valid if ipv4_proto or +* ipv6_proto is set. +* +* ipsec_ah +* Set if IPv4/v6 packet is using IPsec AH +* +* l4_offset +* Depending upon mode bit, this field either indicates the +* L4 offset nin bytes from the start of RX_HEADER (only valid +* if either ipv4_proto or ipv6_proto is set to 1) or indicates +* the offset in bytes to the start of TCP or UDP header from +* the start of the IP header after decapsulation (Only valid if +* tcp_proto or udp_proto is set). The value 0 indicates that +* the offset is longer than 127 bytes. +* +* msdu_number +* Indicates the MSDU number within a MPDU. This value is +* reset to zero at the start of each MPDU. If the number of +* MSDU exceeds 255 this number will wrap using modulo 256. +* +* decap_type +* Indicates the format after decapsulation. Values are defined in +* enum %MPDU_START_DECAP_TYPE_*. +* +* ipv4_proto +* Set if L2 layer indicates IPv4 protocol. +* +* ipv6_proto +* Set if L2 layer indicates IPv6 protocol. +* +* tcp_proto +* Set if the ipv4_proto or ipv6_proto are set and the IP protocol +* indicates TCP. +* +* udp_proto +* Set if the ipv4_proto or ipv6_proto are set and the IP protocol +* indicates UDP. +* +* ip_frag +* Indicates that either the IP More frag bit is set or IP frag +* number is non-zero. If set indicates that this is a fragmented +* IP packet. +* +* tcp_only_ack +* Set if only the TCP Ack bit is set in the TCP flags and if +* the TCP payload is 0. +* +* da_is_bcast_mcast +* The destination address is broadcast or multicast. +* +* toeplitz_hash +* Actual chosen Hash. +* 0 - Toeplitz hash of 2-tuple (IP source address, IP +* destination address) +* 1 - Toeplitz hash of 4-tuple (IP source address, +* IP destination address, L4 (TCP/UDP) source port, +* L4 (TCP/UDP) destination port) +* 2 - Toeplitz of flow_id +* 3 - Zero is used +* +* ip_fixed_header_valid +* Fixed 20-byte IPv4 header or 40-byte IPv6 header parsed +* fully within first 256 bytes of the packet +* +* ip_extn_header_valid +* IPv6/IPv6 header, including IPv4 options and +* recognizable extension headers parsed fully within first 256 +* bytes of the packet +* +* tcp_udp_header_valid +* Fixed 20-byte TCP (excluding TCP options) or 8-byte UDP +* header parsed fully within first 256 bytes of the packet +* +* mesh_control_present +* When set, this MSDU includes the 'Mesh Control' field +* +* ldpc +* +* ip4_protocol_ip6_next_header +* For IPv4, this is the 8 bit protocol field set). For IPv6 this +* is the 8 bit next_header field. +* +* toeplitz_hash_2_or_4 +* Controlled by RxOLE register - If register bit set to 0, +* Toeplitz hash is computed over 2-tuple IPv4 or IPv6 src/dest +* addresses; otherwise, toeplitz hash is computed over 4-tuple +* IPv4 or IPv6 src/dest addresses and src/dest ports. +* +* flow_id_toeplitz +* Toeplitz hash of 5-tuple +* {IP source address, IP destination address, IP source port, IP +* destination port, L4 protocol} in case of non-IPSec. +* +* In case of IPSec - Toeplitz hash of 4-tuple +* {IP source address, IP destination address, SPI, L4 protocol} +* +* The relevant Toeplitz key registers are provided in RxOLE's +* instance of common parser module. These registers are separate +* from the Toeplitz keys used by ASE/FSE modules inside RxOLE. +* The actual value will be passed on from common parser module +* to RxOLE in one of the WHO_* TLVs. +* +* user_rssi +* RSSI for this user +* +* pkt_type +* Values are defined in enum %RX_MSDU_START_PKT_TYPE_*. +* +* stbc +* When set, use STBC transmission rates. +* +* sgi +* Field only valid when pkt type is HT, VHT or HE. Values are +* defined in enum %RX_MSDU_START_SGI_*. +* +* rate_mcs +* MCS Rate used. +* +* receive_bandwidth +* Full receive Bandwidth. Values are defined in enum +* %RX_MSDU_START_RECV_*. +* +* reception_type +* Indicates what type of reception this is and defined in enum +* %RX_MSDU_START_RECEPTION_TYPE_*. +* +* mimo_ss_bitmap +* Field only valid when +* Reception_type is RX_MSDU_START_RECEPTION_TYPE_DL_MU_MIMO or +* RX_MSDU_START_RECEPTION_TYPE_DL_MU_OFDMA_MIMO. +* +* Bitmap, with each bit indicating if the related spatial +* stream is used for this STA +* +* LSB related to SS 0 +* +* 0 - spatial stream not used for this reception +* 1 - spatial stream used for this reception +* +* ppdu_start_timestamp +* Timestamp that indicates when the PPDU that contained this MPDU +* started on the medium. +* +* phy_meta_data +* SW programmed Meta data provided by the PHY. Can be used for SW +* to indicate the channel the device is on. +*/ + +#define RX_MSDU_END_INFO0_RXPCU_MPDU_FITLER GENMASK(1, 0) +#define RX_MSDU_END_INFO0_SW_FRAME_GRP_ID GENMASK(8, 2) + +#define RX_MSDU_END_INFO1_KEY_ID GENMASK(7, 0) +#define RX_MSDU_END_INFO1_CCE_SUPER_RULE GENMASK(13, 8) +#define RX_MSDU_END_INFO1_CCND_TRUNCATE BIT(14) +#define RX_MSDU_END_INFO1_CCND_CCE_DIS BIT(15) +#define RX_MSDU_END_INFO1_EXT_WAPI_PN GENMASK(31, 16) + +#define RX_MSDU_END_INFO2_REPORTED_MPDU_LEN GENMASK(13, 0) +#define RX_MSDU_END_INFO2_FIRST_MSDU BIT(14) +#define RX_MSDU_END_INFO2_LAST_MSDU BIT(15) +#define RX_MSDU_END_INFO2_SA_IDX_TIMEOUT BIT(16) +#define RX_MSDU_END_INFO2_DA_IDX_TIMEOUT BIT(17) +#define RX_MSDU_END_INFO2_MSDU_LIMIT_ERR BIT(18) +#define RX_MSDU_END_INFO2_FLOW_IDX_TIMEOUT BIT(19) +#define RX_MSDU_END_INFO2_FLOW_IDX_INVALID BIT(20) +#define RX_MSDU_END_INFO2_WIFI_PARSER_ERR BIT(21) +#define RX_MSDU_END_INFO2_AMSDU_PARSET_ERR BIT(22) +#define RX_MSDU_END_INFO2_SA_IS_VALID BIT(23) +#define RX_MSDU_END_INFO2_DA_IS_VALID BIT(24) +#define RX_MSDU_END_INFO2_DA_IS_MCBC BIT(25) +#define RX_MSDU_END_INFO2_L3_HDR_PADDING GENMASK(27, 26) + +#define RX_MSDU_END_INFO3_TCP_FLAG GENMASK(8, 0) +#define RX_MSDU_END_INFO3_LRO_ELIGIBLE BIT(9) + +#define RX_MSDU_END_INFO4_DA_OFFSET GENMASK(5, 0) +#define RX_MSDU_END_INFO4_SA_OFFSET GENMASK(11, 6) +#define RX_MSDU_END_INFO4_DA_OFFSET_VALID BIT(12) +#define RX_MSDU_END_INFO4_SA_OFFSET_VALID BIT(13) +#define RX_MSDU_END_INFO4_L3_TYPE GENMASK(31, 16) + +#define RX_MSDU_END_INFO5_MSDU_DROP BIT(0) +#define RX_MSDU_END_INFO5_REO_DEST_IND GENMASK(5, 1) +#define RX_MSDU_END_INFO5_FLOW_IDX GENMASK(25, 6) + +struct rx_msdu_end { +__le16 info0; +__le16 phy_ppdu_id; +__le16 ip_hdr_cksum; +__le16 tcp_udp_cksum; +__le32 info1; +__le32 ext_wapi_pn[2 ]; +__le32 info2; +__le32 ipv6_options_crc; +__le32 tcp_seq_num; +__le32 tcp_ack_num; +__le16 info3; +__le16 window_size; +__le32 info4; +__le32 rule_indication[2 ]; +__le16 sa_idx; +__le16 da_idx; +__le32 info5; +__le32 fse_metadata; +__le16 cce_metadata; +__le16 sa_sw_peer_id; +} __packed; + +/* rx_msdu_end +* +* rxpcu_mpdu_filter_in_category +* Field indicates what the reason was that this mpdu frame +* was allowed to come into the receive path by rxpcu. Values +* are defined in enum %RX_DESC_RXPCU_FILTER_*. +* +* sw_frame_group_id +* SW processes frames based on certain classifications. Values +* are defined in enum %RX_DESC_SW_FRAME_GRP_ID_*. +* +* phy_ppdu_id +* A ppdu counter value that PHY increments for every PPDU +* received. The counter value wraps around. +* +* ip_hdr_cksum +* This can include the IP header checksum or the pseudo +* header checksum used by TCP/UDP checksum. +* +* tcp_udp_chksum +* The value of the computed TCP/UDP checksum. A mode bit +* selects whether this checksum is the full checksum or the +* partial checksum which does not include the pseudo header. +* +* key_id +* The key ID octet from the IV. Only valid when first_msdu is set. +* +* cce_super_rule +* Indicates the super filter rule. +* +* cce_classify_not_done_truncate +* Classification failed due to truncated frame. +* +* cce_classify_not_done_cce_dis +* Classification failed due to CCE global disable +* +* ext_wapi_pn* +* Extension PN (packet number) which is only used by WAPI. +* +* reported_mpdu_length +* MPDU length before decapsulation. Only valid when first_msdu is +* set. This field is taken directly from the length field of the +* A-MPDU delimiter or the preamble length field for non-A-MPDU +* frames. +* +* first_msdu +* Indicates the first MSDU of A-MSDU. If both first_msdu and +* last_msdu are set in the MSDU then this is a non-aggregated MSDU +* frame: normal MPDU. Interior MSDU in an A-MSDU shall have both +* first_mpdu and last_mpdu bits set to 0. +* +* last_msdu +* Indicates the last MSDU of the A-MSDU. MPDU end status is only +* valid when last_msdu is set. +* +* sa_idx_timeout +* Indicates an unsuccessful MAC source address search due to the +* expiring of the search timer. +* +* da_idx_timeout +* Indicates an unsuccessful MAC destination address search due to +* the expiring of the search timer. +* +* msdu_limit_error +* Indicates that the MSDU threshold was exceeded and thus all the +* rest of the MSDUs will not be scattered and will not be +* decapsulated but will be DMA'ed in RAW format as a single MSDU. +* +* flow_idx_timeout +* Indicates an unsuccessful flow search due to the expiring of +* the search timer. +* +* flow_idx_invalid +* flow id is not valid. +* +* amsdu_parser_error +* A-MSDU could not be properly de-agregated. +* +* sa_is_valid +* Indicates that OLE found a valid SA entry. +* +* da_is_valid +* Indicates that OLE found a valid DA entry. +* +* da_is_mcbc +* Field Only valid if da_is_valid is set. Indicates the DA address +* was a Multicast of Broadcast address. +* +* l3_header_padding +* Number of bytes padded to make sure that the L3 header will +* always start of a Dword boundary. +* +* ipv6_options_crc +* 32 bit CRC computed out of IP v6 extension headers. +* +* tcp_seq_number +* TCP sequence number. +* +* tcp_ack_number +* TCP acknowledge number. +* +* tcp_flag +* TCP flags {NS, CWR, ECE, URG, ACK, PSH, RST, SYN, FIN}. +* +* lro_eligible +* Computed out of TCP and IP fields to indicate that this +* MSDU is eligible for LRO. +* +* window_size +* TCP receive window size. +* +* da_offset +* Offset into MSDU buffer for DA. +* +* sa_offset +* Offset into MSDU buffer for SA. +* +* da_offset_valid +* da_offset field is valid. This will be set to 0 in case +* of a dynamic A-MSDU when DA is compressed. +* +* sa_offset_valid +* sa_offset field is valid. This will be set to 0 in case +* of a dynamic A-MSDU when SA is compressed. +* +* l3_type +* The 16-bit type value indicating the type of L3 later +* extracted from LLC/SNAP, set to zero if SNAP is not +* available. +* +* rule_indication +* Bitmap indicating which of rules have matched. +* +* sa_idx +* The offset in the address table which matches MAC source address +* +* da_idx +* The offset in the address table which matches MAC destination +* address. +* +* msdu_drop +* REO shall drop this MSDU and not forward it to any other ring. +* +* reo_destination_indication +* The id of the reo exit ring where the msdu frame shall push +* after (MPDU level) reordering has finished. Values are defined +* in enum %HAL_RX_MSDU_DESC_REO_DEST_IND_. +* +* flow_idx +* Flow table index. +* +* fse_metadata +* FSE related meta data. +* +* cce_metadata +* CCE related meta data. +* +* sa_sw_peer_id +* sw_peer_id from the address search entry corresponding to the +* source address of the MSDU. +*/ + +enum rx_mpdu_end_rxdma_dest_ring { +RX_MPDU_END_RXDMA_DEST_RING_RELEASE , +RX_MPDU_END_RXDMA_DEST_RING_FW , +RX_MPDU_END_RXDMA_DEST_RING_SW , +RX_MPDU_END_RXDMA_DEST_RING_REO , +}; + +#define RX_MPDU_END_INFO1_UNSUP_KTYPE_SHORT_FRAME BIT(11) +#define RX_MPDU_END_INFO1_RX_IN_TX_DECRYPT_BYT BIT(12) +#define RX_MPDU_END_INFO1_OVERFLOW_ERR BIT(13) +#define RX_MPDU_END_INFO1_MPDU_LEN_ERR BIT(14) +#define RX_MPDU_END_INFO1_TKIP_MIC_ERR BIT(15) +#define RX_MPDU_END_INFO1_DECRYPT_ERR BIT(16) +#define RX_MPDU_END_INFO1_UNENCRYPTED_FRAME_ERR BIT(17) +#define RX_MPDU_END_INFO1_PN_FIELDS_VALID BIT(18) +#define RX_MPDU_END_INFO1_FCS_ERR BIT(19) +#define RX_MPDU_END_INFO1_MSDU_LEN_ERR BIT(20) +#define RX_MPDU_END_INFO1_RXDMA0_DEST_RING GENMASK(22, 21) +#define RX_MPDU_END_INFO1_RXDMA1_DEST_RING GENMASK(24, 23) +#define RX_MPDU_END_INFO1_DECRYPT_STATUS_CODE GENMASK(27, 25) +#define RX_MPDU_END_INFO1_RX_BITMAP_NOT_UPD BIT(28) + +struct rx_mpdu_end { +__le16 info0; +__le16 phy_ppdu_id; +__le32 info1; +} __packed; + +/* rx_mpdu_end +* +* rxpcu_mpdu_filter_in_category +* Field indicates what the reason was that this mpdu frame +* was allowed to come into the receive path by rxpcu. Values +* are defined in enum %RX_DESC_RXPCU_FILTER_*. +* +* sw_frame_group_id +* SW processes frames based on certain classifications. Values +* are defined in enum %RX_DESC_SW_FRAME_GRP_ID_*. +* +* phy_ppdu_id +* A ppdu counter value that PHY increments for every PPDU +* received. The counter value wraps around. +* +* unsup_ktype_short_frame +* This bit will be '1' when WEP or TKIP or WAPI key type is +* received for 11ah short frame. Crypto will bypass the received +* packet without decryption to RxOLE after setting this bit. +* +* rx_in_tx_decrypt_byp +* Indicates that RX packet is not decrypted as Crypto is +* busy with TX packet processing. +* +* overflow_err +* RXPCU Receive FIFO ran out of space to receive the full MPDU. +* Therefore this MPDU is terminated early and is thus corrupted. +* +* This MPDU will not be ACKed. +* +* RXPCU might still be able to correctly receive the following +* MPDUs in the PPDU if enough fifo space became available in time. +* +* mpdu_length_err +* Set by RXPCU if the expected MPDU length does not correspond +* with the actually received number of bytes in the MPDU. +* +* tkip_mic_err +* Set by Rx crypto when crypto detected a TKIP MIC error for +* this MPDU. +* +* decrypt_err +* Set by RX CRYPTO when CRYPTO detected a decrypt error for this +* MPDU or CRYPTO received an encrypted frame, but did not get a +* valid corresponding key id in the peer entry. +* +* unencrypted_frame_err +* Set by RX CRYPTO when CRYPTO detected an unencrypted frame while +* in the peer entry field 'All_frames_shall_be_encrypted' is set. +* +* pn_fields_contain_valid_info +* Set by RX CRYPTO to indicate that there is a valid PN field +* present in this MPDU. +* +* fcs_err +* Set by RXPCU when there is an FCS error detected for this MPDU. +* +* msdu_length_err +* Set by RXOLE when there is an msdu length error detected +* in at least 1 of the MSDUs embedded within the MPDU. +* +* rxdma0_destination_ring +* rxdma1_destination_ring +* The ring to which RXDMA0/1 shall push the frame, assuming +* no MPDU level errors are detected. In case of MPDU level +* errors, RXDMA0/1 might change the RXDMA0/1 destination. Values +* are defined in %enum RX_MPDU_END_RXDMA_DEST_RING_*. +* +* decrypt_status_code +* Field provides insight into the decryption performed. Values +* are defined in enum %RX_DESC_DECRYPT_STATUS_CODE_*. +* +* rx_bitmap_not_updated +* Frame is received, but RXPCU could not update the receive bitmap +* due to (temporary) fifo constraints. +*/ + +/* Padding bytes to avoid TLV's spanning across 128 byte boundary */ +#define HAL_RX_DESC_PADDING0_BYTES 4 +#define HAL_RX_DESC_PADDING1_BYTES 16 + +#define HAL_RX_DESC_HDR_STATUS_LEN 120 + +struct hal_rx_desc { +__le32 msdu_end_tag; +struct rx_msdu_end msdu_end; +__le32 rx_attn_tag; +struct rx_attention attention; +__le32 msdu_start_tag; +struct rx_msdu_start msdu_start; +u8 rx_padding0[HAL_RX_DESC_PADDING0_BYTES ]; +__le32 mpdu_start_tag; +struct rx_mpdu_start mpdu_start; +__le32 mpdu_end_tag; +struct rx_mpdu_end mpdu_end; +u8 rx_padding1[HAL_RX_DESC_PADDING1_BYTES ]; +__le32 hdr_status_tag; +__le32 phy_ppdu_id; +u8 hdr_status[HAL_RX_DESC_HDR_STATUS_LEN ]; +u8 msdu_payload[0 ]; +} __packed; + +#endif /* ATH11K_RX_DESC_H */
PATCH v3 40/49 ath11k: add testmode.c
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/testmode.c | 199 +++++++++++++++++++++++++++++ 1 file changed, 199 insertions(+)
drivers/net/wireless/ath/ath11k/testmode.c new file +199 -0
@@ -0,0 +1,199 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ + +#include "testmode.h" +#include <net/netlink.h> +#include "debug.h" +#include "wmi.h" +#include "hw.h" +#include "core.h" +#include "testmode_i.h" + +static const struct nla_policy ath11k_tm_policy[ATH11K_TM_ATTR_MAX +1 ] = { + [ATH11K_TM_ATTR_CMD ] = { .type =NLA_U32 }, + [ATH11K_TM_ATTR_DATA ] = { .type =NLA_BINARY , + .len =ATH11K_TM_DATA_MAX_LEN }, + [ATH11K_TM_ATTR_WMI_CMDID ] = { .type =NLA_U32 }, + [ATH11K_TM_ATTR_VERSION_MAJOR ] = { .type =NLA_U32 }, + [ATH11K_TM_ATTR_VERSION_MINOR ] = { .type =NLA_U32 }, +}; + +/* Returns true if callee consumes the skb and the skb should be discarded. +* Returns false if skb is not used. Does not sleep. +*/ +bool ath11k_tm_event_wmi (struct ath11k *ar,u32 cmd_id,struct sk_buff *skb) +{ +struct sk_buff *nl_skb; +bool consumed; +int ret; + +ath11k_dbg (ar->ab,ATH11K_DBG_TESTMODE , +"testmode event wmi cmd_id %d skb %pK skb->len %d\n" , + cmd_id, skb, skb->len); + +ath11k_dbg_dump (ar->ab,ATH11K_DBG_TESTMODE ,NULL ,"" , skb->data, skb->len); + +spin_lock_bh (&ar->data_lock); + + consumed = true; + + nl_skb =cfg80211_testmode_alloc_event_skb (ar->hw->wiphy, +2 *sizeof (u32) + skb->len, +GFP_ATOMIC ); +if (!nl_skb) { +ath11k_warn (ar->ab, +"failed to allocate skb for testmode wmi event\n" ); + goto out; + } + + ret =nla_put_u32 (nl_skb,ATH11K_TM_ATTR_CMD ,ATH11K_TM_CMD_WMI ); +if (ret) { +ath11k_warn (ar->ab, +"failed to to put testmode wmi event cmd attribute: %d\n" , + ret); +kfree_skb (nl_skb); + goto out; + } + + ret =nla_put_u32 (nl_skb,ATH11K_TM_ATTR_WMI_CMDID , cmd_id); +if (ret) { +ath11k_warn (ar->ab, +"failed to to put testmode wmi even cmd_id: %d\n" , + ret); +kfree_skb (nl_skb); + goto out; + } + + ret =nla_put (nl_skb,ATH11K_TM_ATTR_DATA , skb->len, skb->data); +if (ret) { +ath11k_warn (ar->ab, +"failed to copy skb to testmode wmi event: %d\n" , + ret); +kfree_skb (nl_skb); + goto out; + } + +cfg80211_testmode_event (nl_skb,GFP_ATOMIC ); + +out: +spin_unlock_bh (&ar->data_lock); + +return consumed; +} + +static int ath11k_tm_cmd_get_version (struct ath11k *ar,struct nlattr *tb[]) +{ +struct sk_buff *skb; +int ret; + +ath11k_dbg (ar->ab,ATH11K_DBG_TESTMODE , +"testmode cmd get version_major %d version_minor %d\n" , +ATH11K_TESTMODE_VERSION_MAJOR , +ATH11K_TESTMODE_VERSION_MINOR ); + + skb =cfg80211_testmode_alloc_reply_skb (ar->hw->wiphy, +nla_total_size (sizeof (u32))); +if (!skb) +return -ENOMEM ; + + ret =nla_put_u32 (skb,ATH11K_TM_ATTR_VERSION_MAJOR , +ATH11K_TESTMODE_VERSION_MAJOR ); +if (ret) { +kfree_skb (skb); +return ret; + } + + ret =nla_put_u32 (skb,ATH11K_TM_ATTR_VERSION_MINOR , +ATH11K_TESTMODE_VERSION_MINOR ); +if (ret) { +kfree_skb (skb); +return ret; + } + +return cfg80211_testmode_reply (skb); +} + +static int ath11k_tm_cmd_wmi (struct ath11k *ar,struct nlattr *tb[]) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct sk_buff *skb; +u32 cmd_id, buf_len; +int ret; +void *buf; + +mutex_lock (&ar->conf_mutex); + +if (ar->state !=ATH11K_STATE_ON ) { + ret = -ENETDOWN ; + goto out; + } + +if (!tb[ATH11K_TM_ATTR_DATA ]) { + ret = -EINVAL ; + goto out; + } + +if (!tb[ATH11K_TM_ATTR_WMI_CMDID ]) { + ret = -EINVAL ; + goto out; + } + + buf =nla_data (tb[ATH11K_TM_ATTR_DATA ]); + buf_len =nla_len (tb[ATH11K_TM_ATTR_DATA ]); + cmd_id =nla_get_u32 (tb[ATH11K_TM_ATTR_WMI_CMDID ]); + +ath11k_dbg (ar->ab,ATH11K_DBG_TESTMODE , +"testmode cmd wmi cmd_id %d buf %pK buf_len %d\n" , + cmd_id, buf, buf_len); + +ath11k_dbg_dump (ar->ab,ATH11K_DBG_TESTMODE ,NULL ,"" , buf, buf_len); + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, buf_len); +if (!skb) { + ret = -ENOMEM ; + goto out; + } + +memcpy (skb->data, buf, buf_len); + + ret =ath11k_wmi_cmd_send (wmi, skb, cmd_id); +if (ret) { +dev_kfree_skb (skb); +ath11k_warn (ar->ab,"failed to transmit wmi command (testmode): %d\n" , + ret); + goto out; + } + + ret =0 ; + +out: +mutex_unlock (&ar->conf_mutex); +return ret; +} + +int ath11k_tm_cmd (struct ieee80211_hw *hw,struct ieee80211_vif *vif, +void *data,int len) +{ +struct ath11k *ar = hw->priv; +struct nlattr *tb[ATH11K_TM_ATTR_MAX +1 ]; +int ret; + + ret =nla_parse (tb,ATH11K_TM_ATTR_MAX , data, len, ath11k_tm_policy, +NULL ); +if (ret) +return ret; + +if (!tb[ATH11K_TM_ATTR_CMD ]) +return -EINVAL ; + +switch (nla_get_u32 (tb[ATH11K_TM_ATTR_CMD ])) { +case ATH11K_TM_CMD_GET_VERSION : +return ath11k_tm_cmd_get_version (ar, tb); +case ATH11K_TM_CMD_WMI : +return ath11k_tm_cmd_wmi (ar, tb); +default : +return -EOPNOTSUPP ; + } +}
PATCH v3 41/49 ath11k: add testmode.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/testmode.h | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
drivers/net/wireless/ath/ath11k/testmode.h new file +29 -0
@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ + +#include "core.h" + +#ifdef CONFIG_NL80211_TESTMODE + +bool ath11k_tm_event_wmi (struct ath11k *ar,u32 cmd_id,struct sk_buff *skb); +int ath11k_tm_cmd (struct ieee80211_hw *hw,struct ieee80211_vif *vif, +void *data,int len); + +#else + +static inline bool ath11k_tm_event_wmi (struct ath11k *ar,u32 cmd_id, +struct sk_buff *skb) +{ +return false; +} + +static inline int ath11k_tm_cmd (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +void *data,int len) +{ +return 0 ; +} + +#endif
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
PATCH v3 42/49 ath11k: add testmode_i.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/testmode_i.h | 50 ++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+)
drivers/net/wireless/ath/ath11k/testmode_i.h new file +50 -0
@@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ + +/* "API" level of the ath11k testmode interface. Bump it after every +* incompatible interface change. +*/ +#define ATH11K_TESTMODE_VERSION_MAJOR 1 + +/* Bump this after every _compatible_ interface change, for example +* addition of a new command or an attribute. +*/ +#define ATH11K_TESTMODE_VERSION_MINOR 0 + +#define ATH11K_TM_DATA_MAX_LEN 5000 + +enum ath11k_tm_attr { + __ATH11K_TM_ATTR_INVALID =0 , +ATH11K_TM_ATTR_CMD =1 , +ATH11K_TM_ATTR_DATA =2 , +ATH11K_TM_ATTR_WMI_CMDID =3 , +ATH11K_TM_ATTR_VERSION_MAJOR =4 , +ATH11K_TM_ATTR_VERSION_MINOR =5 , +ATH11K_TM_ATTR_WMI_OP_VERSION =6 , + +/* keep last */ + __ATH11K_TM_ATTR_AFTER_LAST, +ATH11K_TM_ATTR_MAX = __ATH11K_TM_ATTR_AFTER_LAST -1 , +}; + +/* All ath11k testmode interface commands specified in +* ATH11K_TM_ATTR_CMD +*/ +enum ath11k_tm_cmd { +/* Returns the supported ath11k testmode interface version in +* ATH11K_TM_ATTR_VERSION. Always guaranteed to work. User space +* uses this to verify it's using the correct version of the +* testmode interface +*/ +ATH11K_TM_CMD_GET_VERSION =0 , + +/* The command used to transmit a WMI command to the firmware and +* the event to receive WMI events from the firmware. Without +* struct wmi_cmd_hdr header, only the WMI payload. Command id is +* provided with ATH11K_TM_ATTR_WMI_CMDID and payload in +* ATH11K_TM_ATTR_DATA. +*/ +ATH11K_TM_CMD_WMI =1 , +};
PATCH v3 43/49 ath11k: add trace.c
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/trace.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/net/wireless/ath/ath11k/trace.c new file +9 -0
@@ -0,0 +1,9 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2019 The Linux Foundation. All rights reserved. +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include "trace.h"
PATCH v3 44/49 ath11k: add trace.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/trace.h | 110 ++++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+)
drivers/net/wireless/ath/ath11k/trace.h new file +110 -0
@@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2019 The Linux Foundation. All rights reserved. +*/ + +#if !defined(_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ ) + +#include <linux/tracepoint.h> +#include "core.h" + +#define _TRACE_H_ + +/* create empty functions when tracing is disabled */ +#if !defined(CONFIG_ATH11K_TRACING ) +#undef TRACE_EVENT +#define TRACE_EVENT (name, proto, ...) \ +static inline void trace_ ## name(proto) {} +#endif /* !CONFIG_ATH11K_TRACING || __CHECKER__ */ + +TRACE_EVENT (ath11k_htt_pktlog, + TP_PROTO(struct ath11k *ar, const void *buf, u16 buf_len), + +TP_ARGS (ar, buf, buf_len), + +TP_STRUCT__entry ( + __string(device, dev_name(ar->ab->dev)) + __string(driver, dev_driver_string(ar->ab->dev)) + __field(u16, buf_len) +__dynamic_array (u8, pktlog, buf_len) + ), + +TP_fast_assign ( + __assign_str(device, dev_name(ar->ab->dev)); + __assign_str(driver, dev_driver_string(ar->ab->dev)); + __entry->buf_len = buf_len; + memcpy(__get_dynamic_array(pktlog), buf, buf_len); + ), + +TP_printk ( +"%s %s size %hu" , +__get_str (driver), +__get_str (device), + __entry->buf_len + ) +); + +TRACE_EVENT (ath11k_htt_ppdu_stats, + TP_PROTO(struct ath11k *ar, const void *data, size_t len), + +TP_ARGS (ar, data, len), + +TP_STRUCT__entry ( + __string(device, dev_name(ar->ab->dev)) + __string(driver, dev_driver_string(ar->ab->dev)) + __field(u16, len) +__dynamic_array (u8, ppdu, len) + ), + +TP_fast_assign ( + __assign_str(device, dev_name(ar->ab->dev)); + __assign_str(driver, dev_driver_string(ar->ab->dev)); + __entry->len = len; + memcpy(__get_dynamic_array(ppdu), data, len); + ), + +TP_printk ( +"%s %s ppdu len %d" , +__get_str (driver), +__get_str (device), + __entry->len + ) +); + +TRACE_EVENT (ath11k_htt_rxdesc, + TP_PROTO(struct ath11k *ar, const void *data, size_t len), + +TP_ARGS (ar, data, len), + +TP_STRUCT__entry ( + __string(device, dev_name(ar->ab->dev)) + __string(driver, dev_driver_string(ar->ab->dev)) + __field(u16, len) +__dynamic_array (u8, rxdesc, len) + ), + +TP_fast_assign ( + __assign_str(device, dev_name(ar->ab->dev)); + __assign_str(driver, dev_driver_string(ar->ab->dev)); + __entry->len = len; + memcpy(__get_dynamic_array(rxdesc), data, len); + ), + +TP_printk ( +"%s %s rxdesc len %d" , +__get_str (driver), +__get_str (device), + __entry->len + ) +); + +#endif /* _TRACE_H_ || TRACE_HEADER_MULTI_READ*/ + +/* we don't want to use include/trace/events */ +#undef TRACE_INCLUDE_PATH +#define TRACE_INCLUDE_PATH . +#undef TRACE_INCLUDE_FILE +#define TRACE_INCLUDE_FILE trace + +/* This part must be outside protection */ +#include <trace/define_trace.h>
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
PATCH v3 45/49 ath11k: add wmi.c
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/wmi.c | 5632 +++++++++++++++++++++++++++++++++ 1 file changed, 5632 insertions(+)
drivers/net/wireless/ath/ath11k/wmi.c new file +5632 -0
@@ -0,0 +1,5632 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ +#include <linux/skbuff.h> +#include <linux/ctype.h> +#include <net/mac80211.h> +#include <net/cfg80211.h> +#include <linux/completion.h> +#include <linux/if_ether.h> +#include <linux/types.h> +#include <linux/pci.h> +#include <linux/uuid.h> +#include <linux/time.h> +#include <linux/of.h> +#include "core.h" +#include "debug.h" +#include "mac.h" +#include "hw.h" +#include "peer.h" + +struct wmi_tlv_policy { +size_t min_len; +}; + +struct wmi_tlv_svc_ready_parse { +bool wmi_svc_bitmap_done; +}; + +struct wmi_tlv_svc_rdy_ext_parse { +struct ath11k_service_ext_param param; +struct wmi_soc_mac_phy_hw_mode_caps *hw_caps; +struct wmi_hw_mode_capabilities *hw_mode_caps; +u32 n_hw_mode_caps; +u32 tot_phy_id; +struct wmi_hw_mode_capabilities pref_hw_mode_caps; +struct wmi_mac_phy_capabilities *mac_phy_caps; +u32 n_mac_phy_caps; +struct wmi_soc_hal_reg_capabilities *soc_hal_reg_caps; +struct wmi_hal_reg_capabilities_ext *ext_hal_reg_caps; +u32 n_ext_hal_reg_caps; +bool hw_mode_done; +bool mac_phy_done; +bool ext_hal_reg_done; +}; + +struct wmi_tlv_rdy_parse { +u32 num_extra_mac_addr; +}; + +static const struct wmi_tlv_policy wmi_tlv_policies[] = { + [WMI_TAG_ARRAY_BYTE ] + = { .min_len =0 }, + [WMI_TAG_ARRAY_UINT32 ] + = { .min_len =0 }, + [WMI_TAG_SERVICE_READY_EVENT ] + = { .min_len =sizeof (struct wmi_service_ready_event ) }, + [WMI_TAG_SERVICE_READY_EXT_EVENT ] + = { .min_len =sizeof (struct wmi_service_ready_ext_event ) }, + [WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS ] + = { .min_len =sizeof (struct wmi_soc_mac_phy_hw_mode_caps ) }, + [WMI_TAG_SOC_HAL_REG_CAPABILITIES ] + = { .min_len =sizeof (struct wmi_soc_hal_reg_capabilities ) }, + [WMI_TAG_VDEV_START_RESPONSE_EVENT ] + = { .min_len =sizeof (struct wmi_vdev_start_resp_event ) }, + [WMI_TAG_PEER_DELETE_RESP_EVENT ] + = { .min_len =sizeof (struct wmi_peer_delete_resp_event ) }, + [WMI_TAG_OFFLOAD_BCN_TX_STATUS_EVENT ] + = { .min_len =sizeof (struct wmi_bcn_tx_status_event ) }, + [WMI_TAG_VDEV_STOPPED_EVENT ] + = { .min_len =sizeof (struct wmi_vdev_stopped_event ) }, + [WMI_TAG_REG_CHAN_LIST_CC_EVENT ] + = { .min_len =sizeof (struct wmi_reg_chan_list_cc_event ) }, + [WMI_TAG_MGMT_RX_HDR ] + = { .min_len =sizeof (struct wmi_mgmt_rx_hdr ) }, + [WMI_TAG_MGMT_TX_COMPL_EVENT ] + = { .min_len =sizeof (struct wmi_mgmt_tx_compl_event ) }, + [WMI_TAG_SCAN_EVENT ] + = { .min_len =sizeof (struct wmi_scan_event ) }, + [WMI_TAG_PEER_STA_KICKOUT_EVENT ] + = { .min_len =sizeof (struct wmi_peer_sta_kickout_event ) }, + [WMI_TAG_ROAM_EVENT ] + = { .min_len =sizeof (struct wmi_roam_event ) }, + [WMI_TAG_CHAN_INFO_EVENT ] + = { .min_len =sizeof (struct wmi_chan_info_event ) }, + [WMI_TAG_PDEV_BSS_CHAN_INFO_EVENT ] + = { .min_len =sizeof (struct wmi_pdev_bss_chan_info_event ) }, + [WMI_TAG_VDEV_INSTALL_KEY_COMPLETE_EVENT ] + = { .min_len =sizeof (struct wmi_vdev_install_key_compl_event ) }, + [WMI_TAG_READY_EVENT ] + = {.min_len =sizeof (struct wmi_ready_event ) }, + [WMI_TAG_SERVICE_AVAILABLE_EVENT ] + = {.min_len =sizeof (struct wmi_service_available_event ) }, + [WMI_TAG_PEER_ASSOC_CONF_EVENT ] + = { .min_len =sizeof (struct wmi_peer_assoc_conf_event ) }, + [WMI_TAG_STATS_EVENT ] + = { .min_len =sizeof (struct wmi_stats_event ) }, + [WMI_TAG_PDEV_CTL_FAILSAFE_CHECK_EVENT ] + = { .min_len =sizeof (struct wmi_pdev_ctl_failsafe_chk_event ) }, +}; + +#define PRIMAP (_hw_mode_) \ + [_hw_mode_] = _hw_mode_##_PRI + +static const int ath11k_hw_mode_pri_map[] = { +PRIMAP (WMI_HOST_HW_MODE_SINGLE ), +PRIMAP (WMI_HOST_HW_MODE_DBS ), +PRIMAP (WMI_HOST_HW_MODE_SBS_PASSIVE ), +PRIMAP (WMI_HOST_HW_MODE_SBS ), +PRIMAP (WMI_HOST_HW_MODE_DBS_SBS ), +PRIMAP (WMI_HOST_HW_MODE_DBS_OR_SBS ), +/* keep last */ +PRIMAP (WMI_HOST_HW_MODE_MAX ), +}; + +static int +ath11k_wmi_tlv_iter (struct ath11k_base *ab,const void *ptr,size_t len, +int (*iter)(struct ath11k_base *ab,u16 tag,u16 len, +const void *ptr,void *data), +void *data) +{ +const void *begin = ptr; +const struct wmi_tlv *tlv; +u16 tlv_tag, tlv_len; +int ret; + +while (len >0 ) { +if (len <sizeof (*tlv)) { +ath11k_err (ab,"wmi tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n" , + ptr - begin, len,sizeof (*tlv)); +return -EINVAL ; + } + + tlv = ptr; + tlv_tag =FIELD_GET (WMI_TLV_TAG , tlv->header); + tlv_len =FIELD_GET (WMI_TLV_LEN , tlv->header); + ptr +=sizeof (*tlv); + len -=sizeof (*tlv); + +if (tlv_len > len) { +ath11k_err (ab,"wmi tlv parse failure of tag %hhu at byte %zd (%zu bytes left, %hhu expected)\n" , + tlv_tag, ptr - begin, len, tlv_len); +return -EINVAL ; + } + +if (tlv_tag <ARRAY_SIZE (wmi_tlv_policies) && + wmi_tlv_policies[tlv_tag].min_len && + wmi_tlv_policies[tlv_tag].min_len > tlv_len) { +ath11k_err (ab,"wmi tlv parse failure of tag %hhu at byte %zd (%hhu bytes is less than min length %zu)\n" , + tlv_tag, ptr - begin, tlv_len, + wmi_tlv_policies[tlv_tag].min_len); +return -EINVAL ; + } + + ret =iter (ab, tlv_tag, tlv_len, ptr, data); +if (ret) +return ret; + + ptr += tlv_len; + len -= tlv_len; + } + +return 0 ; +} + +static int ath11k_wmi_tlv_iter_parse (struct ath11k_base *ab,u16 tag,u16 len, +const void *ptr,void *data) +{ +const void **tb = data; + +if (tag <WMI_TAG_MAX ) + tb[tag] = ptr; + +return 0 ; +} + +static int ath11k_wmi_tlv_parse (struct ath11k_base *ar,const void **tb, +const void *ptr,size_t len) +{ +return ath11k_wmi_tlv_iter (ar, ptr, len, ath11k_wmi_tlv_iter_parse, + (void *)tb); +} + +static const void ** +ath11k_wmi_tlv_parse_alloc (struct ath11k_base *ab,const void *ptr, +size_t len,gfp_t gfp) +{ +const void **tb; +int ret; + + tb =kcalloc (WMI_TAG_MAX ,sizeof (*tb), gfp); +if (!tb) +return ERR_PTR (-ENOMEM ); + + ret =ath11k_wmi_tlv_parse (ab, tb, ptr, len); +if (ret) { +kfree (tb); +return ERR_PTR (ret); + } + +return tb; +} + +static int ath11k_wmi_cmd_send_nowait (struct ath11k_pdev_wmi *wmi,struct sk_buff *skb, +u32 cmd_id) +{ +struct ath11k_skb_cb *skb_cb =ATH11K_SKB_CB (skb); +struct ath11k_base *ab = wmi->wmi_sc->ab; +struct wmi_cmd_hdr *cmd_hdr; +int ret; +u32 cmd =0 ; + +if (skb_push (skb,sizeof (struct wmi_cmd_hdr )) ==NULL ) +return -ENOMEM ; + + cmd |=FIELD_PREP (WMI_CMD_HDR_CMD_ID , cmd_id); + + cmd_hdr = (struct wmi_cmd_hdr *)skb->data; + cmd_hdr->cmd_id = cmd; + +memset (skb_cb,0 ,sizeof (*skb_cb)); + ret =ath11k_htc_send (&ab->htc, wmi->eid, skb); + +if (ret) + goto err_pull; + +return 0 ; + +err_pull: +skb_pull (skb,sizeof (struct wmi_cmd_hdr )); +return ret; +} + +int ath11k_wmi_cmd_send (struct ath11k_pdev_wmi *wmi,struct sk_buff *skb, +u32 cmd_id) +{ +struct ath11k_wmi_base *wmi_sc = wmi->wmi_sc; +int ret = -EOPNOTSUPP ; + +might_sleep (); + +wait_event_timeout (wmi_sc->tx_credits_wq, ({ + ret =ath11k_wmi_cmd_send_nowait (wmi, skb, cmd_id); + +if (ret &&test_bit (ATH11K_FLAG_CRASH_FLUSH , &wmi_sc->ab->dev_flags)) + ret = -ESHUTDOWN ; + + (ret != -EAGAIN ); + }),WMI_SEND_TIMEOUT_HZ ); + +if (ret == -EAGAIN ) +ath11k_warn (wmi_sc->ab,"wmi command %d timeout\n" , cmd_id); + +return ret; +} + +static int ath11k_pull_svc_ready_ext (struct ath11k_pdev_wmi *wmi_handle, +const void *ptr, +struct ath11k_service_ext_param *param) +{ +const struct wmi_service_ready_ext_event *ev = ptr; + +if (!ev) +return -EINVAL ; + +/* Move this to host based bitmap */ + param->default_conc_scan_config_bits = ev->default_conc_scan_config_bits; + param->default_fw_config_bits = ev->default_fw_config_bits; + param->he_cap_info = ev->he_cap_info; + param->mpdu_density = ev->mpdu_density; + param->max_bssid_rx_filters = ev->max_bssid_rx_filters; +memcpy (¶m->ppet, &ev->ppet,sizeof (param->ppet)); + +return 0 ; +} + +static int +ath11k_pull_mac_phy_cap_svc_ready_ext (struct ath11k_pdev_wmi *wmi_handle, +struct wmi_soc_mac_phy_hw_mode_caps *hw_caps, +struct wmi_hw_mode_capabilities *wmi_hw_mode_caps, +struct wmi_soc_hal_reg_capabilities *hal_reg_caps, +struct wmi_mac_phy_capabilities *wmi_mac_phy_caps, +u8 hw_mode_id,u8 phy_id, +struct ath11k_pdev *pdev) +{ +struct wmi_mac_phy_capabilities *mac_phy_caps; +struct ath11k_band_cap *cap_band; +struct ath11k_pdev_cap *pdev_cap = &pdev->cap; +u32 phy_map; +u32 hw_idx, phy_idx =0 ; + +if (!hw_caps || !wmi_hw_mode_caps || !hal_reg_caps) +return -EINVAL ; + +for (hw_idx =0 ; hw_idx < hw_caps->num_hw_modes; hw_idx++) { +if (hw_mode_id == wmi_hw_mode_caps[hw_idx].hw_mode_id) +break ; + + phy_map = wmi_hw_mode_caps[hw_idx].phy_id_map; +while (phy_map) { + phy_map >>=1 ; + phy_idx++; + } + } + +if (hw_idx == hw_caps->num_hw_modes) +return -EINVAL ; + + phy_idx += phy_id; +if (phy_id >= hal_reg_caps->num_phy) +return -EINVAL ; + + mac_phy_caps = &wmi_mac_phy_caps[phy_idx]; + + pdev->pdev_id = mac_phy_caps->pdev_id; + pdev_cap->supported_bands = mac_phy_caps->supported_bands; + pdev_cap->ampdu_density = mac_phy_caps->ampdu_density; + +/* Take non-zero tx/rx chainmask. If tx/rx chainmask differs from +* band to band for a single radio, need to see how this should be +* handled. +*/ +if (mac_phy_caps->supported_bands &WMI_HOST_WLAN_2G_CAP ) { + pdev_cap->tx_chain_mask = mac_phy_caps->tx_chain_mask_2g; + pdev_cap->rx_chain_mask = mac_phy_caps->rx_chain_mask_2g; + }else if (mac_phy_caps->supported_bands &WMI_HOST_WLAN_5G_CAP ) { + pdev_cap->vht_cap = mac_phy_caps->vht_cap_info_5g; + pdev_cap->vht_mcs = mac_phy_caps->vht_supp_mcs_5g; + pdev_cap->he_mcs = mac_phy_caps->he_supp_mcs_5g; + pdev_cap->tx_chain_mask = mac_phy_caps->tx_chain_mask_5g; + pdev_cap->rx_chain_mask = mac_phy_caps->rx_chain_mask_5g; + }else { +return -EINVAL ; + } + +/* tx/rx chainmask reported from fw depends on the actual hw chains used, +* For example, for 4x4 capable macphys, first 4 chains can be used for first +* mac and the remaing 4 chains can be used for the second mac or vice-versa. +* In this case, tx/rx chainmask 0xf will be advertised for first mac and 0xf0 +* will be advertised for second mac or vice-versa. Compute the shift value for +* for tx/rx chainmask which will be used to advertise supported ht/vht rates to +* mac80211. +*/ + pdev_cap->tx_chain_mask_shift = +find_first_bit ((unsigned long *)&pdev_cap->tx_chain_mask,32 ); + pdev_cap->rx_chain_mask_shift = +find_first_bit ((unsigned long *)&pdev_cap->rx_chain_mask,32 ); + + cap_band = &pdev_cap->band[NL80211_BAND_2GHZ ]; + cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_2g; + cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_2g; + cap_band->he_cap_info[0 ] = mac_phy_caps->he_cap_info_2g; + cap_band->he_cap_info[1 ] = mac_phy_caps->he_cap_info_2g_ext; + cap_band->he_mcs = mac_phy_caps->he_supp_mcs_2g; +memcpy (cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_2g, +sizeof (u32) *PSOC_HOST_MAX_PHY_SIZE ); +memcpy (&cap_band->he_ppet, &mac_phy_caps->he_ppet2g, +sizeof (struct ath11k_ppe_threshold )); + + cap_band = &pdev_cap->band[NL80211_BAND_5GHZ ]; + cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_5g; + cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_5g; + cap_band->he_cap_info[0 ] = mac_phy_caps->he_cap_info_5g; + cap_band->he_cap_info[1 ] = mac_phy_caps->he_cap_info_5g_ext; + cap_band->he_mcs = mac_phy_caps->he_supp_mcs_5g; +memcpy (cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g, +sizeof (u32) *PSOC_HOST_MAX_PHY_SIZE ); +memcpy (&cap_band->he_ppet, &mac_phy_caps->he_ppet5g, +sizeof (struct ath11k_ppe_threshold )); + +return 0 ; +} + +static int +ath11k_pull_reg_cap_svc_rdy_ext (struct ath11k_pdev_wmi *wmi_handle, +struct wmi_soc_hal_reg_capabilities *reg_caps, +struct wmi_hal_reg_capabilities_ext *wmi_ext_reg_cap, +u8 phy_idx, +struct ath11k_hal_reg_capabilities_ext *param) +{ +struct wmi_hal_reg_capabilities_ext *ext_reg_cap; + +if (!reg_caps || !wmi_ext_reg_cap) +return -EINVAL ; + +if (phy_idx >= reg_caps->num_phy) +return -EINVAL ; + + ext_reg_cap = &wmi_ext_reg_cap[phy_idx]; + + param->phy_id = ext_reg_cap->phy_id; + param->eeprom_reg_domain = ext_reg_cap->eeprom_reg_domain; + param->eeprom_reg_domain_ext = + ext_reg_cap->eeprom_reg_domain_ext; + param->regcap1 = ext_reg_cap->regcap1; + param->regcap2 = ext_reg_cap->regcap2; +/* check if param->wireless_mode is needed */ + param->low_2ghz_chan = ext_reg_cap->low_2ghz_chan; + param->high_2ghz_chan = ext_reg_cap->high_2ghz_chan; + param->low_5ghz_chan = ext_reg_cap->low_5ghz_chan; + param->high_5ghz_chan = ext_reg_cap->high_5ghz_chan; + +return 0 ; +} + +static int ath11k_pull_service_ready_tlv (struct ath11k_base *ab, +const void *evt_buf, +struct ath11k_targ_cap *cap) +{ +const struct wmi_service_ready_event *ev = evt_buf; + +if (!ev) { +ath11k_err (ab,"%s: failed by NULL param\n" , + __func__); +return -EINVAL ; + } + + cap->phy_capability = ev->phy_capability; + cap->max_frag_entry = ev->max_frag_entry; + cap->num_rf_chains = ev->num_rf_chains; + cap->ht_cap_info = ev->ht_cap_info; + cap->vht_cap_info = ev->vht_cap_info; + cap->vht_supp_mcs = ev->vht_supp_mcs; + cap->hw_min_tx_power = ev->hw_min_tx_power; + cap->hw_max_tx_power = ev->hw_max_tx_power; + cap->sys_cap_info = ev->sys_cap_info; + cap->min_pkt_size_enable = ev->min_pkt_size_enable; + cap->max_bcn_ie_size = ev->max_bcn_ie_size; + cap->max_num_scan_channels = ev->max_num_scan_channels; + cap->max_supported_macs = ev->max_supported_macs; + cap->wmi_fw_sub_feat_caps = ev->wmi_fw_sub_feat_caps; + cap->txrx_chainmask = ev->txrx_chainmask; + cap->default_dbs_hw_mode_index = ev->default_dbs_hw_mode_index; + cap->num_msdu_desc = ev->num_msdu_desc; + +return 0 ; +} + +/* Save the wmi_service_bitmap into a linear bitmap. The wmi_services in +* wmi_service ready event are advertised in b0-b3 (LSB 4-bits) of each +* 4-byte word. +*/ +static void ath11k_wmi_service_bitmap_copy (struct ath11k_pdev_wmi *wmi, +const u32 *wmi_svc_bm) +{ +int i, j; + +for (i =0 , j =0 ; i <WMI_SERVICE_BM_SIZE && j <WMI_MAX_SERVICE ; i++) { +do { +if (wmi_svc_bm[i] &BIT (j %WMI_SERVICE_BITS_IN_SIZE32 )) +set_bit (j, wmi->wmi_sc->svc_map); + }while (++j %WMI_SERVICE_BITS_IN_SIZE32 ); + } +} + +static int ath11k_wmi_tlv_svc_rdy_parse (struct ath11k_base *ab,u16 tag,u16 len, +const void *ptr,void *data) +{ +struct wmi_tlv_svc_ready_parse *svc_ready = data; +struct ath11k_pdev_wmi *wmi_handle = &ab->wmi_sc.wmi[0 ]; +u16 expect_len; + +switch (tag) { +case WMI_TAG_SERVICE_READY_EVENT : +if (ath11k_pull_service_ready_tlv (ab, ptr, &ab->target_caps)) +return -EINVAL ; +break ; + +case WMI_TAG_ARRAY_UINT32 : +if (!svc_ready->wmi_svc_bitmap_done) { + expect_len =WMI_SERVICE_BM_SIZE *sizeof (u32); +if (len < expect_len) { +ath11k_warn (ab,"invalid len %d for the tag 0x%x\n" , + len, tag); +return -EINVAL ; + } + +ath11k_wmi_service_bitmap_copy (wmi_handle, ptr); + + svc_ready->wmi_svc_bitmap_done = true; + } +break ; +default : +break ; + } + +return 0 ; +} + +static int ath11k_service_ready_event (struct ath11k_base *ab,struct sk_buff *skb) +{ +struct wmi_tlv_svc_ready_parse svc_ready = { }; +int ret; + + ret =ath11k_wmi_tlv_iter (ab, skb->data, skb->len, + ath11k_wmi_tlv_svc_rdy_parse, + &svc_ready); +if (ret) { +ath11k_warn (ab,"failed to parse tlv %d\n" , ret); +return ret; + } + +return 0 ; +} + +struct sk_buff *ath11k_wmi_alloc_skb (struct ath11k_wmi_base *wmi_sc,u32 len) +{ +struct sk_buff *skb; +struct ath11k_base *ab = wmi_sc->ab; +u32 round_len =roundup (len,4 ); + + skb =ath11k_htc_alloc_skb (ab,WMI_SKB_HEADROOM + round_len); +if (!skb) +return NULL ; + +skb_reserve (skb,WMI_SKB_HEADROOM ); +if (!IS_ALIGNED ((unsigned long )skb->data,4 )) +ath11k_warn (ab,"unaligned WMI skb data\n" ); + +skb_put (skb, round_len); +memset (skb->data,0 , round_len); + +return skb; +} + +int ath11k_wmi_mgmt_send (struct ath11k *ar,u32 vdev_id,u32 buf_id, +struct sk_buff *frame) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_mgmt_send_cmd *cmd; +struct wmi_tlv *frame_tlv; +struct sk_buff *skb; +u32 buf_len; +int ret, len; + + buf_len = frame->len <WMI_MGMT_SEND_DOWNLD_LEN ? + frame->len :WMI_MGMT_SEND_DOWNLD_LEN ; + + len =sizeof (*cmd) +sizeof (*frame_tlv) +roundup (buf_len,4 ); + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_mgmt_send_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_MGMT_TX_SEND_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = vdev_id; + cmd->desc_id = buf_id; + cmd->chanfreq =0 ; + cmd->paddr_lo =lower_32_bits (ATH11K_SKB_CB (frame)->paddr); + cmd->paddr_hi =upper_32_bits (ATH11K_SKB_CB (frame)->paddr); + cmd->frame_len = frame->len; + cmd->buf_len = buf_len; + cmd->tx_params_valid =0 ; + + frame_tlv = (struct wmi_tlv *)(skb->data +sizeof (*cmd)); + frame_tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_BYTE ) | +FIELD_PREP (WMI_TLV_LEN , buf_len); + +memcpy (frame_tlv->value, frame->data, buf_len); + +ath11k_ce_byte_swap (frame_tlv->value, buf_len); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_MGMT_TX_SEND_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to submit WMI_MGMT_TX_SEND_CMDID cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_vdev_create (struct ath11k *ar,u8 *macaddr, +struct vdev_create_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_create_cmd *cmd; +struct sk_buff *skb; +struct wmi_vdev_txrx_streams *txrx_streams; +struct wmi_tlv *tlv; +int ret, len; +void *ptr; + +/* It can be optimized my sending tx/rx chain configuration +* only for supported bands instead of always sending it for +* both the bands. +*/ + len =sizeof (*cmd) +TLV_HDR_SIZE + + (WMI_NUM_SUPPORTED_BAND_MAX *sizeof (*txrx_streams)); + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_create_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_CREATE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = param->if_id; + cmd->vdev_type = param->type; + cmd->vdev_subtype = param->subtype; + cmd->num_cfg_txrx_streams =WMI_NUM_SUPPORTED_BAND_MAX ; + cmd->pdev_id = param->pdev_id; +ether_addr_copy (cmd->vdev_macaddr.addr, macaddr); + + ptr = skb->data +sizeof (*cmd); + len =WMI_NUM_SUPPORTED_BAND_MAX *sizeof (*txrx_streams); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len); + + ptr +=TLV_HDR_SIZE ; + txrx_streams = ptr; + len =sizeof (*txrx_streams); + txrx_streams->tlv_header = +FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_TXRX_STREAMS ) | +FIELD_PREP (WMI_TLV_LEN , len -TLV_HDR_SIZE ); + txrx_streams->band =WMI_TPC_CHAINMASK_CONFIG_BAND_2G ; + txrx_streams->supported_tx_streams = + param->chains[NL80211_BAND_2GHZ ].tx; + txrx_streams->supported_rx_streams = + param->chains[NL80211_BAND_2GHZ ].rx; + + txrx_streams++; + txrx_streams->tlv_header = +FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_TXRX_STREAMS ) | +FIELD_PREP (WMI_TLV_LEN , len -TLV_HDR_SIZE ); + txrx_streams->band =WMI_TPC_CHAINMASK_CONFIG_BAND_5G ; + txrx_streams->supported_tx_streams = + param->chains[NL80211_BAND_5GHZ ].tx; + txrx_streams->supported_rx_streams = + param->chains[NL80211_BAND_5GHZ ].rx; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_CREATE_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to submit WMI_VDEV_CREATE_CMDID\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI vdev create: id %d type %d subtype %d macaddr %pM pdevid %d\n" , + param->if_id, param->type, param->subtype, + macaddr, param->pdev_id); + +return ret; +} + +int ath11k_wmi_vdev_delete (struct ath11k *ar,u8 vdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_delete_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_delete_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_DELETE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = vdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_DELETE_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to submit WMI_VDEV_DELETE_CMDID\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI ,"WMI vdev delete id %d\n" , vdev_id); + +return ret; +} + +int ath11k_wmi_vdev_stop (struct ath11k *ar,u8 vdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_stop_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_stop_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_STOP_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = vdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_STOP_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to submit WMI_VDEV_STOP cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI ,"WMI vdev stop id 0x%x\n" , vdev_id); + +return ret; +} + +int ath11k_wmi_vdev_down (struct ath11k *ar,u8 vdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_down_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_down_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_DOWN_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = vdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_DOWN_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to submit WMI_VDEV_DOWN cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI ,"WMI vdev down id 0x%x\n" , vdev_id); + +return ret; +} + +static void ath11k_wmi_put_wmi_channel (struct wmi_channel *chan, +struct wmi_vdev_start_req_arg *arg) +{ +memset (chan,0 ,sizeof (*chan)); + + chan->mhz = arg->channel.freq; + chan->band_center_freq1 = arg->channel.band_center_freq1; +if (arg->channel.mode ==MODE_11AC_VHT80_80 ) + chan->band_center_freq2 = arg->channel.band_center_freq2; +else + chan->band_center_freq2 =0 ; + + chan->info |=FIELD_PREP (WMI_CHAN_INFO_MODE , arg->channel.mode); +if (arg->channel.passive) + chan->info |=WMI_CHAN_INFO_PASSIVE ; +if (arg->channel.allow_ibss) + chan->info |=WMI_CHAN_INFO_ADHOC_ALLOWED ; +if (arg->channel.allow_ht) + chan->info |=WMI_CHAN_INFO_ALLOW_HT ; +if (arg->channel.allow_vht) + chan->info |=WMI_CHAN_INFO_ALLOW_VHT ; +if (arg->channel.ht40plus) + chan->info |=WMI_CHAN_INFO_HT40_PLUS ; +if (arg->channel.chan_radar) + chan->info |=WMI_CHAN_INFO_DFS ; +if (arg->channel.freq2_radar) + chan->info |=WMI_CHAN_INFO_DFS_FREQ2 ; + + chan->reg_info_1 =FIELD_PREP (WMI_CHAN_REG_INFO1_MAX_PWR , + arg->channel.max_power) | +FIELD_PREP (WMI_CHAN_REG_INFO1_MAX_REG_PWR , + arg->channel.max_reg_power); + + chan->reg_info_2 =FIELD_PREP (WMI_CHAN_REG_INFO2_ANT_MAX , + arg->channel.max_antenna_gain) | +FIELD_PREP (WMI_CHAN_REG_INFO2_MAX_TX_PWR , + arg->channel.max_power); +} + +int ath11k_wmi_vdev_start (struct ath11k *ar,struct wmi_vdev_start_req_arg *arg, +bool restart) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_start_request_cmd *cmd; +struct sk_buff *skb; +struct wmi_channel *chan; +struct wmi_tlv *tlv; +void *ptr; +int ret, len; + +if (WARN_ON (arg->ssid_len >sizeof (cmd->ssid.ssid))) +return -EINVAL ; + + len =sizeof (*cmd) +sizeof (*chan) +TLV_HDR_SIZE ; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_start_request_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_VDEV_START_REQUEST_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = arg->vdev_id; + cmd->beacon_interval = arg->bcn_intval; + cmd->bcn_tx_rate = arg->bcn_tx_rate; + cmd->dtim_period = arg->dtim_period; + cmd->num_noa_descriptors = arg->num_noa_descriptors; + cmd->preferred_rx_streams = arg->pref_rx_streams; + cmd->preferred_tx_streams = arg->pref_tx_streams; + cmd->cac_duration_ms = arg->cac_duration_ms; + cmd->regdomain = arg->regdomain; + cmd->he_ops = arg->he_ops; + +if (!restart) { +if (arg->ssid) { + cmd->ssid.ssid_len = arg->ssid_len; +memcpy (cmd->ssid.ssid, arg->ssid, arg->ssid_len); + } +if (arg->hidden_ssid) + cmd->flags |=WMI_VDEV_START_HIDDEN_SSID ; +if (arg->pmf_enabled) + cmd->flags |=WMI_VDEV_START_PMF_ENABLED ; + } + + cmd->flags |=WMI_VDEV_START_LDPC_RX_ENABLED ; + + ptr = skb->data +sizeof (*cmd); + chan = ptr; + +ath11k_wmi_put_wmi_channel (chan, arg); + + chan->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_CHANNEL ) | +FIELD_PREP (WMI_TLV_LEN , +sizeof (*chan) -TLV_HDR_SIZE ); + ptr +=sizeof (*chan); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN ,0 ); + +/* Note: This is a nested TLV containing: +* [wmi_tlv][wmi_p2p_noa_descriptor][wmi_tlv].. +*/ + + ptr +=sizeof (*tlv); + +if (restart) + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_VDEV_RESTART_REQUEST_CMDID ); +else + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_VDEV_START_REQUEST_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to submit vdev_%s cmd\n" , + restart ?"restart" :"start" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI ,"vdev %s id 0x%x freq 0x%x mode 0x%x\n" , + restart ?"restart" :"start" , arg->vdev_id, + arg->channel.freq, arg->channel.mode); + +return ret; +} + +int ath11k_wmi_vdev_up (struct ath11k *ar,u32 vdev_id,u32 aid,const u8 *bssid) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_up_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_up_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_UP_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = vdev_id; + cmd->vdev_assoc_id = aid; + +ether_addr_copy (cmd->vdev_bssid.addr, bssid); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_UP_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to submit WMI_VDEV_UP cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI mgmt vdev up id 0x%x assoc id %d bssid %pM\n" , + vdev_id, aid, bssid); + +return ret; +} + +int ath11k_wmi_send_peer_create_cmd (struct ath11k *ar, +struct peer_create_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_peer_create_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_peer_create_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PEER_CREATE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + +ether_addr_copy (cmd->peer_macaddr.addr, param->peer_addr); + cmd->peer_type = param->peer_type; + cmd->vdev_id = param->vdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PEER_CREATE_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to submit WMI_PEER_CREATE cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI peer create vdev_id %d peer_addr %pM\n" , + param->vdev_id, param->peer_addr); + +return ret; +} + +int ath11k_wmi_send_peer_delete_cmd (struct ath11k *ar, +const u8 *peer_addr,u8 vdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_peer_delete_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_peer_delete_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PEER_DELETE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + +ether_addr_copy (cmd->peer_macaddr.addr, peer_addr); + cmd->vdev_id = vdev_id; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI peer delete vdev_id %d peer_addr %pM\n" , + vdev_id, peer_addr); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PEER_DELETE_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PEER_DELETE cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_send_pdev_set_regdomain (struct ath11k *ar, +struct pdev_set_regdomain_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pdev_set_regdomain_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pdev_set_regdomain_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_PDEV_SET_REGDOMAIN_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->reg_domain = param->current_rd_in_use; + cmd->reg_domain_2g = param->current_rd_2g; + cmd->reg_domain_5g = param->current_rd_5g; + cmd->conformance_test_limit_2g = param->ctl_2g; + cmd->conformance_test_limit_5g = param->ctl_5g; + cmd->dfs_domain = param->dfs_domain; + cmd->pdev_id = param->pdev_id; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI pdev regd rd %d rd2g %d rd5g %d domain %d pdev id %d\n" , + param->current_rd_in_use, param->current_rd_2g, + param->current_rd_5g, param->dfs_domain, param->pdev_id); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PDEV_SET_REGDOMAIN_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PDEV_SET_REGDOMAIN cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_set_peer_param (struct ath11k *ar,const u8 *peer_addr, +u32 vdev_id,u32 param_id,u32 param_val) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_peer_set_param_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_peer_set_param_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PEER_SET_PARAM_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); +ether_addr_copy (cmd->peer_macaddr.addr, peer_addr); + cmd->vdev_id = vdev_id; + cmd->param_id = param_id; + cmd->param_value = param_val; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PEER_SET_PARAM_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PEER_SET_PARAM cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI vdev %d peer 0x%pM set param %d value %d\n" , + vdev_id, peer_addr, param_id, param_val); + +return ret; +} + +int ath11k_wmi_send_peer_flush_tids_cmd (struct ath11k *ar, +u8 peer_addr[ETH_ALEN ], +struct peer_flush_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_peer_flush_tids_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_peer_flush_tids_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PEER_FLUSH_TIDS_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + +ether_addr_copy (cmd->peer_macaddr.addr, peer_addr); + cmd->peer_tid_bitmap = param->peer_tid_bitmap; + cmd->vdev_id = param->vdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PEER_FLUSH_TIDS_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PEER_FLUSH_TIDS cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI peer flush vdev_id %d peer_addr %pM tids %08x\n" , + param->vdev_id, peer_addr, param->peer_tid_bitmap); + +return ret; +} + +int ath11k_wmi_peer_rx_reorder_queue_setup (struct ath11k *ar, +int vdev_id,const u8 *addr, +dma_addr_t paddr,u8 tid, +u8 ba_window_size_valid, +u32 ba_window_size) +{ +struct wmi_peer_reorder_queue_setup_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (ar->wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_peer_reorder_queue_setup_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_REORDER_QUEUE_SETUP_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + +ether_addr_copy (cmd->peer_macaddr.addr, addr); + cmd->vdev_id = vdev_id; + cmd->tid = tid; + cmd->queue_ptr_lo =lower_32_bits (paddr); + cmd->queue_ptr_hi =upper_32_bits (paddr); + cmd->queue_no = tid; + cmd->ba_window_size_valid = ba_window_size_valid; + cmd->ba_window_size = ba_window_size; + + ret =ath11k_wmi_cmd_send (ar->wmi, skb, +WMI_PEER_REORDER_QUEUE_SETUP_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PEER_REORDER_QUEUE_SETUP\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"wmi rx reorder queue setup addr %pM vdev_id %d tid %d\n" , + addr, vdev_id, tid); + +return ret; +} + +int +ath11k_wmi_rx_reord_queue_remove (struct ath11k *ar, +struct rx_reorder_queue_remove_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_peer_reorder_queue_remove_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_peer_reorder_queue_remove_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_REORDER_QUEUE_REMOVE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + +ether_addr_copy (cmd->peer_macaddr.addr, param->peer_macaddr); + cmd->vdev_id = param->vdev_id; + cmd->tid_mask = param->peer_tid_bitmap; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"%s: peer_macaddr %pM vdev_id %d, tid_map %d" , __func__, + param->peer_macaddr, param->vdev_id, param->peer_tid_bitmap); + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_PEER_REORDER_QUEUE_REMOVE_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PEER_REORDER_QUEUE_REMOVE_CMDID" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_pdev_set_param (struct ath11k *ar,u32 param_id, +u32 param_value,u8 pdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pdev_set_param_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pdev_set_param_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_SET_PARAM_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->pdev_id = pdev_id; + cmd->param_id = param_id; + cmd->param_value = param_value; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PDEV_SET_PARAM_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PDEV_SET_PARAM cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI pdev set param %d pdev id %d value %d\n" , + param_id, pdev_id, param_value); + +return ret; +} + +int ath11k_wmi_pdev_suspend (struct ath11k *ar,u32 suspend_opt, +u32 pdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pdev_suspend_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pdev_suspend_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_SUSPEND_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->suspend_opt = suspend_opt; + cmd->pdev_id = pdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PDEV_SUSPEND_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PDEV_SUSPEND cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI pdev suspend pdev_id %d\n" , pdev_id); + +return ret; +} + +int ath11k_wmi_pdev_resume (struct ath11k *ar,u32 pdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pdev_resume_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pdev_resume_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_RESUME_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->pdev_id = pdev_id; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI pdev resume pdev id %d\n" , pdev_id); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PDEV_RESUME_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PDEV_RESUME cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +/* TODO FW Support for the cmd is not available yet. +* Can be tested once the command and corresponding +* event is implemented in FW +*/ +int ath11k_wmi_pdev_bss_chan_info_request (struct ath11k *ar, +enum wmi_bss_chan_info_req_type type) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pdev_bss_chan_info_req_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pdev_bss_chan_info_req_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_PDEV_BSS_CHAN_INFO_REQUEST ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->req_type = type; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI bss chan info req type %d\n" , type); + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_PDEV_BSS_CHAN_INFO_REQUEST_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PDEV_BSS_CHAN_INFO_REQUEST cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_send_set_ap_ps_param_cmd (struct ath11k *ar,u8 *peer_addr, +struct ap_ps_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_ap_ps_peer_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_ap_ps_peer_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_AP_PS_PEER_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = param->vdev_id; +ether_addr_copy (cmd->peer_macaddr.addr, peer_addr); + cmd->param = param->param; + cmd->value = param->value; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_AP_PS_PEER_PARAM_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_AP_PS_PEER_PARAM_CMDID\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI set ap ps vdev id %d peer %pM param %d value %d\n" , + param->vdev_id, peer_addr, param->param, param->value); + +return ret; +} + +int ath11k_wmi_set_sta_ps_param (struct ath11k *ar,u32 vdev_id, +u32 param,u32 param_value) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_sta_powersave_param_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_sta_powersave_param_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_STA_POWERSAVE_PARAM_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = vdev_id; + cmd->param = param; + cmd->value = param_value; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI set sta ps vdev_id %d param %d value %d\n" , + vdev_id, param, param_value); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_STA_POWERSAVE_PARAM_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_STA_POWERSAVE_PARAM_CMDID" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_force_fw_hang_cmd (struct ath11k *ar,u32 type,u32 delay_time_ms) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_force_fw_hang_cmd *cmd; +struct sk_buff *skb; +int ret, len; + + len =sizeof (*cmd); + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_force_fw_hang_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_FORCE_FW_HANG_CMD ) | +FIELD_PREP (WMI_TLV_LEN , len -TLV_HDR_SIZE ); + + cmd->type = type; + cmd->delay_time_ms = delay_time_ms; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_FORCE_FW_HANG_CMDID ); + +if (ret) { +ath11k_warn (ar->ab,"Failed to send WMI_FORCE_FW_HANG_CMDID" ); +dev_kfree_skb (skb); + } +return ret; +} + +int ath11k_wmi_vdev_set_param_cmd (struct ath11k *ar,u32 vdev_id, +u32 param_id,u32 param_value) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_set_param_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_set_param_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_SET_PARAM_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = vdev_id; + cmd->param_id = param_id; + cmd->param_value = param_value; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_SET_PARAM_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_VDEV_SET_PARAM_CMDID\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI vdev id 0x%x set param %d value %d\n" , + vdev_id, param_id, param_value); + +return ret; +} + +int ath11k_wmi_send_stats_request_cmd (struct ath11k *ar, +struct stats_request_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_request_stats_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_request_stats_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_REQUEST_STATS_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->stats_id = param->stats_id; + cmd->vdev_id = param->vdev_id; + cmd->pdev_id = param->pdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_REQUEST_STATS_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_REQUEST_STATS cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI request stats 0x%x vdev id %d pdev id %d\n" , + param->stats_id, param->vdev_id, param->pdev_id); + +return ret; +} + +int ath11k_wmi_send_bcn_offload_control_cmd (struct ath11k *ar, +u32 vdev_id,u32 bcn_ctrl_op) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_bcn_offload_ctrl_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_bcn_offload_ctrl_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_BCN_OFFLOAD_CTRL_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = vdev_id; + cmd->bcn_ctrl_op = bcn_ctrl_op; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI bcn ctrl offload vdev id %d ctrl_op %d\n" , + vdev_id, bcn_ctrl_op); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_BCN_OFFLOAD_CTRL_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_BCN_OFFLOAD_CTRL_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_bcn_tmpl (struct ath11k *ar,u32 vdev_id, +struct ieee80211_mutable_offsets *offs, +struct sk_buff *bcn) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_bcn_tmpl_cmd *cmd; +struct wmi_bcn_prb_info *bcn_prb_info; +struct wmi_tlv *tlv; +struct sk_buff *skb; +void *ptr; +int ret, len; +size_t aligned_len =roundup (bcn->len,4 ); + + len =sizeof (*cmd) +sizeof (*bcn_prb_info) +TLV_HDR_SIZE + aligned_len; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_bcn_tmpl_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_BCN_TMPL_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = vdev_id; + cmd->tim_ie_offset = offs->tim_offset; + cmd->csa_switch_count_offset = offs->csa_counter_offs[0 ]; + cmd->ext_csa_switch_count_offset = offs->csa_counter_offs[1 ]; + cmd->buf_len = bcn->len; + + ptr = skb->data +sizeof (*cmd); + + bcn_prb_info = ptr; + len =sizeof (*bcn_prb_info); + bcn_prb_info->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_BCN_PRB_INFO ) | +FIELD_PREP (WMI_TLV_LEN , len -TLV_HDR_SIZE ); + bcn_prb_info->caps =0 ; + bcn_prb_info->erp =0 ; + + ptr +=sizeof (*bcn_prb_info); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_BYTE ) | +FIELD_PREP (WMI_TLV_LEN , aligned_len); +memcpy (tlv->value, bcn->data, bcn->len); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_BCN_TMPL_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_BCN_TMPL_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_vdev_install_key (struct ath11k *ar, +struct wmi_vdev_install_key_arg *arg) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_install_key_cmd *cmd; +struct wmi_tlv *tlv; +struct sk_buff *skb; +int ret, len; +int key_len_aligned =roundup (arg->key_len,sizeof (uint32_t )); + + len =sizeof (*cmd) +TLV_HDR_SIZE + key_len_aligned; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_install_key_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VDEV_INSTALL_KEY_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + cmd->vdev_id = arg->vdev_id; +ether_addr_copy (cmd->peer_macaddr.addr, arg->macaddr); + cmd->key_idx = arg->key_idx; + cmd->key_flags = arg->key_flags; + cmd->key_cipher = arg->key_cipher; + cmd->key_len = arg->key_len; + cmd->key_txmic_len = arg->key_txmic_len; + cmd->key_rxmic_len = arg->key_rxmic_len; + +if (arg->key_rsc_counter) +memcpy (&cmd->key_rsc_counter, &arg->key_rsc_counter, +sizeof (struct wmi_key_seq_counter )); + + tlv = (struct wmi_tlv *)(skb->data +sizeof (*cmd)); + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_BYTE ) | +FIELD_PREP (WMI_TLV_LEN , key_len_aligned); +memcpy (tlv->value, (u8 *)arg->key_data, key_len_aligned); + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_VDEV_INSTALL_KEY_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_VDEV_INSTALL_KEY cmd\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI vdev install key idx %d cipher %d len %d\n" , + arg->key_idx, arg->key_cipher, arg->key_len); + +return ret; +} + +static inline void +ath11k_wmi_copy_peer_flags (struct wmi_peer_assoc_complete_cmd *cmd, +struct peer_assoc_params *param) +{ + cmd->peer_flags =0 ; + +if (param->is_wme_set) { +if (param->qos_flag) + cmd->peer_flags |=WMI_PEER_QOS ; +if (param->apsd_flag) + cmd->peer_flags |=WMI_PEER_APSD ; +if (param->ht_flag) + cmd->peer_flags |=WMI_PEER_HT ; +if (param->bw_40) + cmd->peer_flags |=WMI_PEER_40MHZ ; +if (param->bw_80) + cmd->peer_flags |=WMI_PEER_80MHZ ; +if (param->bw_160) + cmd->peer_flags |=WMI_PEER_160MHZ ; + +/* Typically if STBC is enabled for VHT it should be enabled +* for HT as well +**/ +if (param->stbc_flag) + cmd->peer_flags |=WMI_PEER_STBC ; + +/* Typically if LDPC is enabled for VHT it should be enabled +* for HT as well +**/ +if (param->ldpc_flag) + cmd->peer_flags |=WMI_PEER_LDPC ; + +if (param->static_mimops_flag) + cmd->peer_flags |=WMI_PEER_STATIC_MIMOPS ; +if (param->dynamic_mimops_flag) + cmd->peer_flags |=WMI_PEER_DYN_MIMOPS ; +if (param->spatial_mux_flag) + cmd->peer_flags |=WMI_PEER_SPATIAL_MUX ; +if (param->vht_flag) + cmd->peer_flags |=WMI_PEER_VHT ; +if (param->he_flag) + cmd->peer_flags |=WMI_PEER_HE ; + } + +/* Suppress authorization for all AUTH modes that need 4-way handshake +* (during re-association). +* Authorization will be done for these modes on key installation. +*/ +if (param->auth_flag) + cmd->peer_flags |=WMI_PEER_AUTH ; +if (param->need_ptk_4_way) + cmd->peer_flags |=WMI_PEER_NEED_PTK_4_WAY ; +else + cmd->peer_flags &= ~WMI_PEER_NEED_PTK_4_WAY ; +if (param->need_gtk_2_way) + cmd->peer_flags |=WMI_PEER_NEED_GTK_2_WAY ; +/* safe mode bypass the 4-way handshake */ +if (param->safe_mode_enabled) + cmd->peer_flags &= ~(WMI_PEER_NEED_PTK_4_WAY | +WMI_PEER_NEED_GTK_2_WAY ); + +if (param->is_pmf_enabled) + cmd->peer_flags |=WMI_PEER_PMF ; + +/* Disable AMSDU for station transmit, if user configures it */ +/* Disable AMSDU for AP transmit to 11n Stations, if user configures +* it +* if (param->amsdu_disable) Add after FW support +**/ + +/* Target asserts if node is marked HT and all MCS is set to 0. +* Mark the node as non-HT if all the mcs rates are disabled through +* iwpriv +**/ +if (param->peer_ht_rates.num_rates ==0 ) + cmd->peer_flags &= ~WMI_PEER_HT ; +} + +int ath11k_wmi_send_peer_assoc_cmd (struct ath11k *ar, +struct peer_assoc_params *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_peer_assoc_complete_cmd *cmd; +struct wmi_vht_rate_set *mcs; +struct wmi_he_rate_set *he_mcs; +struct sk_buff *skb; +struct wmi_tlv *tlv; +void *ptr; +u32 peer_legacy_rates_align; +u32 peer_ht_rates_align; +int i, ret, len; + + peer_legacy_rates_align =roundup (param->peer_legacy_rates.num_rates, +sizeof (u32)); + peer_ht_rates_align =roundup (param->peer_ht_rates.num_rates, +sizeof (u32)); + + len =sizeof (*cmd) + +TLV_HDR_SIZE + (peer_legacy_rates_align *sizeof (u8)) + +TLV_HDR_SIZE + (peer_ht_rates_align *sizeof (u8)) + +sizeof (*mcs) +TLV_HDR_SIZE + + (sizeof (*he_mcs) * param->peer_he_mcs_count); + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + ptr = skb->data; + + cmd = ptr; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_PEER_ASSOC_COMPLETE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = param->vdev_id; + + cmd->peer_new_assoc = param->peer_new_assoc; + cmd->peer_associd = param->peer_associd; + +ath11k_wmi_copy_peer_flags (cmd, param); + +ether_addr_copy (cmd->peer_macaddr.addr, param->peer_mac); + + cmd->peer_rate_caps = param->peer_rate_caps; + cmd->peer_caps = param->peer_caps; + cmd->peer_listen_intval = param->peer_listen_intval; + cmd->peer_ht_caps = param->peer_ht_caps; + cmd->peer_max_mpdu = param->peer_max_mpdu; + cmd->peer_mpdu_density = param->peer_mpdu_density; + cmd->peer_vht_caps = param->peer_vht_caps; + cmd->peer_phymode = param->peer_phymode; + +/* Update 11ax capabilities */ + cmd->peer_he_cap_info = param->peer_he_cap_macinfo[0 ]; + cmd->peer_he_cap_info_ext = param->peer_he_cap_macinfo[1 ]; + cmd->peer_he_cap_info_internal = param->peer_he_cap_macinfo_internal; + cmd->peer_he_ops = param->peer_he_ops; +memcpy (&cmd->peer_he_cap_phy, ¶m->peer_he_cap_phyinfo, +sizeof (param->peer_he_cap_phyinfo)); +memcpy (&cmd->peer_ppet, ¶m->peer_ppet, +sizeof (param->peer_ppet)); + +/* Update peer legacy rate information */ + ptr +=sizeof (*cmd); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_BYTE ) | +FIELD_PREP (WMI_TLV_LEN , peer_legacy_rates_align); + + ptr +=TLV_HDR_SIZE ; + + cmd->num_peer_legacy_rates = param->peer_legacy_rates.num_rates; +memcpy (ptr, param->peer_legacy_rates.rates, + param->peer_legacy_rates.num_rates); + +/* Update peer HT rate information */ + ptr += peer_legacy_rates_align; + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_BYTE ) | +FIELD_PREP (WMI_TLV_LEN , peer_ht_rates_align); + ptr +=TLV_HDR_SIZE ; + cmd->num_peer_ht_rates = param->peer_ht_rates.num_rates; +memcpy (ptr, param->peer_ht_rates.rates, + param->peer_ht_rates.num_rates); + +/* VHT Rates */ + ptr += peer_ht_rates_align; + + mcs = ptr; + + mcs->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_VHT_RATE_SET ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*mcs) -TLV_HDR_SIZE ); + + cmd->peer_nss = param->peer_nss; + +/* Update bandwidth-NSS mapping */ + cmd->peer_bw_rxnss_override =0 ; + cmd->peer_bw_rxnss_override |= param->peer_bw_rxnss_override; + +if (param->vht_capable) { + mcs->rx_max_rate = param->rx_max_rate; + mcs->rx_mcs_set = param->rx_mcs_set; + mcs->tx_max_rate = param->tx_max_rate; + mcs->tx_mcs_set = param->tx_mcs_set; + } + +/* HE Rates */ + cmd->peer_he_mcs = param->peer_he_mcs_count; + + ptr +=sizeof (*mcs); + + len = param->peer_he_mcs_count *sizeof (*he_mcs); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len); + ptr +=TLV_HDR_SIZE ; + +/* Loop through the HE rate set */ +for (i =0 ; i < param->peer_he_mcs_count; i++) { + he_mcs = ptr; + he_mcs->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_HE_RATE_SET ) | +FIELD_PREP (WMI_TLV_LEN , +sizeof (*he_mcs) -TLV_HDR_SIZE ); + + he_mcs->rx_mcs_set = param->peer_he_rx_mcs_set[i]; + he_mcs->tx_mcs_set = param->peer_he_tx_mcs_set[i]; + ptr +=sizeof (*he_mcs); + } + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_PEER_ASSOC_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PEER_ASSOC_CMDID\n" ); +dev_kfree_skb (skb); + } + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI peer assoc vdev id %d assoc id %d peer mac %pM\n" , + param->vdev_id, param->peer_associd, param->peer_mac); + +return ret; +} + +void ath11k_wmi_start_scan_init (struct ath11k *ar, +struct scan_req_params *arg) +{ +/* setup commonly used values */ + arg->scan_req_id =1 ; + arg->scan_priority =WMI_SCAN_PRIORITY_LOW ; + arg->dwell_time_active =50 ; + arg->dwell_time_active_2g =0 ; + arg->dwell_time_passive =150 ; + arg->min_rest_time =50 ; + arg->max_rest_time =500 ; + arg->repeat_probe_time =0 ; + arg->probe_spacing_time =0 ; + arg->idle_time =0 ; + arg->max_scan_time =20000 ; + arg->probe_delay =5 ; + arg->notify_scan_events =WMI_SCAN_EVENT_STARTED | +WMI_SCAN_EVENT_COMPLETED | +WMI_SCAN_EVENT_BSS_CHANNEL | +WMI_SCAN_EVENT_FOREIGN_CHAN | +WMI_SCAN_EVENT_DEQUEUED ; + arg->scan_flags |=WMI_SCAN_CHAN_STAT_EVENT ; + arg->num_bssid =1 ; +} + +static inline void +ath11k_wmi_copy_scan_event_cntrl_flags (struct wmi_start_scan_cmd *cmd, +struct scan_req_params *param) +{ +/* Scan events subscription */ +if (param->scan_ev_started) + cmd->notify_scan_events |=WMI_SCAN_EVENT_STARTED ; +if (param->scan_ev_completed) + cmd->notify_scan_events |=WMI_SCAN_EVENT_COMPLETED ; +if (param->scan_ev_bss_chan) + cmd->notify_scan_events |=WMI_SCAN_EVENT_BSS_CHANNEL ; +if (param->scan_ev_foreign_chan) + cmd->notify_scan_events |=WMI_SCAN_EVENT_FOREIGN_CHAN ; +if (param->scan_ev_dequeued) + cmd->notify_scan_events |=WMI_SCAN_EVENT_DEQUEUED ; +if (param->scan_ev_preempted) + cmd->notify_scan_events |=WMI_SCAN_EVENT_PREEMPTED ; +if (param->scan_ev_start_failed) + cmd->notify_scan_events |=WMI_SCAN_EVENT_START_FAILED ; +if (param->scan_ev_restarted) + cmd->notify_scan_events |=WMI_SCAN_EVENT_RESTARTED ; +if (param->scan_ev_foreign_chn_exit) + cmd->notify_scan_events |=WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT ; +if (param->scan_ev_suspended) + cmd->notify_scan_events |=WMI_SCAN_EVENT_SUSPENDED ; +if (param->scan_ev_resumed) + cmd->notify_scan_events |=WMI_SCAN_EVENT_RESUMED ; + +/** Set scan control flags */ + cmd->scan_ctrl_flags =0 ; +if (param->scan_f_passive) + cmd->scan_ctrl_flags |=WMI_SCAN_FLAG_PASSIVE ; +if (param->scan_f_strict_passive_pch) + cmd->scan_ctrl_flags |=WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN ; +if (param->scan_f_promisc_mode) + cmd->scan_ctrl_flags |=WMI_SCAN_FILTER_PROMISCUOS ; +if (param->scan_f_capture_phy_err) + cmd->scan_ctrl_flags |=WMI_SCAN_CAPTURE_PHY_ERROR ; +if (param->scan_f_half_rate) + cmd->scan_ctrl_flags |=WMI_SCAN_FLAG_HALF_RATE_SUPPORT ; +if (param->scan_f_quarter_rate) + cmd->scan_ctrl_flags |=WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT ; +if (param->scan_f_cck_rates) + cmd->scan_ctrl_flags |=WMI_SCAN_ADD_CCK_RATES ; +if (param->scan_f_ofdm_rates) + cmd->scan_ctrl_flags |=WMI_SCAN_ADD_OFDM_RATES ; +if (param->scan_f_chan_stat_evnt) + cmd->scan_ctrl_flags |=WMI_SCAN_CHAN_STAT_EVENT ; +if (param->scan_f_filter_prb_req) + cmd->scan_ctrl_flags |=WMI_SCAN_FILTER_PROBE_REQ ; +if (param->scan_f_bcast_probe) + cmd->scan_ctrl_flags |=WMI_SCAN_ADD_BCAST_PROBE_REQ ; +if (param->scan_f_offchan_mgmt_tx) + cmd->scan_ctrl_flags |=WMI_SCAN_OFFCHAN_MGMT_TX ; +if (param->scan_f_offchan_data_tx) + cmd->scan_ctrl_flags |=WMI_SCAN_OFFCHAN_DATA_TX ; +if (param->scan_f_force_active_dfs_chn) + cmd->scan_ctrl_flags |=WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS ; +if (param->scan_f_add_tpc_ie_in_probe) + cmd->scan_ctrl_flags |=WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ ; +if (param->scan_f_add_ds_ie_in_probe) + cmd->scan_ctrl_flags |=WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ ; +if (param->scan_f_add_spoofed_mac_in_probe) + cmd->scan_ctrl_flags |=WMI_SCAN_ADD_SPOOF_MAC_IN_PROBE_REQ ; +if (param->scan_f_add_rand_seq_in_probe) + cmd->scan_ctrl_flags |=WMI_SCAN_RANDOM_SEQ_NO_IN_PROBE_REQ ; +if (param->scan_f_en_ie_whitelist_in_probe) + cmd->scan_ctrl_flags |= +WMI_SCAN_ENABLE_IE_WHTELIST_IN_PROBE_REQ ; + +/* for adaptive scan mode using 3 bits (21 - 23 bits) */ +WMI_SCAN_SET_DWELL_MODE (cmd->scan_ctrl_flags, + param->adaptive_dwell_time_mode); +} + +int ath11k_wmi_send_scan_start_cmd (struct ath11k *ar, +struct scan_req_params *params) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_start_scan_cmd *cmd; +struct wmi_ssid *ssid =NULL ; +struct wmi_mac_addr *bssid; +struct sk_buff *skb; +struct wmi_tlv *tlv; +void *ptr; +int i, ret, len; +u32 *tmp_ptr; +u8 extraie_len_with_pad =0 ; + + len =sizeof (*cmd); + + len +=TLV_HDR_SIZE ; +if (params->num_chan) + len += params->num_chan *sizeof (u32); + + len +=TLV_HDR_SIZE ; +if (params->num_ssids) + len += params->num_ssids *sizeof (*ssid); + + len +=TLV_HDR_SIZE ; +if (params->num_bssid) + len +=sizeof (*bssid) * params->num_bssid; + + len +=TLV_HDR_SIZE ; +if (params->extraie.len) + extraie_len_with_pad = +roundup (params->extraie.len,sizeof (u32)); + len += extraie_len_with_pad; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + ptr = skb->data; + + cmd = ptr; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_START_SCAN_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->scan_id = params->scan_id; + cmd->scan_req_id = params->scan_req_id; + cmd->vdev_id = params->vdev_id; + cmd->scan_priority = params->scan_priority; + cmd->notify_scan_events = params->notify_scan_events; + +ath11k_wmi_copy_scan_event_cntrl_flags (cmd, params); + + cmd->dwell_time_active = params->dwell_time_active; + cmd->dwell_time_active_2g = params->dwell_time_active_2g; + cmd->dwell_time_passive = params->dwell_time_passive; + cmd->min_rest_time = params->min_rest_time; + cmd->max_rest_time = params->max_rest_time; + cmd->repeat_probe_time = params->repeat_probe_time; + cmd->probe_spacing_time = params->probe_spacing_time; + cmd->idle_time = params->idle_time; + cmd->max_scan_time = params->max_scan_time; + cmd->probe_delay = params->probe_delay; + cmd->burst_duration = params->burst_duration; + cmd->num_chan = params->num_chan; + cmd->num_bssid = params->num_bssid; + cmd->num_ssids = params->num_ssids; + cmd->ie_len = params->extraie.len; + cmd->n_probes = params->n_probes; + + ptr +=sizeof (*cmd); + + len = params->num_chan *sizeof (u32); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_UINT32 ) | +FIELD_PREP (WMI_TLV_LEN , len); + ptr +=TLV_HDR_SIZE ; + tmp_ptr = (u32 *)ptr; + +for (i =0 ; i < params->num_chan; ++i) + tmp_ptr[i] = params->chan_list[i]; + + ptr += len; + + len = params->num_ssids *sizeof (*ssid); + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_FIXED_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len); + + ptr +=TLV_HDR_SIZE ; + +if (params->num_ssids) { + ssid = ptr; +for (i =0 ; i < params->num_ssids; ++i) { + ssid->ssid_len = params->ssid[i].length; +memcpy (ssid->ssid, params->ssid[i].ssid, + params->ssid[i].length); + ssid++; + } + } + + ptr += (params->num_ssids *sizeof (*ssid)); + len = params->num_bssid *sizeof (*bssid); + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_FIXED_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len); + + ptr +=TLV_HDR_SIZE ; + bssid = ptr; + +if (params->num_bssid) { +for (i =0 ; i < params->num_bssid; ++i) { +ether_addr_copy (bssid->addr, + params->bssid_list[i].addr); + bssid++; + } + } + + ptr += params->num_bssid *sizeof (*bssid); + + len = extraie_len_with_pad; + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_BYTE ) | +FIELD_PREP (WMI_TLV_LEN , len); + ptr +=TLV_HDR_SIZE ; + +if (params->extraie.len) +memcpy (ptr, params->extraie.ptr, + params->extraie.len); + + ptr += extraie_len_with_pad; + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_START_SCAN_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_START_SCAN_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_send_scan_stop_cmd (struct ath11k *ar, +struct scan_cancel_param *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_stop_scan_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_stop_scan_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_STOP_SCAN_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = param->vdev_id; + cmd->requestor = param->requester; + cmd->scan_id = param->scan_id; + cmd->pdev_id = param->pdev_id; +/* stop the scan with the corresponding scan_id */ +if (param->req_type ==WLAN_SCAN_CANCEL_PDEV_ALL ) { +/* Cancelling all scans */ + cmd->req_type =WMI_SCAN_STOP_ALL ; + }else if (param->req_type ==WLAN_SCAN_CANCEL_VDEV_ALL ) { +/* Cancelling VAP scans */ + cmd->req_type =WMI_SCN_STOP_VAP_ALL ; + }else if (param->req_type ==WLAN_SCAN_CANCEL_SINGLE ) { +/* Cancelling specific scan */ + cmd->req_type =WMI_SCAN_STOP_ONE ; + }else { +ath11k_warn (ar->ab,"invalid scan cancel param %d" , + param->req_type); +dev_kfree_skb (skb); +return -EINVAL ; + } + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_STOP_SCAN_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_STOP_SCAN_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_send_scan_chan_list_cmd (struct ath11k *ar, +struct scan_chan_list_params *chan_list) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_scan_chan_list_cmd *cmd; +struct sk_buff *skb; +struct wmi_channel *chan_info; +struct channel_param *tchan_info; +struct wmi_tlv *tlv; +void *ptr; +int i, ret, len; +u32 *reg1, *reg2; + + len =sizeof (*cmd) +TLV_HDR_SIZE + +sizeof (*chan_info) * chan_list->nallchans; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_scan_chan_list_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_SCAN_CHAN_LIST_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI no.of chan = %d len = %d\n" , chan_list->nallchans, len); + cmd->pdev_id = chan_list->pdev_id; + cmd->num_scan_chans = chan_list->nallchans; + + ptr = skb->data +sizeof (*cmd); + + len =sizeof (*chan_info) * chan_list->nallchans; + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len -TLV_HDR_SIZE ); + ptr +=TLV_HDR_SIZE ; + + tchan_info = &chan_list->ch_param[0 ]; + +for (i =0 ; i < chan_list->nallchans; ++i) { + chan_info = ptr; +memset (chan_info,0 ,sizeof (*chan_info)); + len =sizeof (*chan_info); + chan_info->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_CHANNEL ) | +FIELD_PREP (WMI_TLV_LEN , + len -TLV_HDR_SIZE ); + + reg1 = &chan_info->reg_info_1; + reg2 = &chan_info->reg_info_2; + chan_info->mhz = tchan_info->mhz; + chan_info->band_center_freq1 = tchan_info->cfreq1; + chan_info->band_center_freq2 = tchan_info->cfreq2; + +if (tchan_info->is_chan_passive) + chan_info->info |=WMI_CHAN_INFO_PASSIVE ; +if (tchan_info->allow_vht) + chan_info->info |=WMI_CHAN_INFO_ALLOW_VHT ; +else if (tchan_info->allow_ht) + chan_info->info |=WMI_CHAN_INFO_ALLOW_HT ; +if (tchan_info->half_rate) + chan_info->info |=WMI_CHAN_INFO_HALF_RATE ; +if (tchan_info->quarter_rate) + chan_info->info |=WMI_CHAN_INFO_QUARTER_RATE ; + + chan_info->info |=FIELD_PREP (WMI_CHAN_INFO_MODE , + tchan_info->phy_mode); + *reg1 |=FIELD_PREP (WMI_CHAN_REG_INFO1_MIN_PWR , + tchan_info->minpower); + *reg1 |=FIELD_PREP (WMI_CHAN_REG_INFO1_MAX_PWR , + tchan_info->maxpower); + *reg1 |=FIELD_PREP (WMI_CHAN_REG_INFO1_MAX_REG_PWR , + tchan_info->maxregpower); + *reg1 |=FIELD_PREP (WMI_CHAN_REG_INFO1_REG_CLS , + tchan_info->reg_class_id); + *reg2 |=FIELD_PREP (WMI_CHAN_REG_INFO2_ANT_MAX , + tchan_info->antennamax); + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI chan scan list chan[%d] = %u\n" , + i, chan_info->mhz); + + ptr +=sizeof (*chan_info); + + tchan_info++; + } + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_SCAN_CHAN_LIST_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_SCAN_CHAN_LIST cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_send_wmm_update_cmd_tlv (struct ath11k *ar,u32 vdev_id, +struct wmi_wmm_params_all_arg *param) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_vdev_set_wmm_params_cmd *cmd; +struct wmi_wmm_params *wmm_param; +struct wmi_wmm_params_arg *wmi_wmm_arg; +struct sk_buff *skb; +int ret, ac; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_vdev_set_wmm_params_cmd *)skb->data; + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_VDEV_SET_WMM_PARAMS_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->vdev_id = vdev_id; + cmd->wmm_param_type =0 ; + +for (ac =0 ; ac <WME_NUM_AC ; ac++) { +switch (ac) { +case WME_AC_BE : + wmi_wmm_arg = ¶m->ac_be; +break ; +case WME_AC_BK : + wmi_wmm_arg = ¶m->ac_bk; +break ; +case WME_AC_VI : + wmi_wmm_arg = ¶m->ac_vi; +break ; +case WME_AC_VO : + wmi_wmm_arg = ¶m->ac_vo; +break ; + } + + wmm_param = (struct wmi_wmm_params *)&cmd->wmm_params[ac]; + wmm_param->tlv_header = +FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_VDEV_SET_WMM_PARAMS_CMD ) | +FIELD_PREP (WMI_TLV_LEN , +sizeof (*wmm_param) -TLV_HDR_SIZE ); + + wmm_param->aifs = wmi_wmm_arg->aifs; + wmm_param->cwmin = wmi_wmm_arg->cwmin; + wmm_param->cwmax = wmi_wmm_arg->cwmax; + wmm_param->txoplimit = wmi_wmm_arg->txop; + wmm_param->acm = wmi_wmm_arg->acm; + wmm_param->no_ack = wmi_wmm_arg->no_ack; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"wmi wmm set ac %d aifs %d cwmin %d cwmax %d txop %d acm %d no_ack %d\n" , + ac, wmm_param->aifs, wmm_param->cwmin, + wmm_param->cwmax, wmm_param->txoplimit, + wmm_param->acm, wmm_param->no_ack); + } + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_VDEV_SET_WMM_PARAMS_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_VDEV_SET_WMM_PARAMS_CMDID" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_send_dfs_phyerr_offload_enable_cmd (struct ath11k *ar, +u32 pdev_id) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_dfs_phyerr_offload_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_dfs_phyerr_offload_cmd *)skb->data; + cmd->tlv_header = +FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->pdev_id = pdev_id; + +ath11k_dbg (ar->ab,ATH11K_DBG_WMI , +"WMI dfs phy err offload enable pdev id %d\n" , pdev_id); + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID ); +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE cmd\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_pdev_peer_pktlog_filter (struct ath11k *ar,u8 *addr,u8 enable) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pdev_pktlog_filter_cmd *cmd; +struct wmi_pdev_pktlog_filter_info *info; +struct sk_buff *skb; +struct wmi_tlv *tlv; +void *ptr; +int ret, len; + + len =sizeof (*cmd) +sizeof (*info) +TLV_HDR_SIZE ; + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pdev_pktlog_filter_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_PEER_PKTLOG_FILTER_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->pdev_id = ar->pdev->pdev_id; + cmd->num_mac =1 ; + cmd->enable = enable; + + ptr = skb->data +sizeof (*cmd); + + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN ,0 ); + + ptr +=TLV_HDR_SIZE ; + info = ptr; + +ether_addr_copy (info->peer_macaddr.addr, addr); + info->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_PEER_PKTLOG_FILTER_INFO ) | +FIELD_PREP (WMI_TLV_LEN , +sizeof (*info) -TLV_HDR_SIZE ); + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_PDEV_PKTLOG_FILTER_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int +ath11k_wmi_send_init_country_cmd (struct ath11k *ar, +struct wmi_init_country_params init_cc_params) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_init_country_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_init_country_cmd *)skb->data; + cmd->tlv_header = +FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_SET_INIT_COUNTRY_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->pdev_id = ar->pdev->pdev_id; + +switch (init_cc_params.flags) { +case ALPHA_IS_SET : + cmd->init_cc_type =WMI_COUNTRY_INFO_TYPE_ALPHA ; +memcpy ((u8 *)&cmd->cc_info.alpha2, + init_cc_params.cc_info.alpha2,3 ); +break ; +case CC_IS_SET : + cmd->init_cc_type =WMI_COUNTRY_INFO_TYPE_COUNTRY_CODE ; + cmd->cc_info.country_code = init_cc_params.cc_info.country_code; +break ; +case REGDMN_IS_SET : + cmd->init_cc_type =WMI_COUNTRY_INFO_TYPE_REGDOMAIN ; + cmd->cc_info.regdom_id = init_cc_params.cc_info.regdom_id; +break ; +default : + ret = -EINVAL ; + goto out; + } + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_SET_INIT_COUNTRY_CMDID ); + +out: +if (ret) { +ath11k_warn (ar->ab, +"failed to send WMI_SET_INIT_COUNTRY CMD :%d\n" , + ret); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_pdev_pktlog_enable (struct ath11k *ar,u32 pktlog_filter) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pktlog_enable_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pktlog_enable_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_PKTLOG_ENABLE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->pdev_id = ar->pdev->pdev_id; + cmd->evlist = pktlog_filter; + cmd->enable =ATH11K_WMI_PKTLOG_ENABLE_FORCE ; + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_PDEV_PKTLOG_ENABLE_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_pdev_pktlog_disable (struct ath11k *ar) +{ +struct ath11k_pdev_wmi *wmi = ar->wmi; +struct wmi_pktlog_disable_cmd *cmd; +struct sk_buff *skb; +int ret; + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc,sizeof (*cmd)); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_pktlog_disable_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_PDEV_PKTLOG_DISABLE_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + cmd->pdev_id = ar->pdev->pdev_id; + + ret =ath11k_wmi_cmd_send (wmi, skb, +WMI_PDEV_PKTLOG_DISABLE_CMDID ); +if (ret) { +ath11k_warn (ar->ab,"failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +static void +ath11k_fill_band_to_mac_param (struct ath11k_base *soc, +struct wmi_host_pdev_band_to_mac *band_to_mac) +{ +u8 i; +struct ath11k_hal_reg_capabilities_ext *hal_reg_cap; +struct ath11k_pdev *pdev; + +for (i =0 ; i < soc->num_radios; i++) { + pdev = &soc->pdevs[i]; + hal_reg_cap = &soc->hal_reg_cap[i]; + band_to_mac[i].pdev_id = pdev->pdev_id; + +switch (pdev->cap.supported_bands) { +case WMI_HOST_WLAN_2G_5G_CAP : + band_to_mac[i].start_freq = hal_reg_cap->low_2ghz_chan; + band_to_mac[i].end_freq = hal_reg_cap->high_5ghz_chan; +break ; +case WMI_HOST_WLAN_2G_CAP : + band_to_mac[i].start_freq = hal_reg_cap->low_2ghz_chan; + band_to_mac[i].end_freq = hal_reg_cap->high_2ghz_chan; +break ; +case WMI_HOST_WLAN_5G_CAP : + band_to_mac[i].start_freq = hal_reg_cap->low_5ghz_chan; + band_to_mac[i].end_freq = hal_reg_cap->high_5ghz_chan; +break ; +default : +break ; + } + } +} + +static void +ath11k_wmi_copy_resource_config (struct wmi_resource_config *wmi_cfg, +struct target_resource_config *tg_cfg) +{ + wmi_cfg->num_vdevs = tg_cfg->num_vdevs; + wmi_cfg->num_peers = tg_cfg->num_peers; + wmi_cfg->num_offload_peers = tg_cfg->num_offload_peers; + wmi_cfg->num_offload_reorder_buffs = tg_cfg->num_offload_reorder_buffs; + wmi_cfg->num_peer_keys = tg_cfg->num_peer_keys; + wmi_cfg->num_tids = tg_cfg->num_tids; + wmi_cfg->ast_skid_limit = tg_cfg->ast_skid_limit; + wmi_cfg->tx_chain_mask = tg_cfg->tx_chain_mask; + wmi_cfg->rx_chain_mask = tg_cfg->rx_chain_mask; + wmi_cfg->rx_timeout_pri[0 ] = tg_cfg->rx_timeout_pri[0 ]; + wmi_cfg->rx_timeout_pri[1 ] = tg_cfg->rx_timeout_pri[1 ]; + wmi_cfg->rx_timeout_pri[2 ] = tg_cfg->rx_timeout_pri[2 ]; + wmi_cfg->rx_timeout_pri[3 ] = tg_cfg->rx_timeout_pri[3 ]; + wmi_cfg->rx_decap_mode = tg_cfg->rx_decap_mode; + wmi_cfg->scan_max_pending_req = tg_cfg->scan_max_pending_req; + wmi_cfg->bmiss_offload_max_vdev = tg_cfg->bmiss_offload_max_vdev; + wmi_cfg->roam_offload_max_vdev = tg_cfg->roam_offload_max_vdev; + wmi_cfg->roam_offload_max_ap_profiles = + tg_cfg->roam_offload_max_ap_profiles; + wmi_cfg->num_mcast_groups = tg_cfg->num_mcast_groups; + wmi_cfg->num_mcast_table_elems = tg_cfg->num_mcast_table_elems; + wmi_cfg->mcast2ucast_mode = tg_cfg->mcast2ucast_mode; + wmi_cfg->tx_dbg_log_size = tg_cfg->tx_dbg_log_size; + wmi_cfg->num_wds_entries = tg_cfg->num_wds_entries; + wmi_cfg->dma_burst_size = tg_cfg->dma_burst_size; + wmi_cfg->mac_aggr_delim = tg_cfg->mac_aggr_delim; + wmi_cfg->rx_skip_defrag_timeout_dup_detection_check = + tg_cfg->rx_skip_defrag_timeout_dup_detection_check; + wmi_cfg->vow_config = tg_cfg->vow_config; + wmi_cfg->gtk_offload_max_vdev = tg_cfg->gtk_offload_max_vdev; + wmi_cfg->num_msdu_desc = tg_cfg->num_msdu_desc; + wmi_cfg->max_frag_entries = tg_cfg->max_frag_entries; + wmi_cfg->num_tdls_vdevs = tg_cfg->num_tdls_vdevs; + wmi_cfg->num_tdls_conn_table_entries = + tg_cfg->num_tdls_conn_table_entries; + wmi_cfg->beacon_tx_offload_max_vdev = + tg_cfg->beacon_tx_offload_max_vdev; + wmi_cfg->num_multicast_filter_entries = + tg_cfg->num_multicast_filter_entries; + wmi_cfg->num_wow_filters = tg_cfg->num_wow_filters; + wmi_cfg->num_keep_alive_pattern = tg_cfg->num_keep_alive_pattern; + wmi_cfg->keep_alive_pattern_size = tg_cfg->keep_alive_pattern_size; + wmi_cfg->max_tdls_concurrent_sleep_sta = + tg_cfg->max_tdls_concurrent_sleep_sta; + wmi_cfg->max_tdls_concurrent_buffer_sta = + tg_cfg->max_tdls_concurrent_buffer_sta; + wmi_cfg->wmi_send_separate = tg_cfg->wmi_send_separate; + wmi_cfg->num_ocb_vdevs = tg_cfg->num_ocb_vdevs; + wmi_cfg->num_ocb_channels = tg_cfg->num_ocb_channels; + wmi_cfg->num_ocb_schedules = tg_cfg->num_ocb_schedules; + wmi_cfg->bpf_instruction_size = tg_cfg->bpf_instruction_size; + wmi_cfg->max_bssid_rx_filters = tg_cfg->max_bssid_rx_filters; + wmi_cfg->use_pdev_id = tg_cfg->use_pdev_id; + wmi_cfg->flag1 = tg_cfg->atf_config; + wmi_cfg->peer_map_unmap_v2_support = tg_cfg->peer_map_unmap_v2_support; +} + +static int ath11k_init_cmd_send (struct ath11k_pdev_wmi *wmi, +struct wmi_init_cmd_param *param) +{ +struct ath11k_base *ab = wmi->wmi_sc->ab; +struct sk_buff *skb; +struct wmi_init_cmd *cmd; +struct wmi_resource_config *cfg; +struct wmi_pdev_set_hw_mode_cmd_param *hw_mode; +struct wmi_pdev_band_to_mac *band_to_mac; +struct wlan_host_mem_chunk *host_mem_chunks; +struct wmi_tlv *tlv; +size_t ret, len; +void *ptr; +u32 hw_mode_len =0 ; +u16 idx; + +if (param->hw_mode_id !=WMI_HOST_HW_MODE_MAX ) + hw_mode_len =sizeof (*hw_mode) +TLV_HDR_SIZE + + (param->num_band_to_mac *sizeof (*band_to_mac)); + + len =sizeof (*cmd) +TLV_HDR_SIZE +sizeof (*cfg) + hw_mode_len + + (sizeof (*host_mem_chunks) *WMI_MAX_MEM_REQS ); + + skb =ath11k_wmi_alloc_skb (wmi->wmi_sc, len); +if (!skb) +return -ENOMEM ; + + cmd = (struct wmi_init_cmd *)skb->data; + + cmd->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_INIT_CMD ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cmd) -TLV_HDR_SIZE ); + + ptr = skb->data +sizeof (*cmd); + cfg = ptr; + +ath11k_wmi_copy_resource_config (cfg, param->res_cfg); + + cfg->tlv_header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_RESOURCE_CONFIG ) | +FIELD_PREP (WMI_TLV_LEN ,sizeof (*cfg) -TLV_HDR_SIZE ); + + ptr +=sizeof (*cfg); + host_mem_chunks = ptr +TLV_HDR_SIZE ; + len =sizeof (struct wlan_host_mem_chunk ); + +for (idx =0 ; idx < param->num_mem_chunks; ++idx) { + host_mem_chunks[idx].tlv_header = +FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_WLAN_HOST_MEMORY_CHUNK ) | +FIELD_PREP (WMI_TLV_LEN , len); + + host_mem_chunks[idx].ptr = param->mem_chunks[idx].paddr; + host_mem_chunks[idx].size = param->mem_chunks[idx].len; + host_mem_chunks[idx].req_id = param->mem_chunks[idx].req_id; + +ath11k_dbg (ab,ATH11K_DBG_WMI , +"WMI host mem chunk req_id %d paddr 0x%llx len %d\n" , + param->mem_chunks[idx].req_id, + (u64 )param->mem_chunks[idx].paddr, + param->mem_chunks[idx].len); + } + cmd->num_host_mem_chunks = param->num_mem_chunks; + len =sizeof (struct wlan_host_mem_chunk ) * param->num_mem_chunks; + +/* num_mem_chunks is zero */ + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len); + ptr +=TLV_HDR_SIZE + len; + +if (param->hw_mode_id !=WMI_HOST_HW_MODE_MAX ) { + hw_mode = (struct wmi_pdev_set_hw_mode_cmd_param *)ptr; + hw_mode->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_PDEV_SET_HW_MODE_CMD ) | +FIELD_PREP (WMI_TLV_LEN , +sizeof (*hw_mode) -TLV_HDR_SIZE ); + + hw_mode->hw_mode_index = param->hw_mode_id; + hw_mode->num_band_to_mac = param->num_band_to_mac; + + ptr +=sizeof (*hw_mode); + + len = param->num_band_to_mac *sizeof (*band_to_mac); + tlv = ptr; + tlv->header =FIELD_PREP (WMI_TLV_TAG ,WMI_TAG_ARRAY_STRUCT ) | +FIELD_PREP (WMI_TLV_LEN , len); + + ptr +=TLV_HDR_SIZE ; + len =sizeof (*band_to_mac); + +for (idx =0 ; idx < param->num_band_to_mac; idx++) { + band_to_mac = (void *)ptr; + + band_to_mac->tlv_header =FIELD_PREP (WMI_TLV_TAG , +WMI_TAG_PDEV_BAND_TO_MAC ) | +FIELD_PREP (WMI_TLV_LEN , + len -TLV_HDR_SIZE ); + band_to_mac->pdev_id = param->band_to_mac[idx].pdev_id; + band_to_mac->start_freq = + param->band_to_mac[idx].start_freq; + band_to_mac->end_freq = + param->band_to_mac[idx].end_freq; + ptr +=sizeof (*band_to_mac); + } + } + + ret =ath11k_wmi_cmd_send (wmi, skb,WMI_INIT_CMDID ); +if (ret) { +ath11k_warn (ab,"failed to send WMI_INIT_CMDID\n" ); +dev_kfree_skb (skb); + } + +return ret; +} + +int ath11k_wmi_wait_for_service_ready (struct ath11k_base *ab) +{ +unsigned long time_left; + + time_left =wait_for_completion_timeout (&ab->wmi_sc.service_ready, +WMI_SERVICE_READY_TIMEOUT_HZ ); +if (!time_left) +return -ETIMEDOUT ; + +return 0 ; +} + +int ath11k_wmi_wait_for_unified_ready (struct ath11k_base *ab) +{ +unsigned long time_left; + + time_left =wait_for_completion_timeout (&ab->wmi_sc.unified_ready, +WMI_SERVICE_READY_TIMEOUT_HZ ); +if (!time_left) +return -ETIMEDOUT ; + +return 0 ; +} + +int ath11k_wmi_cmd_init (struct ath11k_base *ab) +{ +struct ath11k_wmi_base *wmi_sc = &ab->wmi_sc; +struct wmi_init_cmd_param init_param; +struct target_resource_config config; + +memset (&init_param,0 ,sizeof (init_param)); +memset (&config,0 ,sizeof (config)); + + config.num_vdevs = ab->num_radios *TARGET_NUM_VDEVS ; + +if (ab->num_radios ==2 ) { + config.num_peers =TARGET_NUM_PEERS (DBS ); + config.num_tids =TARGET_NUM_TIDS (DBS ); + }else if (ab->num_radios ==3 ) { + config.num_peers =TARGET_NUM_PEERS (DBS_SBS ); + config.num_tids =TARGET_NUM_TIDS (DBS_SBS ); + }else { +/* Control should not reach here */ + config.num_peers =TARGET_NUM_PEERS (SINGLE ); + config.num_tids =TARGET_NUM_TIDS (SINGLE ); + } + config.num_offload_peers =TARGET_NUM_OFFLD_PEERS ; + config.num_offload_reorder_buffs =TARGET_NUM_OFFLD_REORDER_BUFFS ; + config.num_peer_keys =TARGET_NUM_PEER_KEYS ; + config.ast_skid_limit =TARGET_AST_SKID_LIMIT ; + config.tx_chain_mask = (1 << ab->target_caps.num_rf_chains) -1 ; + config.rx_chain_mask = (1 << ab->target_caps.num_rf_chains) -1 ; + config.rx_timeout_pri[0 ] =TARGET_RX_TIMEOUT_LO_PRI ; + config.rx_timeout_pri[1 ] =TARGET_RX_TIMEOUT_LO_PRI ; + config.rx_timeout_pri[2 ] =TARGET_RX_TIMEOUT_LO_PRI ; + config.rx_timeout_pri[3 ] =TARGET_RX_TIMEOUT_HI_PRI ; + config.rx_decap_mode =TARGET_DECAP_MODE_NATIVE_WIFI ; + config.scan_max_pending_req =TARGET_SCAN_MAX_PENDING_REQS ; + config.bmiss_offload_max_vdev =TARGET_BMISS_OFFLOAD_MAX_VDEV ; + config.roam_offload_max_vdev =TARGET_ROAM_OFFLOAD_MAX_VDEV ; + config.roam_offload_max_ap_profiles =TARGET_ROAM_OFFLOAD_MAX_AP_PROFILES ; + config.num_mcast_groups =TARGET_NUM_MCAST_GROUPS ; + config.num_mcast_table_elems =TARGET_NUM_MCAST_TABLE_ELEMS ; + config.mcast2ucast_mode =TARGET_MCAST2UCAST_MODE ; + config.tx_dbg_log_size =TARGET_TX_DBG_LOG_SIZE ; + config.num_wds_entries =TARGET_NUM_WDS_ENTRIES ; + config.dma_burst_size =TARGET_DMA_BURST_SIZE ; + config.rx_skip_defrag_timeout_dup_detection_check = +TARGET_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK ; + config.vow_config =TARGET_VOW_CONFIG ; + config.gtk_offload_max_vdev =TARGET_GTK_OFFLOAD_MAX_VDEV ; + config.num_msdu_desc =TARGET_NUM_MSDU_DESC ; + config.beacon_tx_offload_max_vdev = ab->num_radios *TARGET_MAX_BCN_OFFLD ; + config.rx_batchmode =TARGET_RX_BATCHMODE ; + config.peer_map_unmap_v2_support =1 ; + +memcpy (&wmi_sc->wlan_resource_config, &config,sizeof (config)); + + init_param.res_cfg = &wmi_sc->wlan_resource_config; + init_param.num_mem_chunks = wmi_sc->num_mem_chunks; + init_param.hw_mode_id = wmi_sc->preferred_hw_mode; + init_param.mem_chunks = wmi_sc->mem_chunks; + +if (wmi_sc->preferred_hw_mode ==WMI_HOST_HW_MODE_SINGLE ) + init_param.hw_mode_id =WMI_HOST_HW_MODE_MAX ; + + init_param.num_band_to_mac = ab->num_radios; + +ath11k_fill_band_to_mac_param (ab, init_param.band_to_mac); + +return ath11k_init_cmd_send (&wmi_sc->wmi[0 ], &init_param); +} + +static int ath11k_wmi_tlv_hw_mode_caps_parse (struct ath11k_base *soc, +u16 tag,u16 len, +const void *ptr,void *data) +{ +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; +struct wmi_hw_mode_capabilities *hw_mode_cap; +u32 phy_map =0 ; + +if (tag !=WMI_TAG_HW_MODE_CAPABILITIES ) +return -EPROTO ; + +if (svc_rdy_ext->n_hw_mode_caps >= svc_rdy_ext->param.num_hw_modes) +return -ENOBUFS ; + + hw_mode_cap = container_of(ptr, struct wmi_hw_mode_capabilities, + hw_mode_id); + svc_rdy_ext->n_hw_mode_caps++; + + phy_map = hw_mode_cap->phy_id_map; +while (phy_map) { + svc_rdy_ext->tot_phy_id++; + phy_map = phy_map >>1 ; + } + +return 0 ; +} + +static int ath11k_wmi_tlv_hw_mode_caps (struct ath11k_base *soc, +u16 len,const void *ptr,void *data) +{ +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; +struct wmi_hw_mode_capabilities *hw_mode_caps; +enum wmi_host_hw_mode_config_type mode, pref; +u32 i; +int ret; + + svc_rdy_ext->n_hw_mode_caps =0 ; + svc_rdy_ext->hw_mode_caps = (struct wmi_hw_mode_capabilities *)ptr; + + ret =ath11k_wmi_tlv_iter (soc, ptr, len, + ath11k_wmi_tlv_hw_mode_caps_parse, + svc_rdy_ext); +if (ret) { +ath11k_warn (soc,"failed to parse tlv %d\n" , ret); +return ret; + } + + i =0 ; +while (i < svc_rdy_ext->n_hw_mode_caps) { + hw_mode_caps = &svc_rdy_ext->hw_mode_caps[i]; + mode = hw_mode_caps->hw_mode_id; + pref = soc->wmi_sc.preferred_hw_mode; + +if (ath11k_hw_mode_pri_map[mode] < ath11k_hw_mode_pri_map[pref]) { + svc_rdy_ext->pref_hw_mode_caps = *hw_mode_caps; + soc->wmi_sc.preferred_hw_mode = mode; + } + i++; + } + +if (soc->wmi_sc.preferred_hw_mode ==WMI_HOST_HW_MODE_MAX ) +return -EINVAL ; + +return 0 ; +} + +static int ath11k_wmi_tlv_mac_phy_caps_parse (struct ath11k_base *soc, +u16 tag,u16 len, +const void *ptr,void *data) +{ +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; + +if (tag !=WMI_TAG_MAC_PHY_CAPABILITIES ) +return -EPROTO ; + +if (svc_rdy_ext->n_mac_phy_caps >= svc_rdy_ext->tot_phy_id) +return -ENOBUFS ; + + svc_rdy_ext->n_mac_phy_caps++; +return 0 ; +} + +static int ath11k_wmi_tlv_ext_hal_reg_caps_parse (struct ath11k_base *soc, +u16 tag,u16 len, +const void *ptr,void *data) +{ +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; + +if (tag !=WMI_TAG_HAL_REG_CAPABILITIES_EXT ) +return -EPROTO ; + +if (svc_rdy_ext->n_ext_hal_reg_caps >= svc_rdy_ext->param.num_phy) +return -ENOBUFS ; + + svc_rdy_ext->n_ext_hal_reg_caps++; +return 0 ; +} + +static int ath11k_wmi_tlv_ext_hal_reg_caps (struct ath11k_base *soc, +u16 len,const void *ptr,void *data) +{ +struct ath11k_pdev_wmi *wmi_handle = &soc->wmi_sc.wmi[0 ]; +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; +struct ath11k_hal_reg_capabilities_ext reg_cap; +int ret; +u32 i; + + svc_rdy_ext->n_ext_hal_reg_caps =0 ; + svc_rdy_ext->ext_hal_reg_caps = (struct wmi_hal_reg_capabilities_ext *)ptr; + ret =ath11k_wmi_tlv_iter (soc, ptr, len, + ath11k_wmi_tlv_ext_hal_reg_caps_parse, + svc_rdy_ext); +if (ret) { +ath11k_warn (soc,"failed to parse tlv %d\n" , ret); +return ret; + } + +for (i =0 ; i < svc_rdy_ext->param.num_phy; i++) { + ret =ath11k_pull_reg_cap_svc_rdy_ext (wmi_handle, + svc_rdy_ext->soc_hal_reg_caps, + svc_rdy_ext->ext_hal_reg_caps, i, + ®_cap); +if (ret) { +ath11k_warn (soc,"failed to extract reg cap %d\n" , i); +return ret; + } + +memcpy (&soc->hal_reg_cap[reg_cap.phy_id], + ®_cap,sizeof (reg_cap)); + } +return 0 ; +} + +static int ath11k_wmi_tlv_ext_soc_hal_reg_caps_parse (struct ath11k_base *soc, +u16 len,const void *ptr, +void *data) +{ +struct ath11k_pdev_wmi *wmi_handle = &soc->wmi_sc.wmi[0 ]; +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; +u8 hw_mode_id = svc_rdy_ext->pref_hw_mode_caps.hw_mode_id; +u32 phy_id_map; +int ret; + + svc_rdy_ext->soc_hal_reg_caps = (struct wmi_soc_hal_reg_capabilities *)ptr; + svc_rdy_ext->param.num_phy = svc_rdy_ext->soc_hal_reg_caps->num_phy; + + soc->num_radios =0 ; + phy_id_map = svc_rdy_ext->pref_hw_mode_caps.phy_id_map; + +while (phy_id_map && soc->num_radios <MAX_RADIOS ) { + ret =ath11k_pull_mac_phy_cap_svc_ready_ext (wmi_handle, + svc_rdy_ext->hw_caps, + svc_rdy_ext->hw_mode_caps, + svc_rdy_ext->soc_hal_reg_caps, + svc_rdy_ext->mac_phy_caps, + hw_mode_id, soc->num_radios, + &soc->pdevs[soc->num_radios]); +if (ret) { +ath11k_warn (soc,"failed to extract mac caps, idx :%d\n" , + soc->num_radios); +return ret; + } + + soc->num_radios++; + +/* TODO: mac_phy_cap prints */ + phy_id_map >>=1 ; + } +return 0 ; +} + +static int ath11k_wmi_tlv_svc_rdy_ext_parse (struct ath11k_base *ab, +u16 tag,u16 len, +const void *ptr,void *data) +{ +struct ath11k_pdev_wmi *wmi_handle = &ab->wmi_sc.wmi[0 ]; +struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data; +int ret; + +switch (tag) { +case WMI_TAG_SERVICE_READY_EXT_EVENT : + ret =ath11k_pull_svc_ready_ext (wmi_handle, ptr, + &svc_rdy_ext->param); +if (ret) { +ath11k_warn (ab,"unable to extract ext params\n" ); +return ret; + } +break ; + +case WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS : + svc_rdy_ext->hw_caps = (struct wmi_soc_mac_phy_hw_mode_caps *)ptr; + svc_rdy_ext->param.num_hw_modes = svc_rdy_ext->hw_caps->num_hw_modes; +break ; + +case WMI_TAG_SOC_HAL_REG_CAPABILITIES : + ret =ath11k_wmi_tlv_ext_soc_hal_reg_caps_parse (ab, len, ptr, + svc_rdy_ext); +if (ret) +return ret; +break ; + +case WMI_TAG_ARRAY_STRUCT : +if (!svc_rdy_ext->hw_mode_done) { + ret =ath11k_wmi_tlv_hw_mode_caps (ab, len, ptr, + svc_rdy_ext); +if (ret) +return ret; + + svc_rdy_ext->hw_mode_done = true; + }else if (!svc_rdy_ext->mac_phy_done) { + svc_rdy_ext->n_mac_phy_caps =0 ; + svc_rdy_ext->mac_phy_caps = + (struct wmi_mac_phy_capabilities *)ptr; + ret =ath11k_wmi_tlv_iter (ab, ptr, len, + ath11k_wmi_tlv_mac_phy_caps_parse, + svc_rdy_ext); +if (ret) { +ath11k_warn (ab,"failed to parse tlv %d\n" , ret); +return ret; + } + + svc_rdy_ext->mac_phy_done = true; + }else if (!svc_rdy_ext->ext_hal_reg_done) { + ret =ath11k_wmi_tlv_ext_hal_reg_caps (ab, len, ptr, + svc_rdy_ext); +if (ret) +return ret; + + svc_rdy_ext->ext_hal_reg_done = true; +complete (&ab->wmi_sc.service_ready); + } +break ; + +default : +break ; + } +return 0 ; +} + +static int ath11k_service_ready_ext_event (struct ath11k_base *ab, +struct sk_buff *skb) +{ +struct wmi_tlv_svc_rdy_ext_parse svc_rdy_ext = { }; +int ret; +
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Part of the diff is not shown here. View the raw message.
PATCH v3 46/49 ath11k: add wmi.h
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/ath11k/wmi.h | 4664 +++++++++++++++++++++++++++++++++ 1 file changed, 4664 insertions(+)
drivers/net/wireless/ath/ath11k/wmi.h new file +4664 -0
@@ -0,0 +1,4664 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. +*/ + +#ifndef ATH11K_WMI_H +#define ATH11K_WMI_H + +#include <net/mac80211.h> +#include "htc.h" + +struct ath11k_base ; +struct ath11k ; +struct ath11k_fw_stats ; + +#define PSOC_HOST_MAX_NUM_SS (8) + +/* defines to set Packet extension values whic can be 0 us, 8 usec or 16 usec */ +#define MAX_HE_NSS 8 +#define MAX_HE_MODULATION 8 +#define MAX_HE_RU 4 +#define HE_MODULATION_NONE 7 +#define HE_PET_0_USEC 0 +#define HE_PET_8_USEC 1 +#define HE_PET_16_USEC 2 + +#define WMI_MAX_NUM_SS MAX_HE_NSS +#define WMI_MAX_NUM_RU MAX_HE_RU + +#define WMI_TLV_CMD (grp_id) (((grp_id) << 12) | 0x1) +#define WMI_TLV_EV (grp_id) (((grp_id) << 12) | 0x1) +#define WMI_TLV_CMD_UNSUPPORTED 0 +#define WMI_TLV_PDEV_PARAM_UNSUPPORTED 0 +#define WMI_TLV_VDEV_PARAM_UNSUPPORTED 0 + +struct wmi_cmd_hdr { +u32 cmd_id; +} __packed; + +struct wmi_tlv { +u32 header; +u8 value[0 ]; +} __packed; + +#define WMI_TLV_LEN GENMASK(15, 0) +#define WMI_TLV_TAG GENMASK(31, 16) +#define TLV_HDR_SIZE FIELD_SIZEOF(struct wmi_tlv, header) + +#define WMI_CMD_HDR_CMD_ID GENMASK(23, 0) +#define WMI_MAX_MEM_REQS 32 +#define ATH11K_MAX_HW_LISTEN_INTERVAL 5 + +#define WLAN_SCAN_PARAMS_MAX_SSID 16 +#define WLAN_SCAN_PARAMS_MAX_BSSID 4 +#define WLAN_SCAN_PARAMS_MAX_IE_LEN 256 + +/* +* HW mode config type replicated from FW header +* @WMI_HOST_HW_MODE_SINGLE: Only one PHY is active. +* @WMI_HOST_HW_MODE_DBS: Both PHYs are active in different bands, +* one in 2G and another in 5G. +* @WMI_HOST_HW_MODE_SBS_PASSIVE: Both PHYs are in passive mode (only rx) in +* same band; no tx allowed. +* @WMI_HOST_HW_MODE_SBS: Both PHYs are active in the same band. +* Support for both PHYs within one band is planned +* for 5G only(as indicated in WMI_MAC_PHY_CAPABILITIES), +* but could be extended to other bands in the future. +* The separation of the band between the two PHYs needs +* to be communicated separately. +* @WMI_HOST_HW_MODE_DBS_SBS: 3 PHYs, with 2 on the same band doing SBS +* as in WMI_HW_MODE_SBS, and 3rd on the other band +* @WMI_HOST_HW_MODE_DBS_OR_SBS: Two PHY with one PHY capabale of both 2G and +* 5G. It can support SBS (5G + 5G) OR DBS (5G + 2G). +* @WMI_HOST_HW_MODE_MAX: Max hw_mode_id. Used to indicate invalid mode. +*/ +enum wmi_host_hw_mode_config_type { +WMI_HOST_HW_MODE_SINGLE =0 , +WMI_HOST_HW_MODE_DBS =1 , +WMI_HOST_HW_MODE_SBS_PASSIVE =2 , +WMI_HOST_HW_MODE_SBS =3 , +WMI_HOST_HW_MODE_DBS_SBS =4 , +WMI_HOST_HW_MODE_DBS_OR_SBS =5 , + +/* keep last */ +WMI_HOST_HW_MODE_MAX +}; + +/* HW mode priority values used to detect the preferred HW mode +* on the available modes. +*/ +enum wmi_host_hw_mode_priority { +WMI_HOST_HW_MODE_DBS_SBS_PRI , +WMI_HOST_HW_MODE_DBS_PRI , +WMI_HOST_HW_MODE_DBS_OR_SBS_PRI , +WMI_HOST_HW_MODE_SBS_PRI , +WMI_HOST_HW_MODE_SBS_PASSIVE_PRI , +WMI_HOST_HW_MODE_SINGLE_PRI , + +/* keep last the lowest priority */ +WMI_HOST_HW_MODE_MAX_PRI +}; + +enum { +WMI_HOST_WLAN_2G_CAP =0x1 , +WMI_HOST_WLAN_5G_CAP =0x2 , +WMI_HOST_WLAN_2G_5G_CAP =0x3 , +}; + +/* +* wmi command groups. +*/ +enum wmi_cmd_group { +/* 0 to 2 are reserved */ +WMI_GRP_START =0x3 , +WMI_GRP_SCAN =WMI_GRP_START , +WMI_GRP_PDEV =0x4 , +WMI_GRP_VDEV =0x5 , +WMI_GRP_PEER =0x6 , +WMI_GRP_MGMT =0x7 , +WMI_GRP_BA_NEG =0x8 , +WMI_GRP_STA_PS =0x9 , +WMI_GRP_DFS =0xa , +WMI_GRP_ROAM =0xb , +WMI_GRP_OFL_SCAN =0xc , +WMI_GRP_P2P =0xd , +WMI_GRP_AP_PS =0xe , +WMI_GRP_RATE_CTRL =0xf , +WMI_GRP_PROFILE =0x10 , +WMI_GRP_SUSPEND =0x11 , +WMI_GRP_BCN_FILTER =0x12 , +WMI_GRP_WOW =0x13 , +WMI_GRP_RTT =0x14 , +WMI_GRP_SPECTRAL =0x15 , +WMI_GRP_STATS =0x16 , +WMI_GRP_ARP_NS_OFL =0x17 , +WMI_GRP_NLO_OFL =0x18 , +WMI_GRP_GTK_OFL =0x19 , +WMI_GRP_CSA_OFL =0x1a , +WMI_GRP_CHATTER =0x1b , +WMI_GRP_TID_ADDBA =0x1c , +WMI_GRP_MISC =0x1d , +WMI_GRP_GPIO =0x1e , +WMI_GRP_FWTEST =0x1f , +WMI_GRP_TDLS =0x20 , +WMI_GRP_RESMGR =0x21 , +WMI_GRP_STA_SMPS =0x22 , +WMI_GRP_WLAN_HB =0x23 , +WMI_GRP_RMC =0x24 , +WMI_GRP_MHF_OFL =0x25 , +WMI_GRP_LOCATION_SCAN =0x26 , +WMI_GRP_OEM =0x27 , +WMI_GRP_NAN =0x28 , +WMI_GRP_COEX =0x29 , +WMI_GRP_OBSS_OFL =0x2a , +WMI_GRP_LPI =0x2b , +WMI_GRP_EXTSCAN =0x2c , +WMI_GRP_DHCP_OFL =0x2d , +WMI_GRP_IPA =0x2e , +WMI_GRP_MDNS_OFL =0x2f , +WMI_GRP_SAP_OFL =0x30 , +WMI_GRP_OCB =0x31 , +WMI_GRP_SOC =0x32 , +WMI_GRP_PKT_FILTER =0x33 , +WMI_GRP_MAWC =0x34 , +WMI_GRP_PMF_OFFLOAD =0x35 , +WMI_GRP_BPF_OFFLOAD =0x36 , +WMI_GRP_NAN_DATA =0x37 , +WMI_GRP_PROTOTYPE =0x38 , +WMI_GRP_MONITOR =0x39 , +WMI_GRP_REGULATORY =0x3a , +WMI_GRP_HW_DATA_FILTER =0x3b , +}; + +#define WMI_CMD_GRP (grp_id) (((grp_id) << 12) | 0x1) +#define WMI_EVT_GRP_START_ID (grp_id) (((grp_id) << 12) | 0x1) + +#define WMI_CMD_UNSUPPORTED 0 + +enum wmi_tlv_cmd_id { +WMI_INIT_CMDID =0x1 , +WMI_START_SCAN_CMDID =WMI_TLV_CMD (WMI_GRP_SCAN ), +WMI_STOP_SCAN_CMDID , +WMI_SCAN_CHAN_LIST_CMDID , +WMI_SCAN_SCH_PRIO_TBL_CMDID , +WMI_SCAN_UPDATE_REQUEST_CMDID , +WMI_SCAN_PROB_REQ_OUI_CMDID , +WMI_SCAN_ADAPTIVE_DWELL_CONFIG_CMDID , +WMI_PDEV_SET_REGDOMAIN_CMDID =WMI_TLV_CMD (WMI_GRP_PDEV ), +WMI_PDEV_SET_CHANNEL_CMDID , +WMI_PDEV_SET_PARAM_CMDID , +WMI_PDEV_PKTLOG_ENABLE_CMDID , +WMI_PDEV_PKTLOG_DISABLE_CMDID , +WMI_PDEV_SET_WMM_PARAMS_CMDID , +WMI_PDEV_SET_HT_CAP_IE_CMDID , +WMI_PDEV_SET_VHT_CAP_IE_CMDID , +WMI_PDEV_SET_DSCP_TID_MAP_CMDID , +WMI_PDEV_SET_QUIET_MODE_CMDID , +WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID , +WMI_PDEV_GET_TPC_CONFIG_CMDID , +WMI_PDEV_SET_BASE_MACADDR_CMDID , +WMI_PDEV_DUMP_CMDID , +WMI_PDEV_SET_LED_CONFIG_CMDID , +WMI_PDEV_GET_TEMPERATURE_CMDID , +WMI_PDEV_SET_LED_FLASHING_CMDID , +WMI_PDEV_SMART_ANT_ENABLE_CMDID , +WMI_PDEV_SMART_ANT_SET_RX_ANTENNA_CMDID , +WMI_PDEV_SET_ANTENNA_SWITCH_TABLE_CMDID , +WMI_PDEV_SET_CTL_TABLE_CMDID , +WMI_PDEV_SET_MIMOGAIN_TABLE_CMDID , +WMI_PDEV_FIPS_CMDID , +WMI_PDEV_GET_ANI_CCK_CONFIG_CMDID , +WMI_PDEV_GET_ANI_OFDM_CONFIG_CMDID , +WMI_PDEV_GET_NFCAL_POWER_CMDID , +WMI_PDEV_GET_TPC_CMDID , +WMI_MIB_STATS_ENABLE_CMDID , +WMI_PDEV_SET_PCL_CMDID , +WMI_PDEV_SET_HW_MODE_CMDID , +WMI_PDEV_SET_MAC_CONFIG_CMDID , +WMI_PDEV_SET_ANTENNA_MODE_CMDID , +WMI_SET_PERIODIC_CHANNEL_STATS_CONFIG_CMDID , +WMI_PDEV_WAL_POWER_DEBUG_CMDID , +WMI_PDEV_SET_REORDER_TIMEOUT_VAL_CMDID , +WMI_PDEV_SET_WAKEUP_CONFIG_CMDID , +WMI_PDEV_GET_ANTDIV_STATUS_CMDID , +WMI_PDEV_GET_CHIP_POWER_STATS_CMDID , +WMI_PDEV_SET_STATS_THRESHOLD_CMDID , +WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID , +WMI_PDEV_UPDATE_PKT_ROUTING_CMDID , +WMI_PDEV_CHECK_CAL_VERSION_CMDID , +WMI_PDEV_SET_DIVERSITY_GAIN_CMDID , +WMI_PDEV_DIV_GET_RSSI_ANTID_CMDID , +WMI_PDEV_BSS_CHAN_INFO_REQUEST_CMDID , +WMI_PDEV_UPDATE_PMK_CACHE_CMDID , +WMI_PDEV_UPDATE_FILS_HLP_PKT_CMDID , +WMI_PDEV_UPDATE_CTLTABLE_REQUEST_CMDID , +WMI_PDEV_CONFIG_VENDOR_OUI_ACTION_CMDID , +WMI_PDEV_SET_AC_TX_QUEUE_OPTIMIZED_CMDID , +WMI_PDEV_SET_RX_FILTER_PROMISCUOUS_CMDID , +WMI_PDEV_DMA_RING_CFG_REQ_CMDID , +WMI_PDEV_HE_TB_ACTION_FRM_CMDID , +WMI_PDEV_PKTLOG_FILTER_CMDID , +WMI_VDEV_CREATE_CMDID =WMI_TLV_CMD (WMI_GRP_VDEV ), +WMI_VDEV_DELETE_CMDID , +WMI_VDEV_START_REQUEST_CMDID , +WMI_VDEV_RESTART_REQUEST_CMDID , +WMI_VDEV_UP_CMDID , +WMI_VDEV_STOP_CMDID , +WMI_VDEV_DOWN_CMDID , +WMI_VDEV_SET_PARAM_CMDID , +WMI_VDEV_INSTALL_KEY_CMDID , +WMI_VDEV_WNM_SLEEPMODE_CMDID , +WMI_VDEV_WMM_ADDTS_CMDID , +WMI_VDEV_WMM_DELTS_CMDID , +WMI_VDEV_SET_WMM_PARAMS_CMDID , +WMI_VDEV_SET_GTX_PARAMS_CMDID , +WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID , +WMI_VDEV_PLMREQ_START_CMDID , +WMI_VDEV_PLMREQ_STOP_CMDID , +WMI_VDEV_TSF_TSTAMP_ACTION_CMDID , +WMI_VDEV_SET_IE_CMDID , +WMI_VDEV_RATEMASK_CMDID , +WMI_VDEV_ATF_REQUEST_CMDID , +WMI_VDEV_SET_DSCP_TID_MAP_CMDID , +WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID , +WMI_VDEV_SET_QUIET_MODE_CMDID , +WMI_VDEV_SET_CUSTOM_AGGR_SIZE_CMDID , +WMI_VDEV_ENCRYPT_DECRYPT_DATA_REQ_CMDID , +WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_CMDID , +WMI_PEER_CREATE_CMDID =WMI_TLV_CMD (WMI_GRP_PEER ), +WMI_PEER_DELETE_CMDID , +WMI_PEER_FLUSH_TIDS_CMDID , +WMI_PEER_SET_PARAM_CMDID , +WMI_PEER_ASSOC_CMDID , +WMI_PEER_ADD_WDS_ENTRY_CMDID , +WMI_PEER_REMOVE_WDS_ENTRY_CMDID , +WMI_PEER_MCAST_GROUP_CMDID , +WMI_PEER_INFO_REQ_CMDID , +WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID , +WMI_PEER_SET_RATE_REPORT_CONDITION_CMDID , +WMI_PEER_UPDATE_WDS_ENTRY_CMDID , +WMI_PEER_ADD_PROXY_STA_ENTRY_CMDID , +WMI_PEER_SMART_ANT_SET_TX_ANTENNA_CMDID , +WMI_PEER_SMART_ANT_SET_TRAIN_INFO_CMDID , +WMI_PEER_SMART_ANT_SET_NODE_CONFIG_OPS_CMDID , +WMI_PEER_ATF_REQUEST_CMDID , +WMI_PEER_BWF_REQUEST_CMDID , +WMI_PEER_REORDER_QUEUE_SETUP_CMDID , +WMI_PEER_REORDER_QUEUE_REMOVE_CMDID , +WMI_PEER_SET_RX_BLOCKSIZE_CMDID , +WMI_PEER_ANTDIV_INFO_REQ_CMDID , +WMI_PEER_OPER_MODE_CHANGE_EVENTID , +WMI_BCN_TX_CMDID =WMI_TLV_CMD (WMI_GRP_MGMT ), +WMI_PDEV_SEND_BCN_CMDID , +WMI_BCN_TMPL_CMDID , +WMI_BCN_FILTER_RX_CMDID , +WMI_PRB_REQ_FILTER_RX_CMDID , +WMI_MGMT_TX_CMDID , +WMI_PRB_TMPL_CMDID , +WMI_MGMT_TX_SEND_CMDID , +WMI_OFFCHAN_DATA_TX_SEND_CMDID , +WMI_PDEV_SEND_FD_CMDID , +WMI_BCN_OFFLOAD_CTRL_CMDID , +WMI_BSS_COLOR_CHANGE_ENABLE_CMDID , +WMI_VDEV_BCN_OFFLOAD_QUIET_CONFIG_CMDID , +WMI_ADDBA_CLEAR_RESP_CMDID =WMI_TLV_CMD (WMI_GRP_BA_NEG ), +WMI_ADDBA_SEND_CMDID , +WMI_ADDBA_STATUS_CMDID , +WMI_DELBA_SEND_CMDID , +WMI_ADDBA_SET_RESP_CMDID , +WMI_SEND_SINGLEAMSDU_CMDID , +WMI_STA_POWERSAVE_MODE_CMDID =WMI_TLV_CMD (WMI_GRP_STA_PS ), +WMI_STA_POWERSAVE_PARAM_CMDID , +WMI_STA_MIMO_PS_MODE_CMDID , +WMI_PDEV_DFS_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_DFS ), +WMI_PDEV_DFS_DISABLE_CMDID , +WMI_DFS_PHYERR_FILTER_ENA_CMDID , +WMI_DFS_PHYERR_FILTER_DIS_CMDID , +WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID , +WMI_PDEV_DFS_PHYERR_OFFLOAD_DISABLE_CMDID , +WMI_VDEV_ADFS_CH_CFG_CMDID , +WMI_VDEV_ADFS_OCAC_ABORT_CMDID , +WMI_ROAM_SCAN_MODE =WMI_TLV_CMD (WMI_GRP_ROAM ), +WMI_ROAM_SCAN_RSSI_THRESHOLD , +WMI_ROAM_SCAN_PERIOD , +WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD , +WMI_ROAM_AP_PROFILE , +WMI_ROAM_CHAN_LIST , +WMI_ROAM_SCAN_CMD , +WMI_ROAM_SYNCH_COMPLETE , +WMI_ROAM_SET_RIC_REQUEST_CMDID , +WMI_ROAM_INVOKE_CMDID , +WMI_ROAM_FILTER_CMDID , +WMI_ROAM_SUBNET_CHANGE_CONFIG_CMDID , +WMI_ROAM_CONFIGURE_MAWC_CMDID , +WMI_ROAM_SET_MBO_PARAM_CMDID , +WMI_ROAM_PER_CONFIG_CMDID , +WMI_OFL_SCAN_ADD_AP_PROFILE =WMI_TLV_CMD (WMI_GRP_OFL_SCAN ), +WMI_OFL_SCAN_REMOVE_AP_PROFILE , +WMI_OFL_SCAN_PERIOD , +WMI_P2P_DEV_SET_DEVICE_INFO =WMI_TLV_CMD (WMI_GRP_P2P ), +WMI_P2P_DEV_SET_DISCOVERABILITY , +WMI_P2P_GO_SET_BEACON_IE , +WMI_P2P_GO_SET_PROBE_RESP_IE , +WMI_P2P_SET_VENDOR_IE_DATA_CMDID , +WMI_P2P_DISC_OFFLOAD_CONFIG_CMDID , +WMI_P2P_DISC_OFFLOAD_APPIE_CMDID , +WMI_P2P_DISC_OFFLOAD_PATTERN_CMDID , +WMI_P2P_SET_OPPPS_PARAM_CMDID , +WMI_P2P_LISTEN_OFFLOAD_START_CMDID , +WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID , +WMI_AP_PS_PEER_PARAM_CMDID =WMI_TLV_CMD (WMI_GRP_AP_PS ), +WMI_AP_PS_PEER_UAPSD_COEX_CMDID , +WMI_AP_PS_EGAP_PARAM_CMDID , +WMI_PEER_RATE_RETRY_SCHED_CMDID =WMI_TLV_CMD (WMI_GRP_RATE_CTRL ), +WMI_WLAN_PROFILE_TRIGGER_CMDID =WMI_TLV_CMD (WMI_GRP_PROFILE ), +WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID , +WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID , +WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID , +WMI_WLAN_PROFILE_LIST_PROFILE_ID_CMDID , +WMI_PDEV_SUSPEND_CMDID =WMI_TLV_CMD (WMI_GRP_SUSPEND ), +WMI_PDEV_RESUME_CMDID , +WMI_ADD_BCN_FILTER_CMDID =WMI_TLV_CMD (WMI_GRP_BCN_FILTER ), +WMI_RMV_BCN_FILTER_CMDID , +WMI_WOW_ADD_WAKE_PATTERN_CMDID =WMI_TLV_CMD (WMI_GRP_WOW ), +WMI_WOW_DEL_WAKE_PATTERN_CMDID , +WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID , +WMI_WOW_ENABLE_CMDID , +WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID , +WMI_WOW_IOAC_ADD_KEEPALIVE_CMDID , +WMI_WOW_IOAC_DEL_KEEPALIVE_CMDID , +WMI_WOW_IOAC_ADD_WAKE_PATTERN_CMDID , +WMI_WOW_IOAC_DEL_WAKE_PATTERN_CMDID , +WMI_D0_WOW_ENABLE_DISABLE_CMDID , +WMI_EXTWOW_ENABLE_CMDID , +WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID , +WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID , +WMI_WOW_ENABLE_ICMPV6_NA_FLT_CMDID , +WMI_WOW_UDP_SVC_OFLD_CMDID , +WMI_WOW_HOSTWAKEUP_GPIO_PIN_PATTERN_CONFIG_CMDID , +WMI_WOW_SET_ACTION_WAKE_UP_CMDID , +WMI_RTT_MEASREQ_CMDID =WMI_TLV_CMD (WMI_GRP_RTT ), +WMI_RTT_TSF_CMDID , +WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID =WMI_TLV_CMD (WMI_GRP_SPECTRAL ), +WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID , +WMI_REQUEST_STATS_CMDID =WMI_TLV_CMD (WMI_GRP_STATS ), +WMI_MCC_SCHED_TRAFFIC_STATS_CMDID , +WMI_REQUEST_STATS_EXT_CMDID , +WMI_REQUEST_LINK_STATS_CMDID , +WMI_START_LINK_STATS_CMDID , +WMI_CLEAR_LINK_STATS_CMDID , +WMI_GET_FW_MEM_DUMP_CMDID , +WMI_DEBUG_MESG_FLUSH_CMDID , +WMI_DIAG_EVENT_LOG_CONFIG_CMDID , +WMI_REQUEST_WLAN_STATS_CMDID , +WMI_REQUEST_RCPI_CMDID , +WMI_REQUEST_PEER_STATS_INFO_CMDID , +WMI_REQUEST_RADIO_CHAN_STATS_CMDID , +WMI_SET_ARP_NS_OFFLOAD_CMDID =WMI_TLV_CMD (WMI_GRP_ARP_NS_OFL ), +WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID , +WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID , +WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID =WMI_TLV_CMD (WMI_GRP_NLO_OFL ), +WMI_APFIND_CMDID , +WMI_PASSPOINT_LIST_CONFIG_CMDID , +WMI_NLO_CONFIGURE_MAWC_CMDID , +WMI_GTK_OFFLOAD_CMDID =WMI_TLV_CMD (WMI_GRP_GTK_OFL ), +WMI_CSA_OFFLOAD_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_CSA_OFL ), +WMI_CSA_OFFLOAD_CHANSWITCH_CMDID , +WMI_CHATTER_SET_MODE_CMDID =WMI_TLV_CMD (WMI_GRP_CHATTER ), +WMI_CHATTER_ADD_COALESCING_FILTER_CMDID , +WMI_CHATTER_DELETE_COALESCING_FILTER_CMDID , +WMI_CHATTER_COALESCING_QUERY_CMDID , +WMI_PEER_TID_ADDBA_CMDID =WMI_TLV_CMD (WMI_GRP_TID_ADDBA ), +WMI_PEER_TID_DELBA_CMDID , +WMI_STA_DTIM_PS_METHOD_CMDID , +WMI_STA_UAPSD_AUTO_TRIG_CMDID , +WMI_STA_KEEPALIVE_CMDID , +WMI_BA_REQ_SSN_CMDID , +WMI_ECHO_CMDID =WMI_TLV_CMD (WMI_GRP_MISC ), +WMI_PDEV_UTF_CMDID , +WMI_DBGLOG_CFG_CMDID , +WMI_PDEV_QVIT_CMDID , +WMI_PDEV_FTM_INTG_CMDID , +WMI_VDEV_SET_KEEPALIVE_CMDID , +WMI_VDEV_GET_KEEPALIVE_CMDID , +WMI_FORCE_FW_HANG_CMDID , +WMI_SET_MCASTBCAST_FILTER_CMDID , +WMI_THERMAL_MGMT_CMDID , +WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID , +WMI_TPC_CHAINMASK_CONFIG_CMDID , +WMI_SET_ANTENNA_DIVERSITY_CMDID , +WMI_OCB_SET_SCHED_CMDID , +WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID , +WMI_LRO_CONFIG_CMDID , +WMI_TRANSFER_DATA_TO_FLASH_CMDID , +WMI_CONFIG_ENHANCED_MCAST_FILTER_CMDID , +WMI_VDEV_WISA_CMDID , +WMI_DBGLOG_TIME_STAMP_SYNC_CMDID , +WMI_SET_MULTIPLE_MCAST_FILTER_CMDID , +WMI_READ_DATA_FROM_FLASH_CMDID , +WMI_GPIO_CONFIG_CMDID =WMI_TLV_CMD (WMI_GRP_GPIO ), +WMI_GPIO_OUTPUT_CMDID , +WMI_TXBF_CMDID , +WMI_FWTEST_VDEV_MCC_SET_TBTT_MODE_CMDID =WMI_TLV_CMD (WMI_GRP_FWTEST ), +WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID , +WMI_UNIT_TEST_CMDID , +WMI_FWTEST_CMDID , +WMI_QBOOST_CFG_CMDID , +WMI_TDLS_SET_STATE_CMDID =WMI_TLV_CMD (WMI_GRP_TDLS ), +WMI_TDLS_PEER_UPDATE_CMDID , +WMI_TDLS_SET_OFFCHAN_MODE_CMDID , +WMI_RESMGR_ADAPTIVE_OCS_EN_DIS_CMDID =WMI_TLV_CMD (WMI_GRP_RESMGR ), +WMI_RESMGR_SET_CHAN_TIME_QUOTA_CMDID , +WMI_RESMGR_SET_CHAN_LATENCY_CMDID , +WMI_STA_SMPS_FORCE_MODE_CMDID =WMI_TLV_CMD (WMI_GRP_STA_SMPS ), +WMI_STA_SMPS_PARAM_CMDID , +WMI_HB_SET_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_WLAN_HB ), +WMI_HB_SET_TCP_PARAMS_CMDID , +WMI_HB_SET_TCP_PKT_FILTER_CMDID , +WMI_HB_SET_UDP_PARAMS_CMDID , +WMI_HB_SET_UDP_PKT_FILTER_CMDID , +WMI_RMC_SET_MODE_CMDID =WMI_TLV_CMD (WMI_GRP_RMC ), +WMI_RMC_SET_ACTION_PERIOD_CMDID , +WMI_RMC_CONFIG_CMDID , +WMI_RMC_SET_MANUAL_LEADER_CMDID , +WMI_MHF_OFFLOAD_SET_MODE_CMDID =WMI_TLV_CMD (WMI_GRP_MHF_OFL ), +WMI_MHF_OFFLOAD_PLUMB_ROUTING_TBL_CMDID , +WMI_BATCH_SCAN_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_LOCATION_SCAN ), +WMI_BATCH_SCAN_DISABLE_CMDID , +WMI_BATCH_SCAN_TRIGGER_RESULT_CMDID , +WMI_OEM_REQ_CMDID =WMI_TLV_CMD (WMI_GRP_OEM ), +WMI_OEM_REQUEST_CMDID , +WMI_LPI_OEM_REQ_CMDID , +WMI_NAN_CMDID =WMI_TLV_CMD (WMI_GRP_NAN ), +WMI_MODEM_POWER_STATE_CMDID =WMI_TLV_CMD (WMI_GRP_COEX ), +WMI_CHAN_AVOID_UPDATE_CMDID , +WMI_COEX_CONFIG_CMDID , +WMI_CHAN_AVOID_RPT_ALLOW_CMDID , +WMI_COEX_GET_ANTENNA_ISOLATION_CMDID , +WMI_SAR_LIMITS_CMDID , +WMI_OBSS_SCAN_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_OBSS_OFL ), +WMI_OBSS_SCAN_DISABLE_CMDID , +WMI_LPI_MGMT_SNOOPING_CONFIG_CMDID =WMI_TLV_CMD (WMI_GRP_LPI ), +WMI_LPI_START_SCAN_CMDID , +WMI_LPI_STOP_SCAN_CMDID , +WMI_EXTSCAN_START_CMDID =WMI_TLV_CMD (WMI_GRP_EXTSCAN ), +WMI_EXTSCAN_STOP_CMDID , +WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID , +WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID , +WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID , +WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID , +WMI_EXTSCAN_SET_CAPABILITIES_CMDID , +WMI_EXTSCAN_GET_CAPABILITIES_CMDID , +WMI_EXTSCAN_CONFIGURE_HOTLIST_SSID_MONITOR_CMDID , +WMI_EXTSCAN_CONFIGURE_MAWC_CMDID , +WMI_SET_DHCP_SERVER_OFFLOAD_CMDID =WMI_TLV_CMD (WMI_GRP_DHCP_OFL ), +WMI_IPA_OFFLOAD_ENABLE_DISABLE_CMDID =WMI_TLV_CMD (WMI_GRP_IPA ), +WMI_MDNS_OFFLOAD_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_MDNS_OFL ), +WMI_MDNS_SET_FQDN_CMDID , +WMI_MDNS_SET_RESPONSE_CMDID , +WMI_MDNS_GET_STATS_CMDID , +WMI_SAP_OFL_ENABLE_CMDID =WMI_TLV_CMD (WMI_GRP_SAP_OFL ), +WMI_SAP_SET_BLACKLIST_PARAM_CMDID , +WMI_OCB_SET_CONFIG_CMDID =WMI_TLV_CMD (WMI_GRP_OCB ), +WMI_OCB_SET_UTC_TIME_CMDID , +WMI_OCB_START_TIMING_ADVERT_CMDID , +WMI_OCB_STOP_TIMING_ADVERT_CMDID , +WMI_OCB_GET_TSF_TIMER_CMDID , +WMI_DCC_GET_STATS_CMDID , +WMI_DCC_CLEAR_STATS_CMDID , +WMI_DCC_UPDATE_NDL_CMDID , +WMI_SOC_SET_PCL_CMDID =WMI_TLV_CMD (WMI_GRP_SOC ), +WMI_SOC_SET_HW_MODE_CMDID , +WMI_SOC_SET_DUAL_MAC_CONFIG_CMDID , +WMI_SOC_SET_ANTENNA_MODE_CMDID , +WMI_PACKET_FILTER_CONFIG_CMDID =WMI_TLV_CMD (WMI_GRP_PKT_FILTER ), +WMI_PACKET_FILTER_ENABLE_CMDID , +WMI_MAWC_SENSOR_REPORT_IND_CMDID =WMI_TLV_CMD (WMI_GRP_MAWC ), +WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID =WMI_TLV_CMD (WMI_GRP_PMF_OFFLOAD ), +WMI_BPF_GET_CAPABILITY_CMDID =WMI_TLV_CMD (WMI_GRP_BPF_OFFLOAD ), +WMI_BPF_GET_VDEV_STATS_CMDID , +WMI_BPF_SET_VDEV_INSTRUCTIONS_CMDID , +WMI_BPF_DEL_VDEV_INSTRUCTIONS_CMDID , +WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID , +WMI_MNT_FILTER_CMDID =WMI_TLV_CMD (WMI_GRP_MONITOR ), +WMI_SET_CURRENT_COUNTRY_CMDID =WMI_TLV_CMD (WMI_GRP_REGULATORY ), +WMI_11D_SCAN_START_CMDID , +WMI_11D_SCAN_STOP_CMDID , +WMI_SET_INIT_COUNTRY_CMDID , +WMI_NDI_GET_CAP_REQ_CMDID =WMI_TLV_CMD (WMI_GRP_PROTOTYPE ), +WMI_NDP_INITIATOR_REQ_CMDID , +WMI_NDP_RESPONDER_REQ_CMDID , +WMI_NDP_END_REQ_CMDID , +WMI_HW_DATA_FILTER_CMDID =WMI_TLV_CMD (WMI_GRP_HW_DATA_FILTER ), +}; + +enum wmi_tlv_event_id { +WMI_SERVICE_READY_EVENTID =0x1 , +WMI_READY_EVENTID , +WMI_SERVICE_AVAILABLE_EVENTID , +WMI_SCAN_EVENTID =WMI_EVT_GRP_START_ID (WMI_GRP_SCAN ), +WMI_PDEV_TPC_CONFIG_EVENTID =WMI_TLV_CMD (WMI_GRP_PDEV ), +WMI_CHAN_INFO_EVENTID , +WMI_PHYERR_EVENTID , +WMI_PDEV_DUMP_EVENTID , +WMI_TX_PAUSE_EVENTID , +WMI_DFS_RADAR_EVENTID , +WMI_PDEV_L1SS_TRACK_EVENTID , +WMI_PDEV_TEMPERATURE_EVENTID , +WMI_SERVICE_READY_EXT_EVENTID , +WMI_PDEV_FIPS_EVENTID , +WMI_PDEV_CHANNEL_HOPPING_EVENTID , +WMI_PDEV_ANI_CCK_LEVEL_EVENTID , +WMI_PDEV_ANI_OFDM_LEVEL_EVENTID , +WMI_PDEV_TPC_EVENTID , +WMI_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENTID , +WMI_PDEV_SET_HW_MODE_RESP_EVENTID , +WMI_PDEV_HW_MODE_TRANSITION_EVENTID , +WMI_PDEV_SET_MAC_CONFIG_RESP_EVENTID , +WMI_PDEV_ANTDIV_STATUS_EVENTID , +WMI_PDEV_CHIP_POWER_STATS_EVENTID , +WMI_PDEV_CHIP_POWER_SAVE_FAILURE_DETECTED_EVENTID , +WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID , +WMI_PDEV_CHECK_CAL_VERSION_EVENTID , +WMI_PDEV_DIV_RSSI_ANTID_EVENTID , +WMI_PDEV_BSS_CHAN_INFO_EVENTID , +WMI_PDEV_UPDATE_CTLTABLE_EVENTID , +WMI_PDEV_DMA_RING_CFG_RSP_EVENTID , +WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID , +WMI_PDEV_CTL_FAILSAFE_CHECK_EVENTID , +WMI_VDEV_START_RESP_EVENTID =WMI_TLV_CMD (WMI_GRP_VDEV ), +WMI_VDEV_STOPPED_EVENTID , +WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID , +WMI_VDEV_MCC_BCN_INTERVAL_CHANGE_REQ_EVENTID , +WMI_VDEV_TSF_REPORT_EVENTID , +WMI_VDEV_DELETE_RESP_EVENTID , +WMI_VDEV_ENCRYPT_DECRYPT_DATA_RESP_EVENTID , +WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID , +WMI_PEER_STA_KICKOUT_EVENTID =WMI_TLV_CMD (WMI_GRP_PEER ), +WMI_PEER_INFO_EVENTID , +WMI_PEER_TX_FAIL_CNT_THR_EVENTID , +WMI_PEER_ESTIMATED_LINKSPEED_EVENTID , +WMI_PEER_STATE_EVENTID , +WMI_PEER_ASSOC_CONF_EVENTID , +WMI_PEER_DELETE_RESP_EVENTID , +WMI_PEER_RATECODE_LIST_EVENTID , +WMI_WDS_PEER_EVENTID , +WMI_PEER_STA_PS_STATECHG_EVENTID , +WMI_PEER_ANTDIV_INFO_EVENTID , +WMI_MGMT_RX_EVENTID =WMI_TLV_CMD (WMI_GRP_MGMT ), +WMI_HOST_SWBA_EVENTID , +WMI_TBTTOFFSET_UPDATE_EVENTID , +WMI_OFFLOAD_BCN_TX_STATUS_EVENTID , +WMI_OFFLOAD_PROB_RESP_TX_STATUS_EVENTID , +WMI_MGMT_TX_COMPLETION_EVENTID , +WMI_MGMT_TX_BUNDLE_COMPLETION_EVENTID , +WMI_TBTTOFFSET_EXT_UPDATE_EVENTID , +WMI_TX_DELBA_COMPLETE_EVENTID =WMI_TLV_CMD (WMI_GRP_BA_NEG ), +WMI_TX_ADDBA_COMPLETE_EVENTID , +WMI_BA_RSP_SSN_EVENTID , +WMI_AGGR_STATE_TRIG_EVENTID , +WMI_ROAM_EVENTID =WMI_TLV_CMD (WMI_GRP_ROAM ), +WMI_PROFILE_MATCH , +WMI_ROAM_SYNCH_EVENTID , +WMI_P2P_DISC_EVENTID =WMI_TLV_CMD (WMI_GRP_P2P ), +WMI_P2P_NOA_EVENTID , +WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID , +WMI_AP_PS_EGAP_INFO_EVENTID =WMI_TLV_CMD (WMI_GRP_AP_PS ), +WMI_PDEV_RESUME_EVENTID =WMI_TLV_CMD (WMI_GRP_SUSPEND ), +WMI_WOW_WAKEUP_HOST_EVENTID =WMI_TLV_CMD (WMI_GRP_WOW ), +WMI_D0_WOW_DISABLE_ACK_EVENTID , +WMI_WOW_INITIAL_WAKEUP_EVENTID , +WMI_RTT_MEASUREMENT_REPORT_EVENTID =WMI_TLV_CMD (WMI_GRP_RTT ), +WMI_TSF_MEASUREMENT_REPORT_EVENTID , +WMI_RTT_ERROR_REPORT_EVENTID , +WMI_STATS_EXT_EVENTID =WMI_TLV_CMD (WMI_GRP_STATS ), +WMI_IFACE_LINK_STATS_EVENTID , +WMI_PEER_LINK_STATS_EVENTID , +WMI_RADIO_LINK_STATS_EVENTID , +WMI_UPDATE_FW_MEM_DUMP_EVENTID , +WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID , +WMI_INST_RSSI_STATS_EVENTID , +WMI_RADIO_TX_POWER_LEVEL_STATS_EVENTID , +WMI_REPORT_STATS_EVENTID , +WMI_UPDATE_RCPI_EVENTID , +WMI_PEER_STATS_INFO_EVENTID , +WMI_RADIO_CHAN_STATS_EVENTID , +WMI_NLO_MATCH_EVENTID =WMI_TLV_CMD (WMI_GRP_NLO_OFL ), +WMI_NLO_SCAN_COMPLETE_EVENTID , +WMI_APFIND_EVENTID , +WMI_PASSPOINT_MATCH_EVENTID , +WMI_GTK_OFFLOAD_STATUS_EVENTID =WMI_TLV_CMD (WMI_GRP_GTK_OFL ), +WMI_GTK_REKEY_FAIL_EVENTID , +WMI_CSA_HANDLING_EVENTID =WMI_TLV_CMD (WMI_GRP_CSA_OFL ), +WMI_CHATTER_PC_QUERY_EVENTID =WMI_TLV_CMD (WMI_GRP_CHATTER ), +WMI_PDEV_DFS_RADAR_DETECTION_EVENTID =WMI_TLV_CMD (WMI_GRP_DFS ), +WMI_VDEV_DFS_CAC_COMPLETE_EVENTID , +WMI_VDEV_ADFS_OCAC_COMPLETE_EVENTID , +WMI_ECHO_EVENTID =WMI_TLV_CMD (WMI_GRP_MISC ), +WMI_PDEV_UTF_EVENTID , +WMI_DEBUG_MESG_EVENTID , +WMI_UPDATE_STATS_EVENTID , +WMI_DEBUG_PRINT_EVENTID , +WMI_DCS_INTERFERENCE_EVENTID , +WMI_PDEV_QVIT_EVENTID , +WMI_WLAN_PROFILE_DATA_EVENTID , +WMI_PDEV_FTM_INTG_EVENTID , +WMI_WLAN_FREQ_AVOID_EVENTID , +WMI_VDEV_GET_KEEPALIVE_EVENTID , +WMI_THERMAL_MGMT_EVENTID , +WMI_DIAG_DATA_CONTAINER_EVENTID , +WMI_HOST_AUTO_SHUTDOWN_EVENTID , +WMI_UPDATE_WHAL_MIB_STATS_EVENTID , +WMI_UPDATE_VDEV_RATE_STATS_EVENTID , +WMI_DIAG_EVENTID , +WMI_OCB_SET_SCHED_EVENTID , +WMI_DEBUG_MESG_FLUSH_COMPLETE_EVENTID , +WMI_RSSI_BREACH_EVENTID , +WMI_TRANSFER_DATA_TO_FLASH_COMPLETE_EVENTID , +WMI_PDEV_UTF_SCPC_EVENTID , +WMI_READ_DATA_FROM_FLASH_EVENTID , +WMI_REPORT_RX_AGGR_FAILURE_EVENTID , +WMI_PKGID_EVENTID , +WMI_GPIO_INPUT_EVENTID =WMI_TLV_CMD (WMI_GRP_GPIO ), +WMI_UPLOADH_EVENTID , +WMI_CAPTUREH_EVENTID , +WMI_RFKILL_STATE_CHANGE_EVENTID , +WMI_TDLS_PEER_EVENTID =WMI_TLV_CMD (WMI_GRP_TDLS ), +WMI_STA_SMPS_FORCE_MODE_COMPL_EVENTID =WMI_TLV_CMD (WMI_GRP_STA_SMPS ), +WMI_BATCH_SCAN_ENABLED_EVENTID =WMI_TLV_CMD (WMI_GRP_LOCATION_SCAN ), +WMI_BATCH_SCAN_RESULT_EVENTID , +WMI_OEM_CAPABILITY_EVENTID =WMI_TLV_CMD (WMI_GRP_OEM ), +WMI_OEM_MEASUREMENT_REPORT_EVENTID , +WMI_OEM_ERROR_REPORT_EVENTID , +WMI_OEM_RESPONSE_EVENTID , +WMI_NAN_EVENTID =WMI_TLV_CMD (WMI_GRP_NAN ), +WMI_NAN_DISC_IFACE_CREATED_EVENTID , +WMI_NAN_DISC_IFACE_DELETED_EVENTID , +WMI_NAN_STARTED_CLUSTER_EVENTID , +WMI_NAN_JOINED_CLUSTER_EVENTID , +WMI_COEX_REPORT_ANTENNA_ISOLATION_EVENTID =WMI_TLV_CMD (WMI_GRP_COEX ), +WMI_LPI_RESULT_EVENTID =WMI_TLV_CMD (WMI_GRP_LPI ), +WMI_LPI_STATUS_EVENTID , +WMI_LPI_HANDOFF_EVENTID , +WMI_EXTSCAN_START_STOP_EVENTID =WMI_TLV_CMD (WMI_GRP_EXTSCAN ), +WMI_EXTSCAN_OPERATION_EVENTID , +WMI_EXTSCAN_TABLE_USAGE_EVENTID , +WMI_EXTSCAN_CACHED_RESULTS_EVENTID , +WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID , +WMI_EXTSCAN_HOTLIST_MATCH_EVENTID , +WMI_EXTSCAN_CAPABILITIES_EVENTID , +WMI_EXTSCAN_HOTLIST_SSID_MATCH_EVENTID , +WMI_MDNS_STATS_EVENTID =WMI_TLV_CMD (WMI_GRP_MDNS_OFL ), +WMI_SAP_OFL_ADD_STA_EVENTID =WMI_TLV_CMD (WMI_GRP_SAP_OFL ), +WMI_SAP_OFL_DEL_STA_EVENTID , +WMI_OCB_SET_CONFIG_RESP_EVENTID =WMI_TLV_CMD (WMI_GRP_OCB ), +WMI_OCB_GET_TSF_TIMER_RESP_EVENTID , +WMI_DCC_GET_STATS_RESP_EVENTID , +WMI_DCC_UPDATE_NDL_RESP_EVENTID , +WMI_DCC_STATS_EVENTID , +WMI_SOC_SET_HW_MODE_RESP_EVENTID =WMI_TLV_CMD (WMI_GRP_SOC ), +WMI_SOC_HW_MODE_TRANSITION_EVENTID , +WMI_SOC_SET_DUAL_MAC_CONFIG_RESP_EVENTID , +WMI_MAWC_ENABLE_SENSOR_EVENTID =WMI_TLV_CMD (WMI_GRP_MAWC ), +WMI_BPF_CAPABILIY_INFO_EVENTID =WMI_TLV_CMD (WMI_GRP_BPF_OFFLOAD ), +WMI_BPF_VDEV_STATS_INFO_EVENTID , +WMI_RMC_NEW_LEADER_EVENTID =WMI_TLV_CMD (WMI_GRP_RMC ), +WMI_REG_CHAN_LIST_CC_EVENTID =WMI_TLV_CMD (WMI_GRP_REGULATORY ), +WMI_11D_NEW_COUNTRY_EVENTID , +WMI_NDI_CAP_RSP_EVENTID =WMI_TLV_CMD (WMI_GRP_PROTOTYPE ), +WMI_NDP_INITIATOR_RSP_EVENTID , +WMI_NDP_RESPONDER_RSP_EVENTID , +WMI_NDP_END_RSP_EVENTID , +WMI_NDP_INDICATION_EVENTID , +WMI_NDP_CONFIRM_EVENTID , +WMI_NDP_END_INDICATION_EVENTID , +}; + +enum wmi_tlv_pdev_param { +WMI_PDEV_PARAM_TX_CHAIN_MASK =0x1 , +WMI_PDEV_PARAM_RX_CHAIN_MASK , +WMI_PDEV_PARAM_TXPOWER_LIMIT2G , +WMI_PDEV_PARAM_TXPOWER_LIMIT5G , +WMI_PDEV_PARAM_TXPOWER_SCALE , +WMI_PDEV_PARAM_BEACON_GEN_MODE , +WMI_PDEV_PARAM_BEACON_TX_MODE , +WMI_PDEV_PARAM_RESMGR_OFFCHAN_MODE , +WMI_PDEV_PARAM_PROTECTION_MODE , +WMI_PDEV_PARAM_DYNAMIC_BW , +WMI_PDEV_PARAM_NON_AGG_SW_RETRY_TH , +WMI_PDEV_PARAM_AGG_SW_RETRY_TH , +WMI_PDEV_PARAM_STA_KICKOUT_TH , +WMI_PDEV_PARAM_AC_AGGRSIZE_SCALING , +WMI_PDEV_PARAM_LTR_ENABLE , +WMI_PDEV_PARAM_LTR_AC_LATENCY_BE , +WMI_PDEV_PARAM_LTR_AC_LATENCY_BK , +WMI_PDEV_PARAM_LTR_AC_LATENCY_VI , +WMI_PDEV_PARAM_LTR_AC_LATENCY_VO , +WMI_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT , +WMI_PDEV_PARAM_LTR_SLEEP_OVERRIDE , +WMI_PDEV_PARAM_LTR_RX_OVERRIDE , +WMI_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT , +WMI_PDEV_PARAM_L1SS_ENABLE , +WMI_PDEV_PARAM_DSLEEP_ENABLE , +WMI_PDEV_PARAM_PCIELP_TXBUF_FLUSH , +WMI_PDEV_PARAM_PCIELP_TXBUF_WATERMARK , +WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_EN , +WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_VALUE , +WMI_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD , +WMI_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD , +WMI_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD , +WMI_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD , +WMI_PDEV_PARAM_PMF_QOS , +WMI_PDEV_PARAM_ARP_AC_OVERRIDE , +WMI_PDEV_PARAM_DCS , +WMI_PDEV_PARAM_ANI_ENABLE , +WMI_PDEV_PARAM_ANI_POLL_PERIOD , +WMI_PDEV_PARAM_ANI_LISTEN_PERIOD , +WMI_PDEV_PARAM_ANI_OFDM_LEVEL , +WMI_PDEV_PARAM_ANI_CCK_LEVEL , +WMI_PDEV_PARAM_DYNTXCHAIN , +WMI_PDEV_PARAM_PROXY_STA , +WMI_PDEV_PARAM_IDLE_PS_CONFIG , +WMI_PDEV_PARAM_POWER_GATING_SLEEP , +WMI_PDEV_PARAM_RFKILL_ENABLE , +WMI_PDEV_PARAM_BURST_DUR , +WMI_PDEV_PARAM_BURST_ENABLE , +WMI_PDEV_PARAM_HW_RFKILL_CONFIG , +WMI_PDEV_PARAM_LOW_POWER_RF_ENABLE , +WMI_PDEV_PARAM_L1SS_TRACK , +WMI_PDEV_PARAM_HYST_EN , +WMI_PDEV_PARAM_POWER_COLLAPSE_ENABLE , +WMI_PDEV_PARAM_LED_SYS_STATE , +WMI_PDEV_PARAM_LED_ENABLE , +WMI_PDEV_PARAM_AUDIO_OVER_WLAN_LATENCY , +WMI_PDEV_PARAM_AUDIO_OVER_WLAN_ENABLE , +WMI_PDEV_PARAM_WHAL_MIB_STATS_UPDATE_ENABLE , +WMI_PDEV_PARAM_VDEV_RATE_STATS_UPDATE_PERIOD , +WMI_PDEV_PARAM_CTS_CBW , +WMI_PDEV_PARAM_WNTS_CONFIG , +WMI_PDEV_PARAM_ADAPTIVE_EARLY_RX_ENABLE , +WMI_PDEV_PARAM_ADAPTIVE_EARLY_RX_MIN_SLEEP_SLOP , +WMI_PDEV_PARAM_ADAPTIVE_EARLY_RX_INC_DEC_STEP , +WMI_PDEV_PARAM_EARLY_RX_FIX_SLEEP_SLOP , +WMI_PDEV_PARAM_BMISS_BASED_ADAPTIVE_BTO_ENABLE , +WMI_PDEV_PARAM_BMISS_BTO_MIN_BCN_TIMEOUT , +WMI_PDEV_PARAM_BMISS_BTO_INC_DEC_STEP , +WMI_PDEV_PARAM_BTO_FIX_BCN_TIMEOUT , +WMI_PDEV_PARAM_CE_BASED_ADAPTIVE_BTO_ENABLE , +WMI_PDEV_PARAM_CE_BTO_COMBO_CE_VALUE , +WMI_PDEV_PARAM_TX_CHAIN_MASK_2G , +WMI_PDEV_PARAM_RX_CHAIN_MASK_2G , +WMI_PDEV_PARAM_TX_CHAIN_MASK_5G , +WMI_PDEV_PARAM_RX_CHAIN_MASK_5G , +WMI_PDEV_PARAM_TX_CHAIN_MASK_CCK , +WMI_PDEV_PARAM_TX_CHAIN_MASK_1SS , +WMI_PDEV_PARAM_CTS2SELF_FOR_P2P_GO_CONFIG , +WMI_PDEV_PARAM_TXPOWER_DECR_DB , +WMI_PDEV_PARAM_AGGR_BURST , +WMI_PDEV_PARAM_RX_DECAP_MODE , +WMI_PDEV_PARAM_FAST_CHANNEL_RESET , +WMI_PDEV_PARAM_SMART_ANTENNA_DEFAULT_ANTENNA , +WMI_PDEV_PARAM_ANTENNA_GAIN , +WMI_PDEV_PARAM_RX_FILTER , +WMI_PDEV_SET_MCAST_TO_UCAST_TID , +WMI_PDEV_PARAM_PROXY_STA_MODE , +WMI_PDEV_PARAM_SET_MCAST2UCAST_MODE , +WMI_PDEV_PARAM_SET_MCAST2UCAST_BUFFER , +WMI_PDEV_PARAM_REMOVE_MCAST2UCAST_BUFFER , +WMI_PDEV_PEER_STA_PS_STATECHG_ENABLE , +WMI_PDEV_PARAM_IGMPMLD_AC_OVERRIDE , +WMI_PDEV_PARAM_BLOCK_INTERBSS , +WMI_PDEV_PARAM_SET_DISABLE_RESET_CMDID , +WMI_PDEV_PARAM_SET_MSDU_TTL_CMDID , +WMI_PDEV_PARAM_SET_PPDU_DURATION_CMDID , +WMI_PDEV_PARAM_TXBF_SOUND_PERIOD_CMDID , +WMI_PDEV_PARAM_SET_PROMISC_MODE_CMDID , +WMI_PDEV_PARAM_SET_BURST_MODE_CMDID , +WMI_PDEV_PARAM_EN_STATS , +WMI_PDEV_PARAM_MU_GROUP_POLICY , +WMI_PDEV_PARAM_NOISE_DETECTION , +WMI_PDEV_PARAM_NOISE_THRESHOLD , +WMI_PDEV_PARAM_DPD_ENABLE , +WMI_PDEV_PARAM_SET_MCAST_BCAST_ECHO , +WMI_PDEV_PARAM_ATF_STRICT_SCH , +WMI_PDEV_PARAM_ATF_SCHED_DURATION , +WMI_PDEV_PARAM_ANT_PLZN , +WMI_PDEV_PARAM_MGMT_RETRY_LIMIT , +WMI_PDEV_PARAM_SENSITIVITY_LEVEL , +WMI_PDEV_PARAM_SIGNED_TXPOWER_2G , +WMI_PDEV_PARAM_SIGNED_TXPOWER_5G , +WMI_PDEV_PARAM_ENABLE_PER_TID_AMSDU , +WMI_PDEV_PARAM_ENABLE_PER_TID_AMPDU , +WMI_PDEV_PARAM_CCA_THRESHOLD , +WMI_PDEV_PARAM_RTS_FIXED_RATE , +WMI_PDEV_PARAM_PDEV_RESET , +WMI_PDEV_PARAM_WAPI_MBSSID_OFFSET , +WMI_PDEV_PARAM_ARP_DBG_SRCADDR , +WMI_PDEV_PARAM_ARP_DBG_DSTADDR , +WMI_PDEV_PARAM_ATF_OBSS_NOISE_SCH , +WMI_PDEV_PARAM_ATF_OBSS_NOISE_SCALING_FACTOR , +WMI_PDEV_PARAM_CUST_TXPOWER_SCALE , +WMI_PDEV_PARAM_ATF_DYNAMIC_ENABLE , +WMI_PDEV_PARAM_CTRL_RETRY_LIMIT , +WMI_PDEV_PARAM_PROPAGATION_DELAY , +WMI_PDEV_PARAM_ENA_ANT_DIV , +WMI_PDEV_PARAM_FORCE_CHAIN_ANT , +WMI_PDEV_PARAM_ANT_DIV_SELFTEST , +WMI_PDEV_PARAM_ANT_DIV_SELFTEST_INTVL , +WMI_PDEV_PARAM_STATS_OBSERVATION_PERIOD , +WMI_PDEV_PARAM_TX_PPDU_DELAY_BIN_SIZE_MS , +WMI_PDEV_PARAM_TX_PPDU_DELAY_ARRAY_LEN , +WMI_PDEV_PARAM_TX_MPDU_AGGR_ARRAY_LEN , +WMI_PDEV_PARAM_RX_MPDU_AGGR_ARRAY_LEN , +WMI_PDEV_PARAM_TX_SCH_DELAY , +WMI_PDEV_PARAM_ENABLE_RTS_SIFS_BURSTING , +WMI_PDEV_PARAM_MAX_MPDUS_IN_AMPDU , +WMI_PDEV_PARAM_PEER_STATS_INFO_ENABLE , +WMI_PDEV_PARAM_FAST_PWR_TRANSITION , +WMI_PDEV_PARAM_RADIO_CHAN_STATS_ENABLE , +WMI_PDEV_PARAM_RADIO_DIAGNOSIS_ENABLE , +WMI_PDEV_PARAM_MESH_MCAST_ENABLE , +}; + +enum wmi_tlv_vdev_param { +WMI_VDEV_PARAM_RTS_THRESHOLD =0x1 , +WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD , +WMI_VDEV_PARAM_BEACON_INTERVAL , +WMI_VDEV_PARAM_LISTEN_INTERVAL , +WMI_VDEV_PARAM_MULTICAST_RATE , +WMI_VDEV_PARAM_MGMT_TX_RATE , +WMI_VDEV_PARAM_SLOT_TIME , +WMI_VDEV_PARAM_PREAMBLE , +WMI_VDEV_PARAM_SWBA_TIME , +WMI_VDEV_STATS_UPDATE_PERIOD , +WMI_VDEV_PWRSAVE_AGEOUT_TIME , +WMI_VDEV_HOST_SWBA_INTERVAL , +WMI_VDEV_PARAM_DTIM_PERIOD , +WMI_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT , +WMI_VDEV_PARAM_WDS , +WMI_VDEV_PARAM_ATIM_WINDOW , +WMI_VDEV_PARAM_BMISS_COUNT_MAX , +WMI_VDEV_PARAM_BMISS_FIRST_BCNT , +WMI_VDEV_PARAM_BMISS_FINAL_BCNT , +WMI_VDEV_PARAM_FEATURE_WMM , +WMI_VDEV_PARAM_CHWIDTH , +WMI_VDEV_PARAM_CHEXTOFFSET , +WMI_VDEV_PARAM_DISABLE_HTPROTECTION , +WMI_VDEV_PARAM_STA_QUICKKICKOUT , +WMI_VDEV_PARAM_MGMT_RATE , +WMI_VDEV_PARAM_PROTECTION_MODE , +WMI_VDEV_PARAM_FIXED_RATE , +WMI_VDEV_PARAM_SGI , +WMI_VDEV_PARAM_LDPC , +WMI_VDEV_PARAM_TX_STBC , +WMI_VDEV_PARAM_RX_STBC , +WMI_VDEV_PARAM_INTRA_BSS_FWD , +WMI_VDEV_PARAM_DEF_KEYID , +WMI_VDEV_PARAM_NSS , +WMI_VDEV_PARAM_BCAST_DATA_RATE , +WMI_VDEV_PARAM_MCAST_DATA_RATE , +WMI_VDEV_PARAM_MCAST_INDICATE , +WMI_VDEV_PARAM_DHCP_INDICATE , +WMI_VDEV_PARAM_UNKNOWN_DEST_INDICATE , +WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS , +WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS , +WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS , +WMI_VDEV_PARAM_AP_ENABLE_NAWDS , +WMI_VDEV_PARAM_ENABLE_RTSCTS , +WMI_VDEV_PARAM_TXBF , +WMI_VDEV_PARAM_PACKET_POWERSAVE , +WMI_VDEV_PARAM_DROP_UNENCRY , +WMI_VDEV_PARAM_TX_ENCAP_TYPE , +WMI_VDEV_PARAM_AP_DETECT_OUT_OF_SYNC_SLEEPING_STA_TIME_SECS , +WMI_VDEV_PARAM_EARLY_RX_ADJUST_ENABLE , +WMI_VDEV_PARAM_EARLY_RX_TGT_BMISS_NUM , +WMI_VDEV_PARAM_EARLY_RX_BMISS_SAMPLE_CYCLE , +WMI_VDEV_PARAM_EARLY_RX_SLOP_STEP , +WMI_VDEV_PARAM_EARLY_RX_INIT_SLOP , +WMI_VDEV_PARAM_EARLY_RX_ADJUST_PAUSE , +WMI_VDEV_PARAM_TX_PWRLIMIT , +WMI_VDEV_PARAM_SNR_NUM_FOR_CAL , +WMI_VDEV_PARAM_ROAM_FW_OFFLOAD , +WMI_VDEV_PARAM_ENABLE_RMC , +WMI_VDEV_PARAM_IBSS_MAX_BCN_LOST_MS , +WMI_VDEV_PARAM_MAX_RATE , +WMI_VDEV_PARAM_EARLY_RX_DRIFT_SAMPLE , +WMI_VDEV_PARAM_SET_IBSS_TX_FAIL_CNT_THR , +WMI_VDEV_PARAM_EBT_RESYNC_TIMEOUT , +WMI_VDEV_PARAM_AGGR_TRIG_EVENT_ENABLE , +WMI_VDEV_PARAM_IS_IBSS_POWER_SAVE_ALLOWED , +WMI_VDEV_PARAM_IS_POWER_COLLAPSE_ALLOWED , +WMI_VDEV_PARAM_IS_AWAKE_ON_TXRX_ENABLED , +WMI_VDEV_PARAM_INACTIVITY_CNT , +WMI_VDEV_PARAM_TXSP_END_INACTIVITY_TIME_MS , +WMI_VDEV_PARAM_DTIM_POLICY , +WMI_VDEV_PARAM_IBSS_PS_WARMUP_TIME_SECS , +WMI_VDEV_PARAM_IBSS_PS_1RX_CHAIN_IN_ATIM_WINDOW_ENABLE , +WMI_VDEV_PARAM_RX_LEAK_WINDOW , +WMI_VDEV_PARAM_STATS_AVG_FACTOR , +WMI_VDEV_PARAM_DISCONNECT_TH , +WMI_VDEV_PARAM_RTSCTS_RATE , +WMI_VDEV_PARAM_MCC_RTSCTS_PROTECTION_ENABLE , +WMI_VDEV_PARAM_MCC_BROADCAST_PROBE_ENABLE , +WMI_VDEV_PARAM_TXPOWER_SCALE , +WMI_VDEV_PARAM_TXPOWER_SCALE_DECR_DB , +WMI_VDEV_PARAM_MCAST2UCAST_SET , +WMI_VDEV_PARAM_RC_NUM_RETRIES , +WMI_VDEV_PARAM_CABQ_MAXDUR , +WMI_VDEV_PARAM_MFPTEST_SET , +WMI_VDEV_PARAM_RTS_FIXED_RATE , +WMI_VDEV_PARAM_VHT_SGIMASK , +WMI_VDEV_PARAM_VHT80_RATEMASK , +WMI_VDEV_PARAM_PROXY_STA , +WMI_VDEV_PARAM_VIRTUAL_CELL_MODE , +WMI_VDEV_PARAM_RX_DECAP_TYPE , +WMI_VDEV_PARAM_BW_NSS_RATEMASK , +WMI_VDEV_PARAM_SENSOR_AP , +WMI_VDEV_PARAM_BEACON_RATE , +WMI_VDEV_PARAM_DTIM_ENABLE_CTS , +WMI_VDEV_PARAM_STA_KICKOUT , +WMI_VDEV_PARAM_CAPABILITIES , +WMI_VDEV_PARAM_TSF_INCREMENT , +WMI_VDEV_PARAM_AMPDU_PER_AC , +WMI_VDEV_PARAM_RX_FILTER , +WMI_VDEV_PARAM_MGMT_TX_POWER , +WMI_VDEV_PARAM_NON_AGG_SW_RETRY_TH , +WMI_VDEV_PARAM_AGG_SW_RETRY_TH , +WMI_VDEV_PARAM_DISABLE_DYN_BW_RTS , +WMI_VDEV_PARAM_ATF_SSID_SCHED_POLICY , +WMI_VDEV_PARAM_HE_DCM , +WMI_VDEV_PARAM_HE_RANGE_EXT , +WMI_VDEV_PARAM_ENABLE_BCAST_PROBE_RESPONSE , +WMI_VDEV_PARAM_FILS_MAX_CHANNEL_GUARD_TIME , +WMI_VDEV_PARAM_SET_HE_SOUNDING_MODE =0x87 , +WMI_VDEV_PARAM_PROTOTYPE =0x8000 , +WMI_VDEV_PARAM_BSS_COLOR , +WMI_VDEV_PARAM_SET_HEMU_MODE , +WMI_VDEV_PARAM_TX_OFDMA_CPLEN , +}; + +enum wmi_tlv_peer_flags { +WMI_TLV_PEER_AUTH =0x00000001 , +WMI_TLV_PEER_QOS =0x00000002 , +WMI_TLV_PEER_NEED_PTK_4_WAY =0x00000004 , +WMI_TLV_PEER_NEED_GTK_2_WAY =0x00000010 , +WMI_TLV_PEER_APSD =0x00000800 , +WMI_TLV_PEER_HT =0x00001000 , +WMI_TLV_PEER_40MHZ =0x00002000 , +WMI_TLV_PEER_STBC =0x00008000 , +WMI_TLV_PEER_LDPC =0x00010000 , +WMI_TLV_PEER_DYN_MIMOPS =0x00020000 , +WMI_TLV_PEER_STATIC_MIMOPS =0x00040000 , +WMI_TLV_PEER_SPATIAL_MUX =0x00200000 , +WMI_TLV_PEER_VHT =0x02000000 , +WMI_TLV_PEER_80MHZ =0x04000000 , +WMI_TLV_PEER_PMF =0x08000000 , +WMI_PEER_IS_P2P_CAPABLE =0x20000000 , +WMI_PEER_160MHZ =0x40000000 , +WMI_PEER_SAFEMODE_EN =0x80000000 , + +}; + +/** Enum list of TLV Tags for each parameter structure type. */ +enum wmi_tlv_tag { +WMI_TAG_LAST_RESERVED =15 , +WMI_TAG_FIRST_ARRAY_ENUM , +WMI_TAG_ARRAY_UINT32 =WMI_TAG_FIRST_ARRAY_ENUM , +WMI_TAG_ARRAY_BYTE , +WMI_TAG_ARRAY_STRUCT , +WMI_TAG_ARRAY_FIXED_STRUCT , +WMI_TAG_LAST_ARRAY_ENUM =31 , +WMI_TAG_SERVICE_READY_EVENT , +WMI_TAG_HAL_REG_CAPABILITIES , +WMI_TAG_WLAN_HOST_MEM_REQ , +WMI_TAG_READY_EVENT , +WMI_TAG_SCAN_EVENT , +WMI_TAG_PDEV_TPC_CONFIG_EVENT , +WMI_TAG_CHAN_INFO_EVENT , +WMI_TAG_COMB_PHYERR_RX_HDR , +WMI_TAG_VDEV_START_RESPONSE_EVENT , +WMI_TAG_VDEV_STOPPED_EVENT , +WMI_TAG_VDEV_INSTALL_KEY_COMPLETE_EVENT , +WMI_TAG_PEER_STA_KICKOUT_EVENT , +WMI_TAG_MGMT_RX_HDR , +WMI_TAG_TBTT_OFFSET_EVENT , +WMI_TAG_TX_DELBA_COMPLETE_EVENT , +WMI_TAG_TX_ADDBA_COMPLETE_EVENT , +WMI_TAG_ROAM_EVENT , +WMI_TAG_WOW_EVENT_INFO , +WMI_TAG_WOW_EVENT_INFO_SECTION_BITMAP , +WMI_TAG_RTT_EVENT_HEADER , +WMI_TAG_RTT_ERROR_REPORT_EVENT , +WMI_TAG_RTT_MEAS_EVENT , +WMI_TAG_ECHO_EVENT , +WMI_TAG_FTM_INTG_EVENT , +WMI_TAG_VDEV_GET_KEEPALIVE_EVENT , +WMI_TAG_GPIO_INPUT_EVENT , +WMI_TAG_CSA_EVENT , +WMI_TAG_GTK_OFFLOAD_STATUS_EVENT , +WMI_TAG_IGTK_INFO , +WMI_TAG_DCS_INTERFERENCE_EVENT , +WMI_TAG_ATH_DCS_CW_INT , +WMI_TAG_WLAN_DCS_CW_INT =/* ALIAS */ +WMI_TAG_ATH_DCS_CW_INT , +WMI_TAG_ATH_DCS_WLAN_INT_STAT , +WMI_TAG_WLAN_DCS_IM_TGT_STATS_T =/* ALIAS */ +WMI_TAG_ATH_DCS_WLAN_INT_STAT , +WMI_TAG_WLAN_PROFILE_CTX_T , +WMI_TAG_WLAN_PROFILE_T , +WMI_TAG_PDEV_QVIT_EVENT , +WMI_TAG_HOST_SWBA_EVENT , +WMI_TAG_TIM_INFO , +WMI_TAG_P2P_NOA_INFO , +WMI_TAG_STATS_EVENT , +WMI_TAG_AVOID_FREQ_RANGES_EVENT , +WMI_TAG_AVOID_FREQ_RANGE_DESC , +WMI_TAG_GTK_REKEY_FAIL_EVENT , +WMI_TAG_INIT_CMD , +WMI_TAG_RESOURCE_CONFIG , +WMI_TAG_WLAN_HOST_MEMORY_CHUNK , +WMI_TAG_START_SCAN_CMD , +WMI_TAG_STOP_SCAN_CMD , +WMI_TAG_SCAN_CHAN_LIST_CMD , +WMI_TAG_CHANNEL , +WMI_TAG_PDEV_SET_REGDOMAIN_CMD , +WMI_TAG_PDEV_SET_PARAM_CMD , +WMI_TAG_PDEV_SET_WMM_PARAMS_CMD , +WMI_TAG_WMM_PARAMS , +WMI_TAG_PDEV_SET_QUIET_CMD , +WMI_TAG_VDEV_CREATE_CMD , +WMI_TAG_VDEV_DELETE_CMD , +WMI_TAG_VDEV_START_REQUEST_CMD , +WMI_TAG_P2P_NOA_DESCRIPTOR , +WMI_TAG_P2P_GO_SET_BEACON_IE , +WMI_TAG_GTK_OFFLOAD_CMD , +WMI_TAG_VDEV_UP_CMD , +WMI_TAG_VDEV_STOP_CMD , +WMI_TAG_VDEV_DOWN_CMD , +WMI_TAG_VDEV_SET_PARAM_CMD , +WMI_TAG_VDEV_INSTALL_KEY_CMD , +WMI_TAG_PEER_CREATE_CMD , +WMI_TAG_PEER_DELETE_CMD , +WMI_TAG_PEER_FLUSH_TIDS_CMD , +WMI_TAG_PEER_SET_PARAM_CMD , +WMI_TAG_PEER_ASSOC_COMPLETE_CMD , +WMI_TAG_VHT_RATE_SET , +WMI_TAG_BCN_TMPL_CMD , +WMI_TAG_PRB_TMPL_CMD , +WMI_TAG_BCN_PRB_INFO , +WMI_TAG_PEER_TID_ADDBA_CMD , +WMI_TAG_PEER_TID_DELBA_CMD , +WMI_TAG_STA_POWERSAVE_MODE_CMD , +WMI_TAG_STA_POWERSAVE_PARAM_CMD , +WMI_TAG_STA_DTIM_PS_METHOD_CMD , +WMI_TAG_ROAM_SCAN_MODE , +WMI_TAG_ROAM_SCAN_RSSI_THRESHOLD , +WMI_TAG_ROAM_SCAN_PERIOD , +WMI_TAG_ROAM_SCAN_RSSI_CHANGE_THRESHOLD , +WMI_TAG_PDEV_SUSPEND_CMD , +WMI_TAG_PDEV_RESUME_CMD , +WMI_TAG_ADD_BCN_FILTER_CMD , +WMI_TAG_RMV_BCN_FILTER_CMD , +WMI_TAG_WOW_ENABLE_CMD , +WMI_TAG_WOW_HOSTWAKEUP_FROM_SLEEP_CMD , +WMI_TAG_STA_UAPSD_AUTO_TRIG_CMD , +WMI_TAG_STA_UAPSD_AUTO_TRIG_PARAM , +WMI_TAG_SET_ARP_NS_OFFLOAD_CMD , +WMI_TAG_ARP_OFFLOAD_TUPLE , +WMI_TAG_NS_OFFLOAD_TUPLE , +WMI_TAG_FTM_INTG_CMD , +WMI_TAG_STA_KEEPALIVE_CMD , +WMI_TAG_STA_KEEPALVE_ARP_RESPONSE , +WMI_TAG_P2P_SET_VENDOR_IE_DATA_CMD , +WMI_TAG_AP_PS_PEER_CMD , +WMI_TAG_PEER_RATE_RETRY_SCHED_CMD , +WMI_TAG_WLAN_PROFILE_TRIGGER_CMD , +WMI_TAG_WLAN_PROFILE_SET_HIST_INTVL_CMD , +WMI_TAG_WLAN_PROFILE_GET_PROF_DATA_CMD , +WMI_TAG_WLAN_PROFILE_ENABLE_PROFILE_ID_CMD , +WMI_TAG_WOW_DEL_PATTERN_CMD , +WMI_TAG_WOW_ADD_DEL_EVT_CMD , +WMI_TAG_RTT_MEASREQ_HEAD , +WMI_TAG_RTT_MEASREQ_BODY , +WMI_TAG_RTT_TSF_CMD , +WMI_TAG_VDEV_SPECTRAL_CONFIGURE_CMD , +WMI_TAG_VDEV_SPECTRAL_ENABLE_CMD , +WMI_TAG_REQUEST_STATS_CMD , +WMI_TAG_NLO_CONFIG_CMD , +WMI_TAG_NLO_CONFIGURED_PARAMETERS , +WMI_TAG_CSA_OFFLOAD_ENABLE_CMD , +WMI_TAG_CSA_OFFLOAD_CHANSWITCH_CMD , +WMI_TAG_CHATTER_SET_MODE_CMD , +WMI_TAG_ECHO_CMD , +WMI_TAG_VDEV_SET_KEEPALIVE_CMD , +WMI_TAG_VDEV_GET_KEEPALIVE_CMD , +WMI_TAG_FORCE_FW_HANG_CMD , +WMI_TAG_GPIO_CONFIG_CMD , +WMI_TAG_GPIO_OUTPUT_CMD , +WMI_TAG_PEER_ADD_WDS_ENTRY_CMD , +WMI_TAG_PEER_REMOVE_WDS_ENTRY_CMD , +WMI_TAG_BCN_TX_HDR , +WMI_TAG_BCN_SEND_FROM_HOST_CMD , +WMI_TAG_MGMT_TX_HDR , +WMI_TAG_ADDBA_CLEAR_RESP_CMD , +WMI_TAG_ADDBA_SEND_CMD , +WMI_TAG_DELBA_SEND_CMD , +WMI_TAG_ADDBA_SETRESPONSE_CMD , +WMI_TAG_SEND_SINGLEAMSDU_CMD , +WMI_TAG_PDEV_PKTLOG_ENABLE_CMD , +WMI_TAG_PDEV_PKTLOG_DISABLE_CMD , +WMI_TAG_PDEV_SET_HT_IE_CMD , +WMI_TAG_PDEV_SET_VHT_IE_CMD , +WMI_TAG_PDEV_SET_DSCP_TID_MAP_CMD , +WMI_TAG_PDEV_GREEN_AP_PS_ENABLE_CMD , +WMI_TAG_PDEV_GET_TPC_CONFIG_CMD , +WMI_TAG_PDEV_SET_BASE_MACADDR_CMD , +WMI_TAG_PEER_MCAST_GROUP_CMD , +WMI_TAG_ROAM_AP_PROFILE , +WMI_TAG_AP_PROFILE , +WMI_TAG_SCAN_SCH_PRIORITY_TABLE_CMD , +WMI_TAG_PDEV_DFS_ENABLE_CMD , +WMI_TAG_PDEV_DFS_DISABLE_CMD , +WMI_TAG_WOW_ADD_PATTERN_CMD , +WMI_TAG_WOW_BITMAP_PATTERN_T , +WMI_TAG_WOW_IPV4_SYNC_PATTERN_T , +WMI_TAG_WOW_IPV6_SYNC_PATTERN_T , +WMI_TAG_WOW_MAGIC_PATTERN_CMD , +WMI_TAG_SCAN_UPDATE_REQUEST_CMD , +WMI_TAG_CHATTER_PKT_COALESCING_FILTER , +WMI_TAG_CHATTER_COALESCING_ADD_FILTER_CMD , +WMI_TAG_CHATTER_COALESCING_DELETE_FILTER_CMD , +WMI_TAG_CHATTER_COALESCING_QUERY_CMD , +WMI_TAG_TXBF_CMD , +WMI_TAG_DEBUG_LOG_CONFIG_CMD , +WMI_TAG_NLO_EVENT , +WMI_TAG_CHATTER_QUERY_REPLY_EVENT , +WMI_TAG_UPLOAD_H_HDR , +WMI_TAG_CAPTURE_H_EVENT_HDR , +WMI_TAG_VDEV_WNM_SLEEPMODE_CMD , +WMI_TAG_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD , +WMI_TAG_VDEV_WMM_ADDTS_CMD , +WMI_TAG_VDEV_WMM_DELTS_CMD , +WMI_TAG_VDEV_SET_WMM_PARAMS_CMD , +WMI_TAG_TDLS_SET_STATE_CMD , +WMI_TAG_TDLS_PEER_UPDATE_CMD , +WMI_TAG_TDLS_PEER_EVENT , +WMI_TAG_TDLS_PEER_CAPABILITIES , +WMI_TAG_VDEV_MCC_SET_TBTT_MODE_CMD , +WMI_TAG_ROAM_CHAN_LIST , +WMI_TAG_VDEV_MCC_BCN_INTVL_CHANGE_EVENT , +WMI_TAG_RESMGR_ADAPTIVE_OCS_ENABLE_DISABLE_CMD , +WMI_TAG_RESMGR_SET_CHAN_TIME_QUOTA_CMD , +WMI_TAG_RESMGR_SET_CHAN_LATENCY_CMD , +WMI_TAG_BA_REQ_SSN_CMD , +WMI_TAG_BA_RSP_SSN_EVENT , +WMI_TAG_STA_SMPS_FORCE_MODE_CMD , +WMI_TAG_SET_MCASTBCAST_FILTER_CMD , +WMI_TAG_P2P_SET_OPPPS_CMD , +WMI_TAG_P2P_SET_NOA_CMD , +WMI_TAG_BA_REQ_SSN_CMD_SUB_STRUCT_PARAM , +WMI_TAG_BA_REQ_SSN_EVENT_SUB_STRUCT_PARAM , +WMI_TAG_STA_SMPS_PARAM_CMD , +WMI_TAG_VDEV_SET_GTX_PARAMS_CMD , +WMI_TAG_MCC_SCHED_TRAFFIC_STATS_CMD , +WMI_TAG_MCC_SCHED_STA_TRAFFIC_STATS , +WMI_TAG_OFFLOAD_BCN_TX_STATUS_EVENT , +WMI_TAG_P2P_NOA_EVENT , +WMI_TAG_HB_SET_ENABLE_CMD , +WMI_TAG_HB_SET_TCP_PARAMS_CMD , +WMI_TAG_HB_SET_TCP_PKT_FILTER_CMD , +WMI_TAG_HB_SET_UDP_PARAMS_CMD , +WMI_TAG_HB_SET_UDP_PKT_FILTER_CMD , +WMI_TAG_HB_IND_EVENT , +WMI_TAG_TX_PAUSE_EVENT , +WMI_TAG_RFKILL_EVENT , +WMI_TAG_DFS_RADAR_EVENT , +WMI_TAG_DFS_PHYERR_FILTER_ENA_CMD , +WMI_TAG_DFS_PHYERR_FILTER_DIS_CMD , +WMI_TAG_BATCH_SCAN_RESULT_SCAN_LIST , +WMI_TAG_BATCH_SCAN_RESULT_NETWORK_INFO , +WMI_TAG_BATCH_SCAN_ENABLE_CMD , +WMI_TAG_BATCH_SCAN_DISABLE_CMD , +WMI_TAG_BATCH_SCAN_TRIGGER_RESULT_CMD , +WMI_TAG_BATCH_SCAN_ENABLED_EVENT , +WMI_TAG_BATCH_SCAN_RESULT_EVENT , +WMI_TAG_VDEV_PLMREQ_START_CMD , +WMI_TAG_VDEV_PLMREQ_STOP_CMD , +WMI_TAG_THERMAL_MGMT_CMD , +WMI_TAG_THERMAL_MGMT_EVENT , +WMI_TAG_PEER_INFO_REQ_CMD , +WMI_TAG_PEER_INFO_EVENT , +WMI_TAG_PEER_INFO , +WMI_TAG_PEER_TX_FAIL_CNT_THR_EVENT , +WMI_TAG_RMC_SET_MODE_CMD , +WMI_TAG_RMC_SET_ACTION_PERIOD_CMD , +WMI_TAG_RMC_CONFIG_CMD , +WMI_TAG_MHF_OFFLOAD_SET_MODE_CMD , +WMI_TAG_MHF_OFFLOAD_PLUMB_ROUTING_TABLE_CMD , +WMI_TAG_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD , +WMI_TAG_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD , +WMI_TAG_NAN_CMD_PARAM , +WMI_TAG_NAN_EVENT_HDR , +WMI_TAG_PDEV_L1SS_TRACK_EVENT , +WMI_TAG_DIAG_DATA_CONTAINER_EVENT , +WMI_TAG_MODEM_POWER_STATE_CMD_PARAM , +WMI_TAG_PEER_GET_ESTIMATED_LINKSPEED_CMD , +WMI_TAG_PEER_ESTIMATED_LINKSPEED_EVENT , +WMI_TAG_AGGR_STATE_TRIG_EVENT , +WMI_TAG_MHF_OFFLOAD_ROUTING_TABLE_ENTRY , +WMI_TAG_ROAM_SCAN_CMD , +WMI_TAG_REQ_STATS_EXT_CMD , +WMI_TAG_STATS_EXT_EVENT , +WMI_TAG_OBSS_SCAN_ENABLE_CMD , +WMI_TAG_OBSS_SCAN_DISABLE_CMD , +WMI_TAG_OFFLOAD_PRB_RSP_TX_STATUS_EVENT , +WMI_TAG_PDEV_SET_LED_CONFIG_CMD , +WMI_TAG_HOST_AUTO_SHUTDOWN_CFG_CMD , +WMI_TAG_HOST_AUTO_SHUTDOWN_EVENT , +WMI_TAG_UPDATE_WHAL_MIB_STATS_EVENT , +WMI_TAG_CHAN_AVOID_UPDATE_CMD_PARAM , +WMI_TAG_WOW_IOAC_PKT_PATTERN_T , +WMI_TAG_WOW_IOAC_TMR_PATTERN_T , +WMI_TAG_WOW_IOAC_ADD_KEEPALIVE_CMD , +WMI_TAG_WOW_IOAC_DEL_KEEPALIVE_CMD , +WMI_TAG_WOW_IOAC_KEEPALIVE_T , +WMI_TAG_WOW_IOAC_ADD_PATTERN_CMD , +WMI_TAG_WOW_IOAC_DEL_PATTERN_CMD , +WMI_TAG_START_LINK_STATS_CMD , +WMI_TAG_CLEAR_LINK_STATS_CMD , +WMI_TAG_REQUEST_LINK_STATS_CMD , +WMI_TAG_IFACE_LINK_STATS_EVENT , +WMI_TAG_RADIO_LINK_STATS_EVENT , +WMI_TAG_PEER_STATS_EVENT , +WMI_TAG_CHANNEL_STATS , +WMI_TAG_RADIO_LINK_STATS , +WMI_TAG_RATE_STATS , +WMI_TAG_PEER_LINK_STATS , +WMI_TAG_WMM_AC_STATS , +WMI_TAG_IFACE_LINK_STATS , +WMI_TAG_LPI_MGMT_SNOOPING_CONFIG_CMD , +WMI_TAG_LPI_START_SCAN_CMD , +WMI_TAG_LPI_STOP_SCAN_CMD , +WMI_TAG_LPI_RESULT_EVENT , +WMI_TAG_PEER_STATE_EVENT , +WMI_TAG_EXTSCAN_BUCKET_CMD , +WMI_TAG_EXTSCAN_BUCKET_CHANNEL_EVENT , +WMI_TAG_EXTSCAN_START_CMD , +WMI_TAG_EXTSCAN_STOP_CMD , +WMI_TAG_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMD , +WMI_TAG_EXTSCAN_WLAN_CHANGE_BSSID_PARAM_CMD , +WMI_TAG_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMD , +WMI_TAG_EXTSCAN_GET_CACHED_RESULTS_CMD , +WMI_TAG_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMD , +WMI_TAG_EXTSCAN_SET_CAPABILITIES_CMD , +WMI_TAG_EXTSCAN_GET_CAPABILITIES_CMD , +WMI_TAG_EXTSCAN_OPERATION_EVENT , +WMI_TAG_EXTSCAN_START_STOP_EVENT , +WMI_TAG_EXTSCAN_TABLE_USAGE_EVENT , +WMI_TAG_EXTSCAN_WLAN_DESCRIPTOR_EVENT , +WMI_TAG_EXTSCAN_RSSI_INFO_EVENT , +WMI_TAG_EXTSCAN_CACHED_RESULTS_EVENT , +WMI_TAG_EXTSCAN_WLAN_CHANGE_RESULTS_EVENT , +WMI_TAG_EXTSCAN_WLAN_CHANGE_RESULT_BSSID_EVENT , +WMI_TAG_EXTSCAN_HOTLIST_MATCH_EVENT , +WMI_TAG_EXTSCAN_CAPABILITIES_EVENT , +WMI_TAG_EXTSCAN_CACHE_CAPABILITIES_EVENT , +WMI_TAG_EXTSCAN_WLAN_CHANGE_MONITOR_CAPABILITIES_EVENT , +WMI_TAG_EXTSCAN_HOTLIST_MONITOR_CAPABILITIES_EVENT , +WMI_TAG_D0_WOW_ENABLE_DISABLE_CMD , +WMI_TAG_D0_WOW_DISABLE_ACK_EVENT , +WMI_TAG_UNIT_TEST_CMD , +WMI_TAG_ROAM_OFFLOAD_TLV_PARAM , +WMI_TAG_ROAM_11I_OFFLOAD_TLV_PARAM , +WMI_TAG_ROAM_11R_OFFLOAD_TLV_PARAM , +WMI_TAG_ROAM_ESE_OFFLOAD_TLV_PARAM , +WMI_TAG_ROAM_SYNCH_EVENT , +WMI_TAG_ROAM_SYNCH_COMPLETE , +WMI_TAG_EXTWOW_ENABLE_CMD , +WMI_TAG_EXTWOW_SET_APP_TYPE1_PARAMS_CMD , +WMI_TAG_EXTWOW_SET_APP_TYPE2_PARAMS_CMD , +WMI_TAG_LPI_STATUS_EVENT , +WMI_TAG_LPI_HANDOFF_EVENT , +WMI_TAG_VDEV_RATE_STATS_EVENT , +WMI_TAG_VDEV_RATE_HT_INFO , +WMI_TAG_RIC_REQUEST , +WMI_TAG_PDEV_GET_TEMPERATURE_CMD , +WMI_TAG_PDEV_TEMPERATURE_EVENT , +WMI_TAG_SET_DHCP_SERVER_OFFLOAD_CMD , +WMI_TAG_TPC_CHAINMASK_CONFIG_CMD , +WMI_TAG_RIC_TSPEC , +WMI_TAG_TPC_CHAINMASK_CONFIG , +WMI_TAG_IPA_OFFLOAD_ENABLE_DISABLE_CMD , +WMI_TAG_SCAN_PROB_REQ_OUI_CMD , +WMI_TAG_KEY_MATERIAL , +WMI_TAG_TDLS_SET_OFFCHAN_MODE_CMD , +WMI_TAG_SET_LED_FLASHING_CMD , +WMI_TAG_MDNS_OFFLOAD_CMD , +WMI_TAG_MDNS_SET_FQDN_CMD , +WMI_TAG_MDNS_SET_RESP_CMD , +WMI_TAG_MDNS_GET_STATS_CMD , +WMI_TAG_MDNS_STATS_EVENT , +WMI_TAG_ROAM_INVOKE_CMD , +WMI_TAG_PDEV_RESUME_EVENT , +WMI_TAG_PDEV_SET_ANTENNA_DIVERSITY_CMD , +WMI_TAG_SAP_OFL_ENABLE_CMD , +WMI_TAG_SAP_OFL_ADD_STA_EVENT , +WMI_TAG_SAP_OFL_DEL_STA_EVENT , +WMI_TAG_APFIND_CMD_PARAM , +WMI_TAG_APFIND_EVENT_HDR , +WMI_TAG_OCB_SET_SCHED_CMD , +WMI_TAG_OCB_SET_SCHED_EVENT , +WMI_TAG_OCB_SET_CONFIG_CMD , +WMI_TAG_OCB_SET_CONFIG_RESP_EVENT , +WMI_TAG_OCB_SET_UTC_TIME_CMD , +WMI_TAG_OCB_START_TIMING_ADVERT_CMD , +WMI_TAG_OCB_STOP_TIMING_ADVERT_CMD , +WMI_TAG_OCB_GET_TSF_TIMER_CMD , +WMI_TAG_OCB_GET_TSF_TIMER_RESP_EVENT , +WMI_TAG_DCC_GET_STATS_CMD , +WMI_TAG_DCC_CHANNEL_STATS_REQUEST , +WMI_TAG_DCC_GET_STATS_RESP_EVENT , +WMI_TAG_DCC_CLEAR_STATS_CMD , +WMI_TAG_DCC_UPDATE_NDL_CMD , +WMI_TAG_DCC_UPDATE_NDL_RESP_EVENT , +WMI_TAG_DCC_STATS_EVENT , +WMI_TAG_OCB_CHANNEL , +WMI_TAG_OCB_SCHEDULE_ELEMENT , +WMI_TAG_DCC_NDL_STATS_PER_CHANNEL , +WMI_TAG_DCC_NDL_CHAN , +WMI_TAG_QOS_PARAMETER , +WMI_TAG_DCC_NDL_ACTIVE_STATE_CONFIG , +WMI_TAG_ROAM_SCAN_EXTENDED_THRESHOLD_PARAM , +WMI_TAG_ROAM_FILTER , +WMI_TAG_PASSPOINT_CONFIG_CMD , +WMI_TAG_PASSPOINT_EVENT_HDR , +WMI_TAG_EXTSCAN_CONFIGURE_HOTLIST_SSID_MONITOR_CMD , +WMI_TAG_EXTSCAN_HOTLIST_SSID_MATCH_EVENT , +WMI_TAG_VDEV_TSF_TSTAMP_ACTION_CMD , +WMI_TAG_VDEV_TSF_REPORT_EVENT , +WMI_TAG_GET_FW_MEM_DUMP , +WMI_TAG_UPDATE_FW_MEM_DUMP , +WMI_TAG_FW_MEM_DUMP_PARAMS , +WMI_TAG_DEBUG_MESG_FLUSH , +WMI_TAG_DEBUG_MESG_FLUSH_COMPLETE , +WMI_TAG_PEER_SET_RATE_REPORT_CONDITION , +WMI_TAG_ROAM_SUBNET_CHANGE_CONFIG , +WMI_TAG_VDEV_SET_IE_CMD , +WMI_TAG_RSSI_BREACH_MONITOR_CONFIG , +WMI_TAG_RSSI_BREACH_EVENT , +WMI_TAG_WOW_EVENT_INITIAL_WAKEUP , +WMI_TAG_SOC_SET_PCL_CMD , +WMI_TAG_SOC_SET_HW_MODE_CMD , +WMI_TAG_SOC_SET_HW_MODE_RESPONSE_EVENT , +WMI_TAG_SOC_HW_MODE_TRANSITION_EVENT , +WMI_TAG_VDEV_TXRX_STREAMS , +WMI_TAG_SOC_SET_HW_MODE_RESPONSE_VDEV_MAC_ENTRY , +WMI_TAG_SOC_SET_DUAL_MAC_CONFIG_CMD , +WMI_TAG_SOC_SET_DUAL_MAC_CONFIG_RESPONSE_EVENT , +WMI_TAG_WOW_IOAC_SOCK_PATTERN_T , +WMI_TAG_WOW_ENABLE_ICMPV6_NA_FLT_CMD , +WMI_TAG_DIAG_EVENT_LOG_CONFIG , +WMI_TAG_DIAG_EVENT_LOG_SUPPORTED_EVENT_FIXED_PARAMS , +WMI_TAG_PACKET_FILTER_CONFIG , +WMI_TAG_PACKET_FILTER_ENABLE , +WMI_TAG_SAP_SET_BLACKLIST_PARAM_CMD , +WMI_TAG_MGMT_TX_SEND_CMD , +WMI_TAG_MGMT_TX_COMPL_EVENT , +WMI_TAG_SOC_SET_ANTENNA_MODE_CMD , +WMI_TAG_WOW_UDP_SVC_OFLD_CMD , +WMI_TAG_LRO_INFO_CMD , +WMI_TAG_ROAM_EARLYSTOP_RSSI_THRES_PARAM , +WMI_TAG_SERVICE_READY_EXT_EVENT , +WMI_TAG_MAWC_SENSOR_REPORT_IND_CMD , +WMI_TAG_MAWC_ENABLE_SENSOR_EVENT , +WMI_TAG_ROAM_CONFIGURE_MAWC_CMD , +WMI_TAG_NLO_CONFIGURE_MAWC_CMD , +WMI_TAG_EXTSCAN_CONFIGURE_MAWC_CMD , +WMI_TAG_PEER_ASSOC_CONF_EVENT , +WMI_TAG_WOW_HOSTWAKEUP_GPIO_PIN_PATTERN_CONFIG_CMD , +WMI_TAG_AP_PS_EGAP_PARAM_CMD , +WMI_TAG_AP_PS_EGAP_INFO_EVENT , +WMI_TAG_PMF_OFFLOAD_SET_SA_QUERY_CMD , +WMI_TAG_TRANSFER_DATA_TO_FLASH_CMD , +WMI_TAG_TRANSFER_DATA_TO_FLASH_COMPLETE_EVENT , +WMI_TAG_SCPC_EVENT , +WMI_TAG_AP_PS_EGAP_INFO_CHAINMASK_LIST , +WMI_TAG_STA_SMPS_FORCE_MODE_COMPLETE_EVENT , +WMI_TAG_BPF_GET_CAPABILITY_CMD , +WMI_TAG_BPF_CAPABILITY_INFO_EVT , +WMI_TAG_BPF_GET_VDEV_STATS_CMD , +WMI_TAG_BPF_VDEV_STATS_INFO_EVT , +WMI_TAG_BPF_SET_VDEV_INSTRUCTIONS_CMD , +WMI_TAG_BPF_DEL_VDEV_INSTRUCTIONS_CMD , +WMI_TAG_VDEV_DELETE_RESP_EVENT , +WMI_TAG_PEER_DELETE_RESP_EVENT , +WMI_TAG_ROAM_DENSE_THRES_PARAM , +WMI_TAG_ENLO_CANDIDATE_SCORE_PARAM , +WMI_TAG_PEER_UPDATE_WDS_ENTRY_CMD , +WMI_TAG_VDEV_CONFIG_RATEMASK , +WMI_TAG_PDEV_FIPS_CMD , +WMI_TAG_PDEV_SMART_ANT_ENABLE_CMD , +WMI_TAG_PDEV_SMART_ANT_SET_RX_ANTENNA_CMD , +WMI_TAG_PEER_SMART_ANT_SET_TX_ANTENNA_CMD , +WMI_TAG_PEER_SMART_ANT_SET_TRAIN_ANTENNA_CMD , +WMI_TAG_PEER_SMART_ANT_SET_NODE_CONFIG_OPS_CMD , +WMI_TAG_PDEV_SET_ANT_SWITCH_TBL_CMD , +WMI_TAG_PDEV_SET_CTL_TABLE_CMD , +WMI_TAG_PDEV_SET_MIMOGAIN_TABLE_CMD , +WMI_TAG_FWTEST_SET_PARAM_CMD , +WMI_TAG_PEER_ATF_REQUEST , +WMI_TAG_VDEV_ATF_REQUEST , +WMI_TAG_PDEV_GET_ANI_CCK_CONFIG_CMD , +WMI_TAG_PDEV_GET_ANI_OFDM_CONFIG_CMD , +WMI_TAG_INST_RSSI_STATS_RESP , +WMI_TAG_MED_UTIL_REPORT_EVENT , +WMI_TAG_PEER_STA_PS_STATECHANGE_EVENT , +WMI_TAG_WDS_ADDR_EVENT , +WMI_TAG_PEER_RATECODE_LIST_EVENT , +WMI_TAG_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENT , +WMI_TAG_PDEV_TPC_EVENT , +WMI_TAG_ANI_OFDM_EVENT , +WMI_TAG_ANI_CCK_EVENT , +WMI_TAG_PDEV_CHANNEL_HOPPING_EVENT , +WMI_TAG_PDEV_FIPS_EVENT , +WMI_TAG_ATF_PEER_INFO , +WMI_TAG_PDEV_GET_TPC_CMD , +WMI_TAG_VDEV_FILTER_NRP_CONFIG_CMD , +WMI_TAG_QBOOST_CFG_CMD , +WMI_TAG_PDEV_SMART_ANT_GPIO_HANDLE , +WMI_TAG_PEER_SMART_ANT_SET_TX_ANTENNA_SERIES , +WMI_TAG_PEER_SMART_ANT_SET_TRAIN_ANTENNA_PARAM , +WMI_TAG_PDEV_SET_ANT_CTRL_CHAIN , +WMI_TAG_PEER_CCK_OFDM_RATE_INFO , +WMI_TAG_PEER_MCS_RATE_INFO , +WMI_TAG_PDEV_NFCAL_POWER_ALL_CHANNELS_NFDBR , +WMI_TAG_PDEV_NFCAL_POWER_ALL_CHANNELS_NFDBM , +WMI_TAG_PDEV_NFCAL_POWER_ALL_CHANNELS_FREQNUM , +WMI_TAG_MU_REPORT_TOTAL_MU , +WMI_TAG_VDEV_SET_DSCP_TID_MAP_CMD , +WMI_TAG_ROAM_SET_MBO , +WMI_TAG_MIB_STATS_ENABLE_CMD , +WMI_TAG_NAN_DISC_IFACE_CREATED_EVENT , +WMI_TAG_NAN_DISC_IFACE_DELETED_EVENT , +WMI_TAG_NAN_STARTED_CLUSTER_EVENT , +WMI_TAG_NAN_JOINED_CLUSTER_EVENT , +WMI_TAG_NDI_GET_CAP_REQ , +WMI_TAG_NDP_INITIATOR_REQ , +WMI_TAG_NDP_RESPONDER_REQ , +WMI_TAG_NDP_END_REQ , +WMI_TAG_NDI_CAP_RSP_EVENT , +WMI_TAG_NDP_INITIATOR_RSP_EVENT , +WMI_TAG_NDP_RESPONDER_RSP_EVENT , +WMI_TAG_NDP_END_RSP_EVENT , +WMI_TAG_NDP_INDICATION_EVENT , +WMI_TAG_NDP_CONFIRM_EVENT , +WMI_TAG_NDP_END_INDICATION_EVENT , +WMI_TAG_VDEV_SET_QUIET_CMD , +WMI_TAG_PDEV_SET_PCL_CMD , +WMI_TAG_PDEV_SET_HW_MODE_CMD , +WMI_TAG_PDEV_SET_MAC_CONFIG_CMD , +WMI_TAG_PDEV_SET_ANTENNA_MODE_CMD , +WMI_TAG_PDEV_SET_HW_MODE_RESPONSE_EVENT , +WMI_TAG_PDEV_HW_MODE_TRANSITION_EVENT , +WMI_TAG_PDEV_SET_HW_MODE_RESPONSE_VDEV_MAC_ENTRY , +WMI_TAG_PDEV_SET_MAC_CONFIG_RESPONSE_EVENT , +WMI_TAG_COEX_CONFIG_CMD , +WMI_TAG_CONFIG_ENHANCED_MCAST_FILTER , +WMI_TAG_CHAN_AVOID_RPT_ALLOW_CMD , +WMI_TAG_SET_PERIODIC_CHANNEL_STATS_CONFIG , +WMI_TAG_VDEV_SET_CUSTOM_AGGR_SIZE_CMD , +WMI_TAG_PDEV_WAL_POWER_DEBUG_CMD , +WMI_TAG_MAC_PHY_CAPABILITIES , +WMI_TAG_HW_MODE_CAPABILITIES , +WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS , +WMI_TAG_HAL_REG_CAPABILITIES_EXT , +WMI_TAG_SOC_HAL_REG_CAPABILITIES , +WMI_TAG_VDEV_WISA_CMD , +WMI_TAG_TX_POWER_LEVEL_STATS_EVT , +WMI_TAG_SCAN_ADAPTIVE_DWELL_PARAMETERS_TLV , +WMI_TAG_SCAN_ADAPTIVE_DWELL_CONFIG , +WMI_TAG_WOW_SET_ACTION_WAKE_UP_CMD , +WMI_TAG_NDP_END_RSP_PER_NDI , +WMI_TAG_PEER_BWF_REQUEST , +WMI_TAG_BWF_PEER_INFO , +WMI_TAG_DBGLOG_TIME_STAMP_SYNC_CMD , +WMI_TAG_RMC_SET_LEADER_CMD , +WMI_TAG_RMC_MANUAL_LEADER_EVENT , +WMI_TAG_PER_CHAIN_RSSI_STATS , +WMI_TAG_RSSI_STATS , +WMI_TAG_P2P_LO_START_CMD , +WMI_TAG_P2P_LO_STOP_CMD , +WMI_TAG_P2P_LO_STOPPED_EVENT , +WMI_TAG_REORDER_QUEUE_SETUP_CMD , +WMI_TAG_REORDER_QUEUE_REMOVE_CMD , +WMI_TAG_SET_MULTIPLE_MCAST_FILTER_CMD , +WMI_TAG_MGMT_TX_COMPL_BUNDLE_EVENT , +WMI_TAG_READ_DATA_FROM_FLASH_CMD , +WMI_TAG_READ_DATA_FROM_FLASH_EVENT , +WMI_TAG_PDEV_SET_REORDER_TIMEOUT_VAL_CMD , +WMI_TAG_PEER_SET_RX_BLOCKSIZE_CMD , +WMI_TAG_PDEV_SET_WAKEUP_CONFIG_CMDID , +WMI_TAG_TLV_BUF_LEN_PARAM , +WMI_TAG_SERVICE_AVAILABLE_EVENT , +WMI_TAG_PEER_ANTDIV_INFO_REQ_CMD , +WMI_TAG_PEER_ANTDIV_INFO_EVENT , +WMI_TAG_PEER_ANTDIV_INFO , +WMI_TAG_PDEV_GET_ANTDIV_STATUS_CMD , +WMI_TAG_PDEV_ANTDIV_STATUS_EVENT , +WMI_TAG_MNT_FILTER_CMD , +WMI_TAG_GET_CHIP_POWER_STATS_CMD , +WMI_TAG_PDEV_CHIP_POWER_STATS_EVENT , +WMI_TAG_COEX_GET_ANTENNA_ISOLATION_CMD , +WMI_TAG_COEX_REPORT_ISOLATION_EVENT , +WMI_TAG_CHAN_CCA_STATS , +WMI_TAG_PEER_SIGNAL_STATS , +WMI_TAG_TX_STATS , +WMI_TAG_PEER_AC_TX_STATS , +WMI_TAG_RX_STATS , +WMI_TAG_PEER_AC_RX_STATS , +WMI_TAG_REPORT_STATS_EVENT , +WMI_TAG_CHAN_CCA_STATS_THRESH , +WMI_TAG_PEER_SIGNAL_STATS_THRESH , +WMI_TAG_TX_STATS_THRESH , +WMI_TAG_RX_STATS_THRESH , +WMI_TAG_PDEV_SET_STATS_THRESHOLD_CMD , +WMI_TAG_REQUEST_WLAN_STATS_CMD , +WMI_TAG_RX_AGGR_FAILURE_EVENT , +WMI_TAG_RX_AGGR_FAILURE_INFO , +WMI_TAG_VDEV_ENCRYPT_DECRYPT_DATA_REQ_CMD , +WMI_TAG_VDEV_ENCRYPT_DECRYPT_DATA_RESP_EVENT , +WMI_TAG_PDEV_BAND_TO_MAC , +WMI_TAG_TBTT_OFFSET_INFO , +WMI_TAG_TBTT_OFFSET_EXT_EVENT , +WMI_TAG_SAR_LIMITS_CMD , +WMI_TAG_SAR_LIMIT_CMD_ROW , +WMI_TAG_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMD , +WMI_TAG_PDEV_DFS_PHYERR_OFFLOAD_DISABLE_CMD , +WMI_TAG_VDEV_ADFS_CH_CFG_CMD , +WMI_TAG_VDEV_ADFS_OCAC_ABORT_CMD , +WMI_TAG_PDEV_DFS_RADAR_DETECTION_EVENT , +WMI_TAG_VDEV_ADFS_OCAC_COMPLETE_EVENT , +WMI_TAG_VDEV_DFS_CAC_COMPLETE_EVENT , +WMI_TAG_VENDOR_OUI , +WMI_TAG_REQUEST_RCPI_CMD , +WMI_TAG_UPDATE_RCPI_EVENT , +WMI_TAG_REQUEST_PEER_STATS_INFO_CMD , +WMI_TAG_PEER_STATS_INFO , +WMI_TAG_PEER_STATS_INFO_EVENT , +WMI_TAG_PKGID_EVENT , +WMI_TAG_CONNECTED_NLO_RSSI_PARAMS , +WMI_TAG_SET_CURRENT_COUNTRY_CMD , +WMI_TAG_REGULATORY_RULE_STRUCT , +WMI_TAG_REG_CHAN_LIST_CC_EVENT , +WMI_TAG_11D_SCAN_START_CMD , +WMI_TAG_11D_SCAN_STOP_CMD , +WMI_TAG_11D_NEW_COUNTRY_EVENT , +WMI_TAG_REQUEST_RADIO_CHAN_STATS_CMD , +WMI_TAG_RADIO_CHAN_STATS , +WMI_TAG_RADIO_CHAN_STATS_EVENT , +WMI_TAG_ROAM_PER_CONFIG , +WMI_TAG_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_CMD , +WMI_TAG_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENT , +WMI_TAG_BPF_SET_VDEV_ACTIVE_MODE_CMD , +WMI_TAG_HW_DATA_FILTER_CMD , +WMI_TAG_CONNECTED_NLO_BSS_BAND_RSSI_PREF , +WMI_TAG_PEER_OPER_MODE_CHANGE_EVENT , +WMI_TAG_CHIP_POWER_SAVE_FAILURE_DETECTED , +WMI_TAG_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMD , +WMI_TAG_PDEV_CSA_SWITCH_COUNT_STATUS_EVENT , +WMI_TAG_PDEV_UPDATE_PKT_ROUTING_CMD , +WMI_TAG_PDEV_CHECK_CAL_VERSION_CMD , +WMI_TAG_PDEV_CHECK_CAL_VERSION_EVENT , +WMI_TAG_PDEV_SET_DIVERSITY_GAIN_CMD , +WMI_TAG_MAC_PHY_CHAINMASK_COMBO , +WMI_TAG_MAC_PHY_CHAINMASK_CAPABILITY , +WMI_TAG_VDEV_SET_ARP_STATS_CMD , +WMI_TAG_VDEV_GET_ARP_STATS_CMD , +WMI_TAG_VDEV_GET_ARP_STATS_EVENT , +WMI_TAG_IFACE_OFFLOAD_STATS , +WMI_TAG_REQUEST_STATS_CMD_SUB_STRUCT_PARAM , +WMI_TAG_RSSI_CTL_EXT , +WMI_TAG_SINGLE_PHYERR_EXT_RX_HDR , +WMI_TAG_COEX_BT_ACTIVITY_EVENT , +WMI_TAG_VDEV_GET_TX_POWER_CMD , +WMI_TAG_VDEV_TX_POWER_EVENT , +WMI_TAG_OFFCHAN_DATA_TX_COMPL_EVENT , +WMI_TAG_OFFCHAN_DATA_TX_SEND_CMD , +WMI_TAG_TX_SEND_PARAMS , +WMI_TAG_HE_RATE_SET , +WMI_TAG_CONGESTION_STATS , +WMI_TAG_SET_INIT_COUNTRY_CMD , +WMI_TAG_SCAN_DBS_DUTY_CYCLE , +WMI_TAG_SCAN_DBS_DUTY_CYCLE_PARAM_TLV , +WMI_TAG_PDEV_DIV_GET_RSSI_ANTID , +WMI_TAG_THERM_THROT_CONFIG_REQUEST , +WMI_TAG_THERM_THROT_LEVEL_CONFIG_INFO , +WMI_TAG_THERM_THROT_STATS_EVENT , +WMI_TAG_THERM_THROT_LEVEL_STATS_INFO , +WMI_TAG_PDEV_DIV_RSSI_ANTID_EVENT , +WMI_TAG_OEM_DMA_RING_CAPABILITIES , +WMI_TAG_OEM_DMA_RING_CFG_REQ , +WMI_TAG_OEM_DMA_RING_CFG_RSP , +WMI_TAG_OEM_INDIRECT_DATA , +WMI_TAG_OEM_DMA_BUF_RELEASE , +WMI_TAG_OEM_DMA_BUF_RELEASE_ENTRY , +WMI_TAG_PDEV_BSS_CHAN_INFO_REQUEST , +WMI_TAG_PDEV_BSS_CHAN_INFO_EVENT , +WMI_TAG_ROAM_LCA_DISALLOW_CONFIG , +WMI_TAG_VDEV_LIMIT_OFFCHAN_CMD , +WMI_TAG_ROAM_RSSI_REJECTION_OCE_CONFIG , +WMI_TAG_UNIT_TEST_EVENT , +WMI_TAG_ROAM_FILS_OFFLOAD , +WMI_TAG_PDEV_UPDATE_PMK_CACHE_CMD , +WMI_TAG_PMK_CACHE , +WMI_TAG_PDEV_UPDATE_FILS_HLP_PKT_CMD , +WMI_TAG_ROAM_FILS_SYNCH , +WMI_TAG_GTK_OFFLOAD_EXTENDED , +WMI_TAG_ROAM_BG_SCAN_ROAMING , +WMI_TAG_OIC_PING_OFFLOAD_PARAMS_CMD , +WMI_TAG_OIC_PING_OFFLOAD_SET_ENABLE_CMD , +WMI_TAG_OIC_PING_HANDOFF_EVENT , +WMI_TAG_DHCP_LEASE_RENEW_OFFLOAD_CMD , +WMI_TAG_DHCP_LEASE_RENEW_EVENT , +WMI_TAG_BTM_CONFIG , +WMI_TAG_DEBUG_MESG_FW_DATA_STALL , +WMI_TAG_WLM_CONFIG_CMD , +WMI_TAG_PDEV_UPDATE_CTLTABLE_REQUEST , +WMI_TAG_PDEV_UPDATE_CTLTABLE_EVENT , +WMI_TAG_ROAM_CND_SCORING_PARAM , +WMI_TAG_PDEV_CONFIG_VENDOR_OUI_ACTION , +WMI_TAG_VENDOR_OUI_EXT , +WMI_TAG_ROAM_SYNCH_FRAME_EVENT , +WMI_TAG_FD_SEND_FROM_HOST_CMD , +WMI_TAG_ENABLE_FILS_CMD , +WMI_TAG_HOST_SWFDA_EVENT , +WMI_TAG_BCN_OFFLOAD_CTRL_CMD , +WMI_TAG_PDEV_SET_AC_TX_QUEUE_OPTIMIZED_CMD , +WMI_TAG_STATS_PERIOD , +WMI_TAG_NDL_SCHEDULE_UPDATE , +WMI_TAG_PEER_TID_MSDUQ_QDEPTH_THRESH_UPDATE_CMD , +WMI_TAG_MSDUQ_QDEPTH_THRESH_UPDATE , +WMI_TAG_PDEV_SET_RX_FILTER_PROMISCUOUS_CMD , +WMI_TAG_SAR2_RESULT_EVENT , +WMI_TAG_SAR_CAPABILITIES , +WMI_TAG_SAP_OBSS_DETECTION_CFG_CMD , +WMI_TAG_SAP_OBSS_DETECTION_INFO_EVT , +WMI_TAG_DMA_RING_CAPABILITIES , +WMI_TAG_DMA_RING_CFG_REQ , +WMI_TAG_DMA_RING_CFG_RSP , +WMI_TAG_DMA_BUF_RELEASE , +WMI_TAG_DMA_BUF_RELEASE_ENTRY , +WMI_TAG_SAR_GET_LIMITS_CMD , +WMI_TAG_SAR_GET_LIMITS_EVENT , +WMI_TAG_SAR_GET_LIMITS_EVENT_ROW , +WMI_TAG_OFFLOAD_11K_REPORT , +WMI_TAG_INVOKE_NEIGHBOR_REPORT , +WMI_TAG_NEIGHBOR_REPORT_OFFLOAD , +WMI_TAG_VDEV_SET_CONNECTIVITY_CHECK_STATS , +WMI_TAG_VDEV_GET_CONNECTIVITY_CHECK_STATS , +WMI_TAG_BPF_SET_VDEV_ENABLE_CMD , +WMI_TAG_BPF_SET_VDEV_WORK_MEMORY_CMD , +WMI_TAG_BPF_GET_VDEV_WORK_MEMORY_CMD , +WMI_TAG_BPF_GET_VDEV_WORK_MEMORY_RESP_EVT , +WMI_TAG_PDEV_GET_NFCAL_POWER , +WMI_TAG_BSS_COLOR_CHANGE_ENABLE , +WMI_TAG_OBSS_COLOR_COLLISION_DET_CONFIG , +WMI_TAG_OBSS_COLOR_COLLISION_EVT , +WMI_TAG_RUNTIME_DPD_RECAL_CMD , +WMI_TAG_TWT_ENABLE_CMD , +WMI_TAG_TWT_DISABLE_CMD , +WMI_TAG_TWT_ADD_DIALOG_CMD , +WMI_TAG_TWT_DEL_DIALOG_CMD , +WMI_TAG_TWT_PAUSE_DIALOG_CMD , +WMI_TAG_TWT_RESUME_DIALOG_CMD , +WMI_TAG_TWT_ENABLE_COMPLETE_EVENT , +WMI_TAG_TWT_DISABLE_COMPLETE_EVENT , +WMI_TAG_TWT_ADD_DIALOG_COMPLETE_EVENT , +WMI_TAG_TWT_DEL_DIALOG_COMPLETE_EVENT , +WMI_TAG_TWT_PAUSE_DIALOG_COMPLETE_EVENT , +WMI_TAG_TWT_RESUME_DIALOG_COMPLETE_EVENT , +WMI_TAG_REQUEST_ROAM_SCAN_STATS_CMD , +WMI_TAG_ROAM_SCAN_STATS_EVENT , +WMI_TAG_PEER_TID_CONFIGURATIONS_CMD , +WMI_TAG_VDEV_SET_CUSTOM_SW_RETRY_TH_CMD , +WMI_TAG_GET_TPC_POWER_CMD , +WMI_TAG_GET_TPC_POWER_EVENT , +WMI_TAG_DMA_BUF_RELEASE_SPECTRAL_META_DATA , +WMI_TAG_MOTION_DET_CONFIG_PARAMS_CMD , +WMI_TAG_MOTION_DET_BASE_LINE_CONFIG_PARAMS_CMD , +WMI_TAG_MOTION_DET_START_STOP_CMD , +WMI_TAG_MOTION_DET_BASE_LINE_START_STOP_CMD , +WMI_TAG_MOTION_DET_EVENT , +WMI_TAG_MOTION_DET_BASE_LINE_EVENT , +WMI_TAG_NDP_TRANSPORT_IP , +WMI_TAG_OBSS_SPATIAL_REUSE_SET_CMD , +WMI_TAG_ESP_ESTIMATE_EVENT , +WMI_TAG_NAN_HOST_CONFIG , +WMI_TAG_SPECTRAL_BIN_SCALING_PARAMS , +WMI_TAG_PEER_CFR_CAPTURE_CMD , +WMI_TAG_PEER_CHAN_WIDTH_SWITCH_CMD , +WMI_TAG_CHAN_WIDTH_PEER_LIST , +WMI_TAG_OBSS_SPATIAL_REUSE_SET_DEF_OBSS_THRESH_CMD , +WMI_TAG_PDEV_HE_TB_ACTION_FRM_CMD , +WMI_TAG_PEER_EXTD2_STATS , +WMI_TAG_HPCS_PULSE_START_CMD , +WMI_TAG_PDEV_CTL_FAILSAFE_CHECK_EVENT , +WMI_TAG_VDEV_CHAINMASK_CONFIG_CMD , +WMI_TAG_VDEV_BCN_OFFLOAD_QUIET_CONFIG_CMD , +WMI_TAG_NAN_EVENT_INFO , +WMI_TAG_NDP_CHANNEL_INFO , +WMI_TAG_NDP_CMD , +WMI_TAG_NDP_EVENT , +/* TODO add all the missing cmds */ +WMI_TAG_PDEV_PEER_PKTLOG_FILTER_CMD =0x301 , +WMI_TAG_PDEV_PEER_PKTLOG_FILTER_INFO , +WMI_TAG_MAX +}; + +enum wmi_tlv_service { +WMI_TLV_SERVICE_BEACON_OFFLOAD =0 , +WMI_TLV_SERVICE_SCAN_OFFLOAD =1 , +WMI_TLV_SERVICE_ROAM_SCAN_OFFLOAD =2 , +WMI_TLV_SERVICE_BCN_MISS_OFFLOAD =3 , +WMI_TLV_SERVICE_STA_PWRSAVE =4 , +WMI_TLV_SERVICE_STA_ADVANCED_PWRSAVE =5 , +WMI_TLV_SERVICE_AP_UAPSD =6 , +WMI_TLV_SERVICE_AP_DFS =7 , +WMI_TLV_SERVICE_11AC =8 , +WMI_TLV_SERVICE_BLOCKACK =9 , +WMI_TLV_SERVICE_PHYERR =10 , +WMI_TLV_SERVICE_BCN_FILTER =11 , +WMI_TLV_SERVICE_RTT =12 , +WMI_TLV_SERVICE_WOW =13 , +WMI_TLV_SERVICE_RATECTRL_CACHE =14 , +WMI_TLV_SERVICE_IRAM_TIDS =15 , +WMI_TLV_SERVICE_ARPNS_OFFLOAD =16 , +WMI_TLV_SERVICE_NLO =17 , +WMI_TLV_SERVICE_GTK_OFFLOAD =18 , +WMI_TLV_SERVICE_SCAN_SCH =19 , +WMI_TLV_SERVICE_CSA_OFFLOAD =20 , +WMI_TLV_SERVICE_CHATTER =21 , +WMI_TLV_SERVICE_COEX_FREQAVOID =22 , +WMI_TLV_SERVICE_PACKET_POWER_SAVE =23 , +WMI_TLV_SERVICE_FORCE_FW_HANG =24 , +WMI_TLV_SERVICE_GPIO =25 , +WMI_TLV_SERVICE_STA_DTIM_PS_MODULATED_DTIM =26 , +WMI_STA_UAPSD_BASIC_AUTO_TRIG =27 , +WMI_STA_UAPSD_VAR_AUTO_TRIG =28 , +WMI_TLV_SERVICE_STA_KEEP_ALIVE =29 , +WMI_TLV_SERVICE_TX_ENCAP =30 , +WMI_TLV_SERVICE_AP_PS_DETECT_OUT_OF_SYNC =31 , +WMI_TLV_SERVICE_EARLY_RX =32 , +WMI_TLV_SERVICE_STA_SMPS =33 , +WMI_TLV_SERVICE_FWTEST =34 , +WMI_TLV_SERVICE_STA_WMMAC =35 , +WMI_TLV_SERVICE_TDLS =36 , +WMI_TLV_SERVICE_BURST =37 , +WMI_TLV_SERVICE_MCC_BCN_INTERVAL_CHANGE =38 , +WMI_TLV_SERVICE_ADAPTIVE_OCS =39 , +WMI_TLV_SERVICE_BA_SSN_SUPPORT =40 , +WMI_TLV_SERVICE_FILTER_IPSEC_NATKEEPALIVE =41 , +WMI_TLV_SERVICE_WLAN_HB =42 , +WMI_TLV_SERVICE_LTE_ANT_SHARE_SUPPORT =43 , +WMI_TLV_SERVICE_BATCH_SCAN =44 , +WMI_TLV_SERVICE_QPOWER =45 , +WMI_TLV_SERVICE_PLMREQ =46 , +WMI_TLV_SERVICE_THERMAL_MGMT =47 , +WMI_TLV_SERVICE_RMC =48 , +WMI_TLV_SERVICE_MHF_OFFLOAD =49 , +WMI_TLV_SERVICE_COEX_SAR =50 , +WMI_TLV_SERVICE_BCN_TXRATE_OVERRIDE =51 , +WMI_TLV_SERVICE_NAN =52 , +WMI_TLV_SERVICE_L1SS_STAT =53 , +WMI_TLV_SERVICE_ESTIMATE_LINKSPEED =54 , +WMI_TLV_SERVICE_OBSS_SCAN =55 , +WMI_TLV_SERVICE_TDLS_OFFCHAN =56 , +WMI_TLV_SERVICE_TDLS_UAPSD_BUFFER_STA =57 , +WMI_TLV_SERVICE_TDLS_UAPSD_SLEEP_STA =58 , +WMI_TLV_SERVICE_IBSS_PWRSAVE =59 , +WMI_TLV_SERVICE_LPASS =60 , +WMI_TLV_SERVICE_EXTSCAN =61 , +WMI_TLV_SERVICE_D0WOW =62 , +WMI_TLV_SERVICE_HSOFFLOAD =63 , +WMI_TLV_SERVICE_ROAM_HO_OFFLOAD =64 , +WMI_TLV_SERVICE_RX_FULL_REORDER =65 , +WMI_TLV_SERVICE_DHCP_OFFLOAD =66 , +WMI_TLV_SERVICE_STA_RX_IPA_OFFLOAD_SUPPORT =67 , +WMI_TLV_SERVICE_MDNS_OFFLOAD =68 , +WMI_TLV_SERVICE_SAP_AUTH_OFFLOAD =69 , +WMI_TLV_SERVICE_DUAL_BAND_SIMULTANEOUS_SUPPORT =70 , +WMI_TLV_SERVICE_OCB =71 , +WMI_TLV_SERVICE_AP_ARPNS_OFFLOAD =72 , +WMI_TLV_SERVICE_PER_BAND_CHAINMASK_SUPPORT =73 , +WMI_TLV_SERVICE_PACKET_FILTER_OFFLOAD =74 , +WMI_TLV_SERVICE_MGMT_TX_HTT =75 , +WMI_TLV_SERVICE_MGMT_TX_WMI =76 , +WMI_TLV_SERVICE_EXT_MSG =77 , +WMI_TLV_SERVICE_MAWC =78 , +WMI_TLV_SERVICE_PEER_ASSOC_CONF =79 , +WMI_TLV_SERVICE_EGAP =80 , +WMI_TLV_SERVICE_STA_PMF_OFFLOAD =81 , +WMI_TLV_SERVICE_UNIFIED_WOW_CAPABILITY =82 , +WMI_TLV_SERVICE_ENHANCED_PROXY_STA =83 , +WMI_TLV_SERVICE_ATF =84 , +WMI_TLV_SERVICE_COEX_GPIO =85 , +WMI_TLV_SERVICE_AUX_SPECTRAL_INTF =86 , +WMI_TLV_SERVICE_AUX_CHAN_LOAD_INTF =87 , +WMI_TLV_SERVICE_BSS_CHANNEL_INFO_64 =88 , +WMI_TLV_SERVICE_ENTERPRISE_MESH =89 , +WMI_TLV_SERVICE_RESTRT_CHNL_SUPPORT =90 , +WMI_TLV_SERVICE_BPF_OFFLOAD =91 , +WMI_TLV_SERVICE_SYNC_DELETE_CMDS =92 , +WMI_TLV_SERVICE_SMART_ANTENNA_SW_SUPPORT =93 , +WMI_TLV_SERVICE_SMART_ANTENNA_HW_SUPPORT =94 , +WMI_TLV_SERVICE_RATECTRL_LIMIT_MAX_MIN_RATES =95 , +WMI_TLV_SERVICE_NAN_DATA =96 , +WMI_TLV_SERVICE_NAN_RTT =97 , +WMI_TLV_SERVICE_11AX =98 , +WMI_TLV_SERVICE_DEPRECATED_REPLACE =99 , +WMI_TLV_SERVICE_TDLS_CONN_TRACKER_IN_HOST_MODE =100 , +WMI_TLV_SERVICE_ENHANCED_MCAST_FILTER =101 , +WMI_TLV_SERVICE_PERIODIC_CHAN_STAT_SUPPORT =102 , +WMI_TLV_SERVICE_MESH_11S =103 , +WMI_TLV_SERVICE_HALF_RATE_QUARTER_RATE_SUPPORT =104 , +WMI_TLV_SERVICE_VDEV_RX_FILTER =105 , +WMI_TLV_SERVICE_P2P_LISTEN_OFFLOAD_SUPPORT =106 , +WMI_TLV_SERVICE_MARK_FIRST_WAKEUP_PACKET =107 , +WMI_TLV_SERVICE_MULTIPLE_MCAST_FILTER_SET =108 , +WMI_TLV_SERVICE_HOST_MANAGED_RX_REORDER =109 , +WMI_TLV_SERVICE_FLASH_RDWR_SUPPORT =110 , +WMI_TLV_SERVICE_WLAN_STATS_REPORT =111 , +WMI_TLV_SERVICE_TX_MSDU_ID_NEW_PARTITION_SUPPORT =112 , +WMI_TLV_SERVICE_DFS_PHYERR_OFFLOAD =113 , +WMI_TLV_SERVICE_RCPI_SUPPORT =114 , +WMI_TLV_SERVICE_FW_MEM_DUMP_SUPPORT =115 , +WMI_TLV_SERVICE_PEER_STATS_INFO =116 , +WMI_TLV_SERVICE_REGULATORY_DB =117 , +WMI_TLV_SERVICE_11D_OFFLOAD =118 , +WMI_TLV_SERVICE_HW_DATA_FILTERING =119 , +WMI_TLV_SERVICE_MULTIPLE_VDEV_RESTART =120 , +WMI_TLV_SERVICE_PKT_ROUTING =121 , +WMI_TLV_SERVICE_CHECK_CAL_VERSION =122 , +WMI_TLV_SERVICE_OFFCHAN_TX_WMI =123 , +WMI_TLV_SERVICE_8SS_TX_BFEE =124 , +WMI_TLV_SERVICE_EXTENDED_NSS_SUPPORT =125 , +WMI_TLV_SERVICE_ACK_TIMEOUT =126 , +WMI_TLV_SERVICE_PDEV_BSS_CHANNEL_INFO_64 =127 , + +WMI_MAX_SERVICE =128 , + +WMI_TLV_SERVICE_CHAN_LOAD_INFO =128 , +WMI_TLV_SERVICE_TX_PPDU_INFO_STATS_SUPPORT =129 , +WMI_TLV_SERVICE_VDEV_LIMIT_OFFCHAN_SUPPORT =130 , +WMI_TLV_SERVICE_FILS_SUPPORT =131 , +WMI_TLV_SERVICE_WLAN_OIC_PING_OFFLOAD =132 , +WMI_TLV_SERVICE_WLAN_DHCP_RENEW =133 , +WMI_TLV_SERVICE_MAWC_SUPPORT =134 , +WMI_TLV_SERVICE_VDEV_LATENCY_CONFIG =135 , +WMI_TLV_SERVICE_PDEV_UPDATE_CTLTABLE_SUPPORT =136 , +WMI_TLV_SERVICE_PKTLOG_SUPPORT_OVER_HTT =137 , +WMI_TLV_SERVICE_VDEV_MULTI_GROUP_KEY_SUPPORT =138 , +WMI_TLV_SERVICE_SCAN_PHYMODE_SUPPORT =139 , +WMI_TLV_SERVICE_THERM_THROT =140 , +WMI_TLV_SERVICE_BCN_OFFLOAD_START_STOP_SUPPORT =141 , +WMI_TLV_SERVICE_WOW_WAKEUP_BY_TIMER_PATTERN =142 , +WMI_TLV_SERVICE_PEER_MAP_UNMAP_V2_SUPPORT =143 , +WMI_TLV_SERVICE_OFFCHAN_DATA_TID_SUPPORT =144 , +WMI_TLV_SERVICE_RX_PROMISC_ENABLE_SUPPORT =145 , +WMI_TLV_SERVICE_SUPPORT_DIRECT_DMA =146 , +WMI_TLV_SERVICE_AP_OBSS_DETECTION_OFFLOAD =147 , +WMI_TLV_SERVICE_11K_NEIGHBOUR_REPORT_SUPPORT =148 , +WMI_TLV_SERVICE_LISTEN_INTERVAL_OFFLOAD_SUPPORT =149 , +WMI_TLV_SERVICE_BSS_COLOR_OFFLOAD =150 , +WMI_TLV_SERVICE_RUNTIME_DPD_RECAL =151 , +WMI_TLV_SERVICE_STA_TWT =152 , +WMI_TLV_SERVICE_AP_TWT =153 , +WMI_TLV_SERVICE_GMAC_OFFLOAD_SUPPORT =154 , +WMI_TLV_SERVICE_SPOOF_MAC_SUPPORT =155 , +WMI_TLV_SERVICE_PEER_TID_CONFIGS_SUPPORT =156 , +WMI_TLV_SERVICE_VDEV_SWRETRY_PER_AC_CONFIG_SUPPORT =157 , +WMI_TLV_SERVICE_DUAL_BEACON_ON_SINGLE_MAC_SCC_SUPPORT =158 , +WMI_TLV_SERVICE_DUAL_BEACON_ON_SINGLE_MAC_MCC_SUPPORT =159 , +WMI_TLV_SERVICE_MOTION_DET =160 , +WMI_TLV_SERVICE_INFRA_MBSSID =161 , +WMI_TLV_SERVICE_OBSS_SPATIAL_REUSE =162 , +WMI_TLV_SERVICE_VDEV_DIFFERENT_BEACON_INTERVAL_SUPPORT =163 , +WMI_TLV_SERVICE_NAN_DBS_SUPPORT =164 , +WMI_TLV_SERVICE_NDI_DBS_SUPPORT =165 , +WMI_TLV_SERVICE_NAN_SAP_SUPPORT =166 , +WMI_TLV_SERVICE_NDI_SAP_SUPPORT =167 , +WMI_TLV_SERVICE_CFR_CAPTURE_SUPPORT =168 , +WMI_TLV_SERVICE_CFR_CAPTURE_IND_MSG_TYPE_1 =169 , +WMI_TLV_SERVICE_ESP_SUPPORT =170 , +WMI_TLV_SERVICE_PEER_CHWIDTH_CHANGE =171 , +WMI_TLV_SERVICE_WLAN_HPCS_PULSE =172 , +WMI_TLV_SERVICE_PER_VDEV_CHAINMASK_CONFIG_SUPPORT =173 , +WMI_TLV_SERVICE_TX_DATA_MGMT_ACK_RSSI =174 , +WMI_TLV_SERVICE_NAN_DISABLE_SUPPORT =175 , +WMI_TLV_SERVICE_HTT_H2T_NO_HTC_HDR_LEN_IN_MSG_LEN =176 , + +WMI_MAX_EXT_SERVICE + +}; + +enum { +WMI_SMPS_FORCED_MODE_NONE =0 , +WMI_SMPS_FORCED_MODE_DISABLED , +WMI_SMPS_FORCED_MODE_STATIC , +WMI_SMPS_FORCED_MODE_DYNAMIC +}; + +#define WMI_TPC_CHAINMASK_CONFIG_BAND_2G 0 +#define WMI_TPC_CHAINMASK_CONFIG_BAND_5G 1 +#define WMI_NUM_SUPPORTED_BAND_MAX 2 + +#define WMI_PEER_MIMO_PS_STATE 0x1 +#define WMI_PEER_AMPDU 0x2 +#define WMI_PEER_AUTHORIZE 0x3 +#define WMI_PEER_CHWIDTH 0x4 +#define WMI_PEER_NSS 0x5 +#define WMI_PEER_USE_4ADDR 0x6 +#define WMI_PEER_MEMBERSHIP 0x7 +#define WMI_PEER_USERPOS 0x8 +#define WMI_PEER_CRIT_PROTO_HINT_ENABLED 0x9 +#define WMI_PEER_TX_FAIL_CNT_THR 0xA +#define WMI_PEER_SET_HW_RETRY_CTS2S 0xB +#define WMI_PEER_IBSS_ATIM_WINDOW_LENGTH 0xC +#define WMI_PEER_PHYMODE 0xD +#define WMI_PEER_USE_FIXED_PWR 0xE +#define WMI_PEER_PARAM_FIXED_RATE 0xF +#define WMI_PEER_SET_MU_WHITELIST 0x10 +#define WMI_PEER_SET_MAX_TX_RATE 0x11 +#define WMI_PEER_SET_MIN_TX_RATE 0x12 +#define WMI_PEER_SET_DEFAULT_ROUTING 0x13 + +/* slot time long */ +#define WMI_VDEV_SLOT_TIME_LONG 0x1 +/* slot time short */ +#define WMI_VDEV_SLOT_TIME_SHORT 0x2 +/* preablbe long */ +#define WMI_VDEV_PREAMBLE_LONG 0x1 +/* preablbe short */ +#define WMI_VDEV_PREAMBLE_SHORT 0x2 + +enum wmi_peer_smps_state { +WMI_PEER_SMPS_PS_NONE =0x0 , +WMI_PEER_SMPS_STATIC =0x1 , +WMI_PEER_SMPS_DYNAMIC =0x2 +}; + +enum wmi_peer_chwidth { +WMI_PEER_CHWIDTH_20MHZ =0 , +WMI_PEER_CHWIDTH_40MHZ =1 , +WMI_PEER_CHWIDTH_80MHZ =2 , +WMI_PEER_CHWIDTH_160MHZ =3 , +}; + +enum wmi_beacon_gen_mode { +WMI_BEACON_STAGGERED_MODE =0 , +WMI_BEACON_BURST_MODE =1 +}; + +struct wmi_host_pdev_band_to_mac { +u32 pdev_id; +u32 start_freq; +u32 end_freq; +}; + +struct ath11k_ppe_threshold { +u32 numss_m1; +u32 ru_bit_mask; +u32 ppet16_ppet8_ru3_ru0[PSOC_HOST_MAX_NUM_SS ]; +}; + +struct ath11k_service_ext_param { +u32 default_conc_scan_config_bits; +u32 default_fw_config_bits; +struct ath11k_ppe_threshold ppet; +u32 he_cap_info; +u32 mpdu_density; +u32 max_bssid_rx_filters; +u32 num_hw_modes; +u32 num_phy; +}; + +struct ath11k_hw_mode_caps { +u32 hw_mode_id; +u32 phy_id_map; +u32 hw_mode_config_type; +}; + +#define PSOC_HOST_MAX_PHY_SIZE (3) +#define ATH11K_11B_SUPPORT BIT(0) +#define ATH11K_11G_SUPPORT BIT(1) +#define ATH11K_11A_SUPPORT BIT(2) +#define ATH11K_11N_SUPPORT BIT(3) +#define ATH11K_11AC_SUPPORT BIT(4) +#define ATH11K_11AX_SUPPORT BIT(5) + +struct ath11k_hal_reg_capabilities_ext { +u32 phy_id; +u32 eeprom_reg_domain; +u32 eeprom_reg_domain_ext; +u32 regcap1; +u32 regcap2; +u32 wireless_modes; +u32 low_2ghz_chan; +u32 high_2ghz_chan; +u32 low_5ghz_chan; +u32 high_5ghz_chan; +}; + +#define WMI_HOST_MAX_PDEV 3 + +struct wlan_host_mem_chunk { +u32 tlv_header; +u32 req_id; +u32 ptr; +u32 size; +} __packed; + +struct wmi_host_mem_chunk { +void *vaddr; +dma_addr_t paddr; +u32 len; +u32 req_id; +}; + +struct wmi_init_cmd_param { +u32 tlv_header; +struct target_resource_config *res_cfg; +u8 num_mem_chunks; +struct wmi_host_mem_chunk *mem_chunks; +u32 hw_mode_id; +u32 num_band_to_mac; +struct wmi_host_pdev_band_to_mac band_to_mac[WMI_HOST_MAX_PDEV ]; +}; + +struct wmi_pdev_band_to_mac { +u32 tlv_header; +u32 pdev_id; +u32 start_freq; +u32 end_freq; +} __packed; + +struct wmi_pdev_set_hw_mode_cmd_param { +u32 tlv_header; +u32 pdev_id; +u32 hw_mode_index; +u32 num_band_to_mac; +} __packed; + +struct wmi_ppe_threshold { +u32 numss_m1;/** NSS - 1*/ +union { +u32 ru_count; +u32 ru_mask; + } __packed; +u32 ppet16_ppet8_ru3_ru0[WMI_MAX_NUM_SS ]; +} __packed; + +#define HW_BD_INFO_SIZE 5 + +struct wmi_abi_version { +u32 abi_version_0; +u32 abi_version_1; +u32 abi_version_ns_0; +u32 abi_version_ns_1; +u32 abi_version_ns_2; +u32 abi_version_ns_3; +} __packed; + +struct wmi_init_cmd { +u32 tlv_header; +struct wmi_abi_version host_abi_vers; +u32 num_host_mem_chunks; +} __packed; + +struct wmi_resource_config { +u32 tlv_header; +u32 num_vdevs; +u32 num_peers; +u32 num_offload_peers; +u32 num_offload_reorder_buffs; +u32 num_peer_keys; +u32 num_tids; +u32 ast_skid_limit; +u32 tx_chain_mask; +u32 rx_chain_mask; +u32 rx_timeout_pri[4 ]; +u32 rx_decap_mode; +u32 scan_max_pending_req; +u32 bmiss_offload_max_vdev; +u32 roam_offload_max_vdev; +u32 roam_offload_max_ap_profiles; +u32 num_mcast_groups; +u32 num_mcast_table_elems; +u32 mcast2ucast_mode; +u32 tx_dbg_log_size; +u32 num_wds_entries; +u32 dma_burst_size; +u32 mac_aggr_delim; +u32 rx_skip_defrag_timeout_dup_detection_check; +u32 vow_config; +u32 gtk_offload_max_vdev; +u32 num_msdu_desc; +u32 max_frag_entries; +u32 num_tdls_vdevs; +u32 num_tdls_conn_table_entries; +u32 beacon_tx_offload_max_vdev; +u32 num_multicast_filter_entries; +u32 num_wow_filters; +u32 num_keep_alive_pattern; +u32 keep_alive_pattern_size; +u32 max_tdls_concurrent_sleep_sta; +u32 max_tdls_concurrent_buffer_sta; +u32 wmi_send_separate; +u32 num_ocb_vdevs; +u32 num_ocb_channels; +u32 num_ocb_schedules; +u32 flag1; +u32 smart_ant_cap; +u32 bk_minfree; +u32 be_minfree; +u32 vi_minfree; +u32 vo_minfree; +u32 alloc_frag_desc_for_data_pkt; +u32 num_ns_ext_tuples_cfg; +u32 bpf_instruction_size; +u32 max_bssid_rx_filters; +u32 use_pdev_id; +u32 max_num_dbs_scan_duty_cycle; +u32 max_num_group_keys; +u32 peer_map_unmap_v2_support; +} __packed; + +struct wmi_service_ready_event { +u32 fw_build_vers; +struct wmi_abi_version fw_abi_vers; +u32 phy_capability; +u32 max_frag_entry; +u32 num_rf_chains; +u32 ht_cap_info; +u32 vht_cap_info; +u32 vht_supp_mcs; +u32 hw_min_tx_power; +u32 hw_max_tx_power; +u32 sys_cap_info; +u32 min_pkt_size_enable; +u32 max_bcn_ie_size; +u32 num_mem_reqs; +u32 max_num_scan_channels; +u32 hw_bd_id; +u32 hw_bd_info[HW_BD_INFO_SIZE ]; +u32 max_supported_macs; +u32 wmi_fw_sub_feat_caps; +u32 num_dbs_hw_modes; +/* txrx_chainmask +* [7:0] - 2G band tx chain mask +* [15:8] - 2G band rx chain mask +* [23:16] - 5G band tx chain mask +* [31:24] - 5G band rx chain mask +*/ +u32 txrx_chainmask; +u32 default_dbs_hw_mode_index; +u32 num_msdu_desc; +} __packed; + +#define WMI_SERVICE_BM_SIZE ((WMI_MAX_SERVICE + sizeof(u32) - 1) / sizeof(u32)) + +#define WMI_SERVICE_SEGMENT_BM_SIZE32 4/* 4x u32 = 128 bits */ +#define WMI_SERVICE_EXT_BM_SIZE (WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(u32)) +#define WMI_AVAIL_SERVICE_BITS_IN_SIZE32 32 +#define WMI_SERVICE_BITS_IN_SIZE32 4 + +struct wmi_service_ready_ext_event { +u32 default_conc_scan_config_bits; +u32 default_fw_config_bits; +struct wmi_ppe_threshold ppet; +u32 he_cap_info; +u32 mpdu_density; +u32 max_bssid_rx_filters; +u32 fw_build_vers_ext; +u32 max_nlo_ssids; +u32 max_bssid_indicator; +u32 he_cap_info_ext; +} __packed; + +struct wmi_soc_mac_phy_hw_mode_caps { +u32 num_hw_modes; +u32 num_chainmask_tables; +} __packed; + +struct wmi_hw_mode_capabilities { +u32 tlv_header; +u32 hw_mode_id; +u32 phy_id_map; +u32 hw_mode_config_type; +} __packed; + +#define WMI_MAX_HECAP_PHY_SIZE (3) + +struct wmi_mac_phy_capabilities { +u32 tlv_header; +u32 hw_mode_id; +u32 pdev_id; +u32 phy_id; +u32 supported_flags; +u32 supported_bands; +u32 ampdu_density; +u32 max_bw_supported_2g; +u32 ht_cap_info_2g; +u32 vht_cap_info_2g; +u32 vht_supp_mcs_2g; +u32 he_cap_info_2g; +u32 he_supp_mcs_2g; +u32 tx_chain_mask_2g; +u32 rx_chain_mask_2g; +u32 max_bw_supported_5g; +u32 ht_cap_info_5g; +u32 vht_cap_info_5g; +u32 vht_supp_mcs_5g; +u32 he_cap_info_5g; +u32 he_supp_mcs_5g; +u32 tx_chain_mask_5g; +u32 rx_chain_mask_5g; +u32 he_cap_phy_info_2g[WMI_MAX_HECAP_PHY_SIZE ]; +u32 he_cap_phy_info_5g[WMI_MAX_HECAP_PHY_SIZE ]; +struct wmi_ppe_threshold he_ppet2g; +struct wmi_ppe_threshold he_ppet5g; +u32 chainmask_table_id; +u32 lmac_id; +u32 he_cap_info_2g_ext; +u32 he_cap_info_5g_ext; +u32 he_cap_info_internal; +} __packed; + +struct wmi_hal_reg_capabilities_ext { +u32 tlv_header; +u32 phy_id; +u32 eeprom_reg_domain; +u32 eeprom_reg_domain_ext; +u32 regcap1; +u32 regcap2; +u32 wireless_modes; +u32 low_2ghz_chan; +u32 high_2ghz_chan; +u32 low_5ghz_chan; +u32 high_5ghz_chan; +} __packed; + +struct wmi_soc_hal_reg_capabilities { +u32 num_phy; +} __packed; + +/* 2 word representation of MAC addr */ +struct wmi_mac_addr { +union { +u8 addr[6 ]; +struct { +u32 word0; +u32 word1; + } __packed; + } __packed; +} __packed; + +struct wmi_ready_event { +struct wmi_abi_version fw_abi_vers; +struct wmi_mac_addr mac_addr; +u32 status; +u32 num_dscp_table; +u32 num_extra_mac_addr; +u32 num_total_peers; +u32 num_extra_peers; +} __packed; + +struct wmi_service_available_event { +u32 wmi_service_segment_offset; +u32 wmi_service_segment_bitmap[WMI_SERVICE_SEGMENT_BM_SIZE32 ]; +} __packed; + +struct ath11k_pdev_wmi { +struct ath11k_wmi_base *wmi_sc; +enum ath11k_htc_ep_id eid; +const struct wmi_peer_flags_map *peer_flags; +u32 rx_decap_mode; +}; + +struct vdev_create_params { +u8 if_id; +u32 type; +u32 subtype; +struct { +u8 tx; +u8 rx; + } chains[NUM_NL80211_BANDS ]; +u32 pdev_id; +}; + +struct wmi_vdev_create_cmd { +u32 tlv_header; +u32 vdev_id; +u32 vdev_type; +u32 vdev_subtype; +struct wmi_mac_addr vdev_macaddr; +u32 num_cfg_txrx_streams; +u32 pdev_id; +} __packed; + +struct wmi_vdev_txrx_streams { +u32 tlv_header; +u32 band; +u32 supported_tx_streams; +u32 supported_rx_streams; +} __packed; + +struct wmi_vdev_delete_cmd { +u32 tlv_header; +u32 vdev_id; +} __packed; + +struct wmi_vdev_up_cmd { +u32 tlv_header; +u32 vdev_id; +u32 vdev_assoc_id; +struct wmi_mac_addr vdev_bssid; +struct wmi_mac_addr trans_bssid; +u32 profile_idx; +u32 profile_num; +} __packed; + +struct wmi_vdev_stop_cmd { +u32 tlv_header; +u32 vdev_id; +} __packed; + +struct wmi_vdev_down_cmd { +u32 tlv_header; +u32 vdev_id; +} __packed; + +#define WMI_VDEV_START_HIDDEN_SSID BIT(0) +#define WMI_VDEV_START_PMF_ENABLED BIT(1) +#define WMI_VDEV_START_LDPC_RX_ENABLED BIT(3) + +struct wmi_ssid { +u32 ssid_len; +u32 ssid[8 ]; +} __packed; + +#define ATH11K_VDEV_SETUP_TIMEOUT_HZ (1 * HZ) + +struct wmi_vdev_start_request_cmd { +u32 tlv_header; +u32 vdev_id; +u32 requestor_id; +u32 beacon_interval; +u32 dtim_period; +u32 flags; +struct wmi_ssid ssid; +u32 bcn_tx_rate; +u32 bcn_txpower; +u32 num_noa_descriptors; +u32 disable_hw_ack; +u32 preferred_tx_streams; +u32 preferred_rx_streams; +u32 he_ops; +u32 cac_duration_ms; +u32 regdomain; +} __packed; + +#define MGMT_TX_DL_FRM_LEN 64 +#define WMI_MAC_MAX_SSID_LENGTH 32 +struct mac_ssid { +u8 length; +u8 mac_ssid[WMI_MAC_MAX_SSID_LENGTH ]; +} __packed; + +struct wmi_p2p_noa_descriptor { +u32 type_count; +u32 duration; +u32 interval; +u32 start_time; +}; + +struct channel_param { +u8 chan_id; +u8 pwr; +u32 mhz; +u32 half_rate:1 , + quarter_rate:1 , + dfs_set:1 , + dfs_set_cfreq2:1 , + is_chan_passive:1 , + allow_ht:1 , + allow_vht:1 , + set_agile:1 ; +u32 phy_mode; +u32 cfreq1; +u32 cfreq2; +char maxpower; +char minpower; +char maxregpower; +u8 antennamax; +u8 reg_class_id; +} __packed; + +enum wmi_phy_mode { +MODE_11A =0 , +MODE_11G =1 ,/* 11b/g Mode */ +MODE_11B =2 ,/* 11b Mode */ +MODE_11GONLY =3 ,/* 11g only Mode */ +MODE_11NA_HT20 =4 , +MODE_11NG_HT20 =5 , +MODE_11NA_HT40 =6 , +MODE_11NG_HT40 =7 , +MODE_11AC_VHT20 =8 , +MODE_11AC_VHT40 =9 , +MODE_11AC_VHT80 =10 , +MODE_11AC_VHT20_2G =11 , +MODE_11AC_VHT40_2G =12 , +MODE_11AC_VHT80_2G =13 , +MODE_11AC_VHT80_80 =14 , +MODE_11AC_VHT160 =15 , +MODE_11AX_HE20 =16 , +MODE_11AX_HE40 =17 , +MODE_11AX_HE80 =18 , +MODE_11AX_HE80_80 =19 , +MODE_11AX_HE160 =20 , +MODE_11AX_HE20_2G =21 , +MODE_11AX_HE40_2G =22 , +MODE_11AX_HE80_2G =23 , +MODE_UNKNOWN =24 , +MODE_MAX =24 +}; + +static inline const char *ath11k_wmi_phymode_str (enum wmi_phy_mode mode) +{ +switch (mode) { +case MODE_11A : +return "11a" ; +case MODE_11G : +return "11g" ; +case MODE_11B : +return "11b" ; +case MODE_11GONLY : +return "11gonly" ; +case MODE_11NA_HT20 : +return "11na-ht20" ; +case MODE_11NG_HT20 : +return "11ng-ht20" ; +case MODE_11NA_HT40 : +return "11na-ht40" ; +case MODE_11NG_HT40 : +return "11ng-ht40" ; +case MODE_11AC_VHT20 : +return "11ac-vht20" ; +case MODE_11AC_VHT40 : +return "11ac-vht40" ; +case MODE_11AC_VHT80 : +return "11ac-vht80" ; +case MODE_11AC_VHT160 : +return "11ac-vht160" ; +case MODE_11AC_VHT80_80 : +return "11ac-vht80+80" ; +case MODE_11AC_VHT20_2G : +return "11ac-vht20-2g" ; +case MODE_11AC_VHT40_2G : +return "11ac-vht40-2g" ; +case MODE_11AC_VHT80_2G : +return "11ac-vht80-2g" ; +case MODE_11AX_HE20 : +return "11ax-he20" ; +case MODE_11AX_HE40 : +return "11ax-he40" ; +case MODE_11AX_HE80 : +return "11ax-he80" ; +case MODE_11AX_HE80_80 : +return "11ax-he80+80" ; +case MODE_11AX_HE160 : +return "11ax-he160" ; +case MODE_11AX_HE20_2G : +return "11ax-he20-2g" ; +case MODE_11AX_HE40_2G : +return "11ax-he40-2g" ; +case MODE_11AX_HE80_2G : +return "11ax-he80-2g" ; +case MODE_UNKNOWN : +/* skip */ +break ; + +/* no default handler to allow compiler to check that the +* enum is fully handled +*/ + }; + +return "<unknown>" ; +} + +struct wmi_channel_arg { +u32 freq; +u32 band_center_freq1; +u32 band_center_freq2; +bool passive; +bool allow_ibss; +bool allow_ht; +bool allow_vht; +bool ht40plus; +bool chan_radar; +bool freq2_radar; +bool allow_he; +u32 min_power; +u32 max_power; +u32 max_reg_power; +u32 max_antenna_gain; +enum wmi_phy_mode mode; +}; + +struct wmi_vdev_start_req_arg { +u32 vdev_id; +struct wmi_channel_arg channel; +u32 bcn_intval; +u32 dtim_period; +u8 *ssid; +u32 ssid_len; +u32 bcn_tx_rate; +u32 bcn_tx_power; +bool disable_hw_ack; +bool hidden_ssid; +bool pmf_enabled; +u32 he_ops; +u32 cac_duration_ms; +u32 regdomain; +u32 pref_rx_streams; +u32 pref_tx_streams; +u32 num_noa_descriptors; +}; + +struct peer_create_params { +const u8 *peer_addr; +u32 peer_type; +u32 vdev_id; +}; + +struct peer_delete_params { +u8 vdev_id; +}; + +struct peer_flush_params { +u32 peer_tid_bitmap; +u8 vdev_id; +}; + +struct pdev_set_regdomain_params { +u16 current_rd_in_use; +u16 current_rd_2g; +u16 current_rd_5g; +u32 ctl_2g; +u32 ctl_5g; +u8 dfs_domain; +u32 pdev_id; +}; + +struct rx_reorder_queue_remove_params { +u8 *peer_macaddr; +u16 vdev_id; +u32 peer_tid_bitmap; +}; + +#define WMI_HOST_PDEV_ID_SOC 0xFF +#define WMI_HOST_PDEV_ID_0 0 +#define WMI_HOST_PDEV_ID_1 1 +#define WMI_HOST_PDEV_ID_2 2 + +#define WMI_PDEV_ID_SOC 0 +#define WMI_PDEV_ID_1ST 1 +#define WMI_PDEV_ID_2ND 2 +#define WMI_PDEV_ID_3RD 3 + +/* Freq units in MHz */ +#define REG_RULE_START_FREQ 0x0000ffff +#define REG_RULE_END_FREQ 0xffff0000 +#define REG_RULE_FLAGS 0x0000ffff +#define REG_RULE_MAX_BW 0x0000ffff +#define REG_RULE_REG_PWR 0x00ff0000 +#define REG_RULE_ANT_GAIN 0xff000000 + +#define WMI_VDEV_PARAM_TXBF_SU_TX_BFEE BIT(0) +#define WMI_VDEV_PARAM_TXBF_MU_TX_BFEE BIT(1) +#define WMI_VDEV_PARAM_TXBF_SU_TX_BFER BIT(2) +#define WMI_VDEV_PARAM_TXBF_MU_TX_BFER BIT(3) + +#define HECAP_PHYDWORD_0 0 +#define HECAP_PHYDWORD_1 1 +#define HECAP_PHYDWORD_2 2 + +#define HECAP_PHY_SU_BFER BIT(31) +#define HECAP_PHY_SU_BFEE BIT(0) +#define HECAP_PHY_MU_BFER BIT(1) +#define HECAP_PHY_UL_MUMIMO BIT(22) +#define HECAP_PHY_UL_MUOFDMA BIT(23) + +#define HECAP_PHY_SUBFMR_GET (hecap_phy) \ + FIELD_GET(HECAP_PHY_SU_BFER, hecap_phy[HECAP_PHYDWORD_0]) + +#define HECAP_PHY_SUBFME_GET (hecap_phy) \ + FIELD_GET(HECAP_PHY_SU_BFEE, hecap_phy[HECAP_PHYDWORD_1]) + +#define HECAP_PHY_MUBFMR_GET (hecap_phy) \ + FIELD_GET(HECAP_PHY_MU_BFER, hecap_phy[HECAP_PHYDWORD_1]) + +#define HECAP_PHY_ULMUMIMO_GET (hecap_phy) \ + FIELD_GET(HECAP_PHY_UL_MUMIMO, hecap_phy[HECAP_PHYDWORD_0]) + +#define HECAP_PHY_ULOFDMA_GET (hecap_phy) \ + FIELD_GET(HECAP_PHY_UL_MUOFDMA, hecap_phy[HECAP_PHYDWORD_0]) + +#define HE_MODE_SU_TX_BFEE BIT(0) +#define HE_MODE_SU_TX_BFER BIT(1) +#define HE_MODE_MU_TX_BFEE BIT(2) +#define HE_MODE_MU_TX_BFER BIT(3) +#define HE_MODE_DL_OFDMA BIT(4) +#define HE_MODE_UL_OFDMA BIT(5) +#define HE_MODE_UL_MUMIMO BIT(6) + +#define HE_DL_MUOFDMA_ENABLE 1 +#define HE_UL_MUOFDMA_ENABLE 1 +#define HE_DL_MUMIMO_ENABLE 1 +#define HE_MU_BFEE_ENABLE 1 +#define HE_SU_BFEE_ENABLE 1 + +#define HE_VHT_SOUNDING_MODE_ENABLE 1 +#define HE_SU_MU_SOUNDING_MODE_ENABLE 1 +#define HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE 1 + +/* HE or VHT Sounding */ +#define HE_VHT_SOUNDING_MODE BIT(0) +/* SU or MU Sounding */ +#define HE_SU_MU_SOUNDING_MODE BIT(2) +/* Trig or Non-Trig Sounding */ +#define HE_TRIG_NONTRIG_SOUNDING_MODE BIT(3) + +#define WMI_TXBF_STS_CAP_OFFSET_LSB 4 +#define WMI_TXBF_STS_CAP_OFFSET_MASK 0x70 +#define WMI_BF_SOUND_DIM_OFFSET_LSB 8 +#define WMI_BF_SOUND_DIM_OFFSET_MASK 0x700 + +struct pdev_params { +u32 param_id; +u32 param_value; +}; + +enum wmi_peer_type { +WMI_PEER_TYPE_DEFAULT =0 , +WMI_PEER_TYPE_BSS =1 , +WMI_PEER_TYPE_TDLS =2 , +}; + +struct wmi_peer_create_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +u32 peer_type; +} __packed; + +struct wmi_peer_delete_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +} __packed; + +struct wmi_peer_reorder_queue_setup_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +u32 tid; +u32 queue_ptr_lo; +u32 queue_ptr_hi; +u32 queue_no; +u32 ba_window_size_valid; +u32 ba_window_size; +} __packed; + +struct wmi_peer_reorder_queue_remove_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +u32 tid_mask; +} __packed; + +struct gpio_config_params { +u32 gpio_num; +u32 input; +u32 pull_type; +u32 intr_mode; +}; + +enum wmi_gpio_type { +WMI_GPIO_PULL_NONE , +WMI_GPIO_PULL_UP , +WMI_GPIO_PULL_DOWN +}; + +enum wmi_gpio_intr_type { +WMI_GPIO_INTTYPE_DISABLE , +WMI_GPIO_INTTYPE_RISING_EDGE , +WMI_GPIO_INTTYPE_FALLING_EDGE , +WMI_GPIO_INTTYPE_BOTH_EDGE , +WMI_GPIO_INTTYPE_LEVEL_LOW , +WMI_GPIO_INTTYPE_LEVEL_HIGH +}; + +enum wmi_bss_chan_info_req_type { +WMI_BSS_SURVEY_REQ_TYPE_READ =1 , +WMI_BSS_SURVEY_REQ_TYPE_READ_CLEAR , +}; + +struct wmi_gpio_config_cmd_param { +u32 tlv_header; +u32 gpio_num; +u32 input; +u32 pull_type; +u32 intr_mode; +}; + +struct gpio_output_params { +u32 gpio_num; +u32 set; +}; + +struct wmi_gpio_output_cmd_param { +u32 tlv_header; +u32 gpio_num; +u32 set; +}; + +struct set_fwtest_params { +u32 arg; +u32 value; +}; + +struct wmi_fwtest_set_param_cmd_param { +u32 tlv_header; +u32 param_id; +u32 param_value; +}; + +struct wmi_pdev_set_param_cmd { +u32 tlv_header; +u32 pdev_id; +u32 param_id; +u32 param_value; +} __packed; + +struct wmi_pdev_suspend_cmd { +u32 tlv_header; +u32 pdev_id; +u32 suspend_opt; +} __packed; + +struct wmi_pdev_resume_cmd { +u32 tlv_header; +u32 pdev_id; +} __packed; + +struct wmi_pdev_bss_chan_info_req_cmd { +u32 tlv_header; +/* ref wmi_bss_chan_info_req_type */ +u32 req_type; +} __packed; + +struct wmi_ap_ps_peer_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +u32 param; +u32 value; +} __packed; + +struct wmi_sta_powersave_param_cmd { +u32 tlv_header; +u32 vdev_id; +u32 param; +u32 value; +} __packed; + +struct wmi_pdev_set_regdomain_cmd { +u32 tlv_header; +u32 pdev_id; +u32 reg_domain; +u32 reg_domain_2g; +u32 reg_domain_5g; +u32 conformance_test_limit_2g; +u32 conformance_test_limit_5g; +u32 dfs_domain; +} __packed; + +struct wmi_peer_set_param_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +u32 param_id; +u32 param_value; +} __packed; + +struct wmi_peer_flush_tids_cmd { +u32 tlv_header; +u32 vdev_id; +struct wmi_mac_addr peer_macaddr; +u32 peer_tid_bitmap; +} __packed; + +struct wmi_dfs_phyerr_offload_cmd { +u32 tlv_header; +u32 pdev_id; +} __packed; + +struct wmi_bcn_offload_ctrl_cmd { +u32 tlv_header; +u32 vdev_id; +u32 bcn_ctrl_op; +} __packed; + +enum scan_priority { +SCAN_PRIORITY_VERY_LOW , +SCAN_PRIORITY_LOW , +SCAN_PRIORITY_MEDIUM , +SCAN_PRIORITY_HIGH , +SCAN_PRIORITY_VERY_HIGH , +SCAN_PRIORITY_COUNT , +}; + +enum scan_dwelltime_adaptive_mode { +SCAN_DWELL_MODE_DEFAULT =0 , +SCAN_DWELL_MODE_CONSERVATIVE =1 , +SCAN_DWELL_MODE_MODERATE =2 , +SCAN_DWELL_MODE_AGGRESSIVE =3 , +SCAN_DWELL_MODE_STATIC =4 +}; + +#define WLAN_SCAN_MAX_NUM_SSID 10 +#define WLAN_SCAN_MAX_NUM_BSSID 10 +#define WLAN_SCAN_MAX_NUM_CHANNELS 40 + +#define WLAN_SSID_MAX_LEN 32 + +struct element_info { +u32 len; +u8 *ptr; +}; + +struct wlan_ssid { +u8 length; +u8 ssid[WLAN_SSID_MAX_LEN ]; +}; + +#define WMI_IE_BITMAP_SIZE 8 + +#define WMI_SCAN_MAX_NUM_SSID 0x0A +/* prefix used by scan requestor ids on the host */ +#define WMI_HOST_SCAN_REQUESTOR_ID_PREFIX 0xA000 + +/* prefix used by scan request ids generated on the host */ +/* host cycles through the lower 12 bits to generate ids */ +#define WMI_HOST_SCAN_REQ_ID_PREFIX 0xA000 + +#define WLAN_SCAN_PARAMS_MAX_SSID 16 +#define WLAN_SCAN_PARAMS_MAX_BSSID 4 +#define WLAN_SCAN_PARAMS_MAX_IE_LEN 256 + +/* Values lower than this may be refused by some firmware revisions with a scan +* completion with a timedout reason. +*/ +#define WMI_SCAN_CHAN_MIN_TIME_MSEC 40 + +/* Scan priority numbers must be sequential, starting with 0 */ +enum wmi_scan_priority { +WMI_SCAN_PRIORITY_VERY_LOW =0 , +WMI_SCAN_PRIORITY_LOW , +WMI_SCAN_PRIORITY_MEDIUM , +WMI_SCAN_PRIORITY_HIGH , +WMI_SCAN_PRIORITY_VERY_HIGH , +WMI_SCAN_PRIORITY_COUNT /* number of priorities supported */ +}; + +enum wmi_scan_event_type { +WMI_SCAN_EVENT_STARTED =BIT (0 ), +WMI_SCAN_EVENT_COMPLETED =BIT (1 ), +WMI_SCAN_EVENT_BSS_CHANNEL =BIT (2 ), +WMI_SCAN_EVENT_FOREIGN_CHAN =BIT (3 ), +WMI_SCAN_EVENT_DEQUEUED =BIT (4 ), +/* possibly by high-prio scan */ +WMI_SCAN_EVENT_PREEMPTED =BIT (5 ), +WMI_SCAN_EVENT_START_FAILED =BIT (6 ), +WMI_SCAN_EVENT_RESTARTED =BIT (7 ), +WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT =BIT (8 ), +WMI_SCAN_EVENT_SUSPENDED =BIT (9 ), +WMI_SCAN_EVENT_RESUMED =BIT (10 ), +WMI_SCAN_EVENT_MAX =BIT (15 ), +}; + +enum wmi_scan_completion_reason { +WMI_SCAN_REASON_COMPLETED , +WMI_SCAN_REASON_CANCELLED , +WMI_SCAN_REASON_PREEMPTED , +WMI_SCAN_REASON_TIMEDOUT , +WMI_SCAN_REASON_INTERNAL_FAILURE , +WMI_SCAN_REASON_MAX , +}; + +struct wmi_start_scan_cmd { +u32 tlv_header; +u32 scan_id; +u32 scan_req_id; +u32 vdev_id; +u32 scan_priority; +u32 notify_scan_events; +u32 dwell_time_active; +u32 dwell_time_passive; +u32 min_rest_time; +u32 max_rest_time; +u32 repeat_probe_time; +u32 probe_spacing_time; +u32 idle_time; +u32 max_scan_time; +u32 probe_delay; +u32 scan_ctrl_flags; +u32 burst_duration; +u32 num_chan; +u32 num_bssid; +u32 num_ssids; +u32 ie_len; +u32 n_probes; +struct wmi_mac_addr mac_addr; +struct wmi_mac_addr mac_mask; +u32 ie_bitmap[WMI_IE_BITMAP_SIZE ]; +u32 num_vendor_oui; +u32 scan_ctrl_flags_ext; +u32 dwell_time_active_2g; +} __packed; + +#define WMI_SCAN_FLAG_PASSIVE 0x1 +#define WMI_SCAN_ADD_BCAST_PROBE_REQ 0x2 +#define WMI_SCAN_ADD_CCK_RATES 0x4 +#define WMI_SCAN_ADD_OFDM_RATES 0x8 +#define WMI_SCAN_CHAN_STAT_EVENT 0x10 +#define WMI_SCAN_FILTER_PROBE_REQ 0x20 +#define WMI_SCAN_BYPASS_DFS_CHN 0x40 +#define WMI_SCAN_CONTINUE_ON_ERROR 0x80 +#define WMI_SCAN_FILTER_PROMISCUOS 0x100 +#define WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS 0x200 +#define WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ 0x400 +#define WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ 0x800 +#define WMI_SCAN_ADD_SPOOF_MAC_IN_PROBE_REQ 0x1000 +#define WMI_SCAN_OFFCHAN_MGMT_TX 0x2000 +#define WMI_SCAN_OFFCHAN_DATA_TX 0x4000 +#define WMI_SCAN_CAPTURE_PHY_ERROR 0x8000 +#define WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN 0x10000 +#define WMI_SCAN_FLAG_HALF_RATE_SUPPORT 0x20000 +#define WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT 0x40000
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
Part of the diff is not shown here. View the raw message.
PATCH v3 47/49 ath: add ath11k to Makefile
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/Makefile | 1 + 1 file changed, 1 insertion(+)
drivers/net/wireless/ath/Makefile +1 -0
@@ -7,6 +7,7 @@ obj-$(CONFIG_AR5523) += ar5523/ obj-$(CONFIG_WIL6210) += wil6210/ obj-$(CONFIG_ATH10K) += ath10k/ obj-$(CONFIG_WCN36XX) += wcn36xx/ +obj-$(CONFIG_ATH11K) += ath11k/ obj-$(CONFIG_ATH_COMMON) += ath.o
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
PATCH v3 48/49 ath: add ath11k to Kconfig
In reply to Kalle Valo(patches split for easier review, see the cover letter for more)
--- drivers/net/wireless/ath/Kconfig | 1 + 1 file changed, 1 insertion(+)
drivers/net/wireless/ath/Kconfig +1 -0
@@ -61,5 +61,6 @@ source "drivers/net/wireless/ath/ar5523/Kconfig" source "drivers/net/wireless/ath/wil6210/Kconfig" source "drivers/net/wireless/ath/ath10k/Kconfig" source "drivers/net/wireless/ath/wcn36xx/Kconfig" +source "drivers/net/wireless/ath/ath11k/Kconfig" endif
PATCH v3 49/49 MAINTAINERS: add ath11k
In reply to Kalle ValoAdd an entry for ath11k to the MAINTAINERS file.
--- MAINTAINERS | 7 +++++++ 1 file changed, 7 insertions(+)
MAINTAINERS +7 -0
@@ -13028,6 +13028,13 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git S: Supported F: drivers/net/wireless/ath/ath10k/ +QUALCOMM ATHEROS ATH11K WIRELESS DRIVER +M: Kalle Valo <[email protected]> +L: [email protected] +T: git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git +S: Supported +F: drivers/net/wireless/ath/ath11k/ + QUALCOMM ATHEROS ATH9K WIRELESS DRIVER M: QCA ath9k Development <[email protected]> L: [email protected]
_______________________________________________
ath11k mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/ath11k
Quoted 16 lines · Kalle Valo
ath11k is a new driver for Qualcomm IEEE 802.11ax devices, first supporting only IPQ8074 SoC using the shared memory AHB bus. ath11k uses mac80211 and supports AP, Station and Mesh modes.
Even though ath11k has some similar code as with ath10k (especially the WMI layer) it was concluded to be simpler to have a "clean start" for ath11k code base and not try to share the code with ath10k. This makes maintenance easier and avoids major changes in ath10k, which would have significantly increased the risk of regressions in existing setups.
Even though the driver is very similar with ath10k but there are major differences as well. The datapath is completely different. ath11k supports multiple MACs, called "soc" in the firmware interface. And there's only one WMI interface to support.
Quoted 8 lines
Currently ath11k supports only IEEE 802.11ac mode, but patches for 802.11ax are available and they will be submitted after ath11k is accepted to upstream.
The firmware images are available from ath11k-firmware repository but they will be also submitted to linux-firmware:
I also added to the commit log the version which was used in testing:
WLAN.HK.2.1.0.1-00629-QCAHKSWPL_SILICONZ-1
Quoted 15 lines
--------------[cut]-------------------[cut]-----------------
I have split the driver into multiple patches for easier review, but the final version will be split into three commits:
1. adding
Documentatio/devicetree/bindings/net/wireless/qcom,ath11k.yaml2. adding
drivers/net/wireless/ath/ath11k/with the commit log being the text before the cut line above.3. adding ath11k entry to
MAINTAINERSfileThis version is based on commit
ad10d2ff619f0797cb102b2ff488429d3f8e4a8afrom ath11k-bringup branch on my ath.git tree:
Quoted 7 lines
https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git/log/?h=ath11k-bringup
This patchset applies to wireless-drivers-next but needs
CONFIG_COMPILE_TEST,CONFIG_REMOTEPROCANDCONFIG_QCOM_QMI_HELPERSto be able to compile on x86.Please review and comment.
I have now prepared the three commits and they are in the pending branch for build testing:
In the next few days I'll apply these to ath-next branch and queue for v5.6.
Signature · 6 lines
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches _______________________________________________ ath11k mailing list [email protected] http://lists.infradead.org/mailman/listinfo/ath11k
Quoted 16 lines · Kalle Valo
ath11k is a new driver for Qualcomm IEEE 802.11ax devices, first supporting only IPQ8074 SoC using the shared memory AHB bus. ath11k uses mac80211 and supports AP, Station and Mesh modes.
Even though ath11k has some similar code as with ath10k (especially the WMI layer) it was concluded to be simpler to have a "clean start" for ath11k code base and not try to share the code with ath10k. This makes maintenance easier and avoids major changes in ath10k, which would have significantly increased the risk of regressions in existing setups.
Even though the driver is very similar with ath10k but there are major differences as well. The datapath is completely different. ath11k supports multiple MACs, called "soc" in the firmware interface. And there's only one WMI interface to support.
Quoted 8 lines
Currently ath11k supports only IEEE 802.11ac mode, but patches for 802.11ax are available and they will be submitted after ath11k is accepted to upstream.
The firmware images are available from ath11k-firmware repository but they will be also submitted to linux-firmware:
I also added to the commit log the version which was used in testing:
WLAN.HK.2.1.0.1-00629-QCAHKSWPL_SILICONZ-1
Quoted 15 lines
--------------[cut]-------------------[cut]-----------------
I have split the driver into multiple patches for easier review, but the final version will be split into three commits:
1. adding
Documentatio/devicetree/bindings/net/wireless/qcom,ath11k.yaml2. adding
drivers/net/wireless/ath/ath11k/with the commit log being the text before the cut line above.3. adding ath11k entry to
MAINTAINERSfileThis version is based on commit
ad10d2ff619f0797cb102b2ff488429d3f8e4a8afrom ath11k-bringup branch on my ath.git tree:
Quoted 7 lines
https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git/log/?h=ath11k-bringup
This patchset applies to wireless-drivers-next but needs
CONFIG_COMPILE_TEST,CONFIG_REMOTEPROCANDCONFIG_QCOM_QMI_HELPERSto be able to compile on x86.Please review and comment.
I have now prepared the three commits and they are in the pending branch for build testing:
In the next few days I'll apply these to ath-next branch and queue for v5.6.
Signature · 1 line
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
Quoted 57 lines · Kalle Valo
Quoted 16 lines · Kalle Valo
ath11k is a new driver for Qualcomm IEEE 802.11ax devices, first supporting only IPQ8074 SoC using the shared memory AHB bus. ath11k uses mac80211 and supports AP, Station and Mesh modes.
Even though ath11k has some similar code as with ath10k (especially the WMI layer) it was concluded to be simpler to have a "clean start" for ath11k code base and not try to share the code with ath10k. This makes maintenance easier and avoids major changes in ath10k, which would have significantly increased the risk of regressions in existing setups.
Even though the driver is very similar with ath10k but there are major differences as well. The datapath is completely different. ath11k supports multiple MACs, called "soc" in the firmware interface. And there's only one WMI interface to support.
Quoted 8 lines
Currently ath11k supports only IEEE 802.11ac mode, but patches for 802.11ax are available and they will be submitted after ath11k is accepted to upstream.
The firmware images are available from ath11k-firmware repository but they will be also submitted to linux-firmware:
I also added to the commit log the version which was used in testing:
WLAN.HK.2.1.0.1-00629-QCAHKSWPL_SILICONZ-1
Quoted 15 lines
--------------[cut]-------------------[cut]-----------------
I have split the driver into multiple patches for easier review, but the final version will be split into three commits:
1. adding
Documentatio/devicetree/bindings/net/wireless/qcom,ath11k.yaml2. adding
drivers/net/wireless/ath/ath11k/with the commit log being the text before the cut line above.3. adding ath11k entry to
MAINTAINERSfileThis version is based on commit
ad10d2ff619f0797cb102b2ff488429d3f8e4a8afrom ath11k-bringup branch on my ath.git tree:Quoted 7 lines
https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git/log/?h=ath11k-bringup
This patchset applies to wireless-drivers-next but needs
CONFIG_COMPILE_TEST,CONFIG_REMOTEPROCANDCONFIG_QCOM_QMI_HELPERSto be able to compile on x86.Please review and comment.
I have now prepared the three commits and they are in the pending branch for build testing:
Quoted 7 lines
In the next few days I'll apply these to ath-next branch and queue for v5.6.
Manually applied to ath-next branch of my ath.git tree:
dae0978d4174 dt: bindings: net: add qcom,ath11k.yaml d5c65159f289 ath11k: driver for Qualcomm IEEE 802.11ax devices 02fdd85da2ce MAINTAINERS: add ath11k
Thanks everyone!
Signature · 1 line
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
Quoted 57 lines · Kalle Valo
Quoted 16 lines · Kalle Valo
ath11k is a new driver for Qualcomm IEEE 802.11ax devices, first supporting only IPQ8074 SoC using the shared memory AHB bus. ath11k uses mac80211 and supports AP, Station and Mesh modes.
Even though ath11k has some similar code as with ath10k (especially the WMI layer) it was concluded to be simpler to have a "clean start" for ath11k code base and not try to share the code with ath10k. This makes maintenance easier and avoids major changes in ath10k, which would have significantly increased the risk of regressions in existing setups.
Even though the driver is very similar with ath10k but there are major differences as well. The datapath is completely different. ath11k supports multiple MACs, called "soc" in the firmware interface. And there's only one WMI interface to support.
Quoted 8 lines
Currently ath11k supports only IEEE 802.11ac mode, but patches for 802.11ax are available and they will be submitted after ath11k is accepted to upstream.
The firmware images are available from ath11k-firmware repository but they will be also submitted to linux-firmware:
I also added to the commit log the version which was used in testing:
WLAN.HK.2.1.0.1-00629-QCAHKSWPL_SILICONZ-1
Quoted 15 lines
--------------[cut]-------------------[cut]-----------------
I have split the driver into multiple patches for easier review, but the final version will be split into three commits:
1. adding
Documentatio/devicetree/bindings/net/wireless/qcom,ath11k.yaml2. adding
drivers/net/wireless/ath/ath11k/with the commit log being the text before the cut line above.3. adding ath11k entry to
MAINTAINERSfileThis version is based on commit
ad10d2ff619f0797cb102b2ff488429d3f8e4a8afrom ath11k-bringup branch on my ath.git tree:Quoted 7 lines
https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git/log/?h=ath11k-bringup
This patchset applies to wireless-drivers-next but needs
CONFIG_COMPILE_TEST,CONFIG_REMOTEPROCANDCONFIG_QCOM_QMI_HELPERSto be able to compile on x86.Please review and comment.
I have now prepared the three commits and they are in the pending branch for build testing:
Quoted 7 lines
In the next few days I'll apply these to ath-next branch and queue for v5.6.
Manually applied to ath-next branch of my ath.git tree:
dae0978d4174 dt: bindings: net: add qcom,ath11k.yaml d5c65159f289 ath11k: driver for Qualcomm IEEE 802.11ax devices 02fdd85da2ce MAINTAINERS: add ath11k
Thanks everyone!
Signature · 6 lines
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches _______________________________________________ ath11k mailing list [email protected] http://lists.infradead.org/mailman/listinfo/ath11k