A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-13 08:07:32 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge "cnss2: Enable Support for WFC call TWT config"

Browse source
This commit is contained in:
qctecmdr 2020-05-06 23:50:33 -07:00 • committed by Gerrit - the friendly Code Review server
commit ef0a8ac3e8
7 changed files with 951 additions and 175 deletions
Download patch file Download diff file Expand all files Collapse all files

109
drivers/net/wireless/cnss2/debug.c
View file

@ -10,28 +10,10 @@
#include "pci.h"
#define MMIO_REG_ACCESS_MEM_TYPE 0xFF
#define HEX_DUMP_ROW_SIZE 16
void *cnss_ipc_log_context;
void *cnss_ipc_log_long_context;
static void cnss_print_hex_dump(const void *buf, int len)
{
const u8 *ptr = buf;
int i, linelen, remaining = len, rowsize = HEX_DUMP_ROW_SIZE;
unsigned char linebuf[HEX_DUMP_ROW_SIZE * 3 + 1];
for (i = 0; i < len; i += rowsize) {
linelen = min(remaining, rowsize);
remaining -= rowsize;
hex_dump_to_buffer(ptr + i, linelen, rowsize, 1,
linebuf, sizeof(linebuf), false);
cnss_pr_dbg("%.8x: %s\n", i, linebuf);
}
}
static int cnss_pin_connect_show(struct seq_file *s, void *data)
{
struct cnss_plat_data *cnss_priv = s->private;
@ -768,95 +750,6 @@ static const struct file_operations cnss_dynamic_feature_fops = {
.llseek = seq_lseek,
};
static int cnss_wfc_call_status_debug_show(struct seq_file *s, void *data)
{
seq_puts(s, "\nUsage: echo <data_len> <hex data> > <debugfs_path>/cnss/wfc_call_status\n");
seq_puts(s, "e.g. Send 4 bytes of hex data for WFC call status using QMI message:\n");
seq_puts(s, "echo '0x4 0xA 0xB 0xC 0xD' > /d/cnss/wfc_call_status\n");
return 0;
}
static ssize_t cnss_wfc_call_status_debug_write(struct file *fp,
const char __user *user_buf,
size_t count, loff_t *off)
{
struct cnss_plat_data *plat_priv =
((struct seq_file *)fp->private_data)->private;
char buf[(QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01 + 1) * 5];
char *sptr, *token;
unsigned int len = 0;
const char *delim = " ";
u32 data_len;
u8 data[QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01] = {0}, data_byte;
int ret = 0, i;
if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
cnss_pr_err("Firmware is not ready yet\n");
return -EINVAL;
}
len = min(count, sizeof(buf) - 1);
if (copy_from_user(buf, user_buf, len))
return -EFAULT;
buf[len] = '\0';
sptr = buf;
token = strsep(&sptr, delim);
if (!token || !sptr)
return -EINVAL;
if (kstrtou32(token, 0, &data_len))
return -EINVAL;
cnss_pr_dbg("Parsing 0x%x bytes data for WFC call status\n", data_len);
if (data_len > QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01 ||
data_len == 0) {
cnss_pr_err("Invalid data length 0x%x\n", data_len);
return -EINVAL;
}
for (i = 0; i < data_len; i++) {
token = strsep(&sptr, delim);
if (!token || (!sptr && i < data_len - 1)) {
cnss_pr_err("Input data is less than length\n");
return -EINVAL;
}
if (kstrtou8(token, 0, &data_byte)) {
cnss_pr_err("Data format is incorrect\n");
return -EINVAL;
}
data[i] = data_byte;
}
cnss_print_hex_dump(data, data_len);
ret = cnss_wlfw_wfc_call_status_send_sync(plat_priv, data_len, data);
if (ret)
return ret;
return count;
}
static int cnss_wfc_call_status_debug_open(struct inode *inode,
struct file *file)
{
return single_open(file, cnss_wfc_call_status_debug_show,
inode->i_private);
}
static const struct file_operations cnss_wfc_call_status_debug_fops = {
.read = seq_read,
.write = cnss_wfc_call_status_debug_write,
.open = cnss_wfc_call_status_debug_open,
.owner = THIS_MODULE,
.llseek = seq_lseek,
};
#ifdef CONFIG_CNSS2_DEBUG
static int cnss_create_debug_only_node(struct cnss_plat_data *plat_priv)
{
@ -874,8 +767,6 @@ static int cnss_create_debug_only_node(struct cnss_plat_data *plat_priv)
&cnss_control_params_debug_fops);
debugfs_create_file("dynamic_feature", 0600, root_dentry, plat_priv,
&cnss_dynamic_feature_fops);
debugfs_create_file("wfc_call_status", 0600, root_dentry, plat_priv,
&cnss_wfc_call_status_debug_fops);
return 0;
}

375
drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.c
View file

@ -1,10 +1,34 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2019, The Linux Foundation. All rights reserved. */
#include <linux/soc/qcom/qmi.h>
/* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. */
#include "ip_multimedia_subsystem_private_service_v01.h"
static struct qmi_elem_info ims_private_service_header_value_v01_ei[] = {
{
.data_type = QMI_STRING,
.elem_len = IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1,
.elem_size = sizeof(char),
.array_type = NO_ARRAY,
.tlv_type = 0,
.offset =
offsetof(struct ims_private_service_header_value_v01, header),
},
{
.data_type = QMI_STRING,
.elem_len = IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1,
.elem_size = sizeof(char),
.array_type = NO_ARRAY,
.tlv_type = 0,
.offset =
offsetof(struct ims_private_service_header_value_v01, value),
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};
struct qmi_elem_info
ims_private_service_subscribe_for_indications_req_msg_v01_ei[] = {
{
@ -74,16 +98,68 @@ ims_private_service_subscribe_for_indications_rsp_msg_v01_ei[] = {
},
};
struct qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[] = {
struct qmi_elem_info ims_private_service_mt_invite_ind_msg_v01_ei[] = {
{
.data_type = QMI_UNSIGNED_1_BYTE,
.data_type = QMI_SIGNED_4_BYTE_ENUM,
.elem_len = 1,
.elem_size = sizeof(enum ims_subscription_type_enum_v01),
.array_type = NO_ARRAY,
.tlv_type = 0x01,
.offset =
offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
subscription_type),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x01,
.offset = offsetof(struct
ims_private_service_wfc_call_status_ind_msg_v01,
wfc_call_active),
.tlv_type = 0x10,
.offset =
offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
iccid_valid),
},
{
.data_type = QMI_STRING,
.elem_len = IMS_PRIVATE_SERVICE_MAX_ICCID_LEN_V01 + 1,
.elem_size = sizeof(char),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset =
offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
iccid),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
header_value_list_valid),
},
{
.data_type = QMI_DATA_LEN,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
header_value_list_len),
},
{
.data_type = QMI_STRUCT,
.elem_len = IMS_PRIVATE_SERVICE_MAX_MT_INVITE_HEADERS_V01,
.elem_size =
sizeof(struct ims_private_service_header_value_v01),
.array_type = VAR_LEN_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct ims_private_service_mt_invite_ind_msg_v01,
header_value_list),
.ei_array = ims_private_service_header_value_v01_ei,
},
{
.data_type = QMI_EOTI,
@ -91,3 +167,284 @@ struct qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[] = {
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};
struct qmi_elem_info ims_private_service_wfc_call_status_ind_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 ims_private_service_wfc_call_status_ind_msg_v01,
wfc_call_active),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
all_wfc_calls_held_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
all_wfc_calls_held),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
is_wfc_emergency_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
is_wfc_emergency),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
twt_ims_start_valid),
},
{
.data_type = QMI_UNSIGNED_8_BYTE,
.elem_len = 1,
.elem_size = sizeof(u64),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
twt_ims_start),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
twt_ims_int_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
twt_ims_int),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
media_quality_valid),
},
{
.data_type = QMI_SIGNED_4_BYTE_ENUM,
.elem_len = 1,
.elem_size = sizeof(enum wfc_media_quality_v01),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset =
offsetof(struct ims_private_service_wfc_call_status_ind_msg_v01,
media_quality),
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};
struct qmi_elem_info
ims_private_service_wfc_call_twt_config_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
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_start_valid),
},
{
.data_type = QMI_UNSIGNED_8_BYTE,
.elem_len = 1,
.elem_size = sizeof(u64),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_start),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_int_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_int),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_upo_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_upo),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_sp_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_sp),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_dl_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_dl),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x15,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_config_changed_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x15,
.offset =
offsetof(struct
ims_private_service_wfc_call_twt_config_req_msg_v01,
twt_sta_config_changed),
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};
struct qmi_elem_info
ims_private_service_wfc_call_twt_config_rsp_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
ims_private_service_wfc_call_twt_config_rsp_msg_v01,
resp),
.ei_array = qmi_response_type_v01_ei,
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};

113
drivers/net/wireless/cnss2/ip_multimedia_subsystem_private_service_v01.h
View file

@ -1,17 +1,58 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2019, The Linux Foundation. All rights reserved. */
/* Copyright (c) 2020, The Linux Foundation. All rights reserved. */
#ifndef IP_MULTIMEDIA_SUBSYSTEM_PRIVATE_SERVICE_V01_H
#define IP_MULTIMEDIA_SUBSYSTEM_PRIVATE_SERVICE_V01_H
#include <linux/soc/qcom/qmi.h>
#define IMSPRIVATE_SERVICE_ID_V01 0x4D
#define IMSPRIVATE_SERVICE_VERS_V01 0x01
#define IMSPRIVATE_SERVICE_MAX_MSG_LEN 8
#define QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_RSP_V01 0x003E
#define QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01 0x003E
#define QMI_IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_V01 0x0040
#define QMI_IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_V01 0x003E
#define QMI_IMS_PRIVATE_SERVICE_MT_INVITE_IND_V01 0x003F
#define QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_RSP_V01 0x0041
#define QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_V01 0x0041
#define IMS_PRIVATE_SERVICE_MAX_MT_INVITE_HEADERS_V01 15
#define IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 1024
#define IMS_PRIVATE_SERVICE_MAX_ICCID_LEN_V01 21
enum ims_common_resp_enum_v01 {
IMS_COMMON_RESP_ENUM_MIN_VAL_V01 = INT_MIN,
IMS_COMMON_MSG_NO_ERR_V01 = 0,
IMS_COMMON_MSG_IMS_NOT_READY_V01 = 1,
IMS_COMMON_MSG_FILE_NOT_AVAILABLE_V01 = 2,
IMS_COMMON_MSG_READ_FAILED_V01 = 3,
IMS_COMMON_MSG_WRITE_FAILED_V01 = 4,
IMS_COMMON_MSG_OTHER_INTERNAL_ERR_V01 = 5,
IMS_COMMON_RESP_ENUM_MAX_VAL_V01 = INT_MAX,
};
enum ims_subscription_type_enum_v01 {
IMS_SUBSCRIPTION_TYPE_ENUM_MIN_VAL_V01 = INT_MIN,
IMS_SUBSCRIPTION_TYPE_NONE_V01 = -1,
IMS_SUBSCRIPTION_TYPE_PRIMARY_V01 = 0,
IMS_SUBSCRIPTION_TYPE_SECONDARY_V01 = 1,
IMS_SUBSCRIPTION_TYPE_TERTIARY_V01 = 2,
IMS_SUBSCRIPTION_TYPE_ENUM_MAX_VAL_V01 = INT_MAX,
};
enum wfc_media_quality_v01 {
WFC_MEDIA_QUALITY_MIN_VAL_V01 = INT_MIN,
WFC_MEDIA_QUAL_NOT_AVAILABLE_V01 = 0,
WFC_MEDIA_QUAL_BAD_V01 = 1,
WFC_MEDIA_QUAL_GOOD_V01 = 2,
WFC_MEDIA_QUAL_EXCELLENT_V01 = 3,
WFC_MEDIA_QUALITY_MAX_VAL_V01 = INT_MAX,
};
struct ims_private_service_header_value_v01 {
char header[IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1];
char value[IMS_PRIVATE_SERVICE_HEADER_STR_LEN_V01 + 1];
};
struct ims_private_service_subscribe_for_indications_req_msg_v01 {
u8 mt_invite_valid;
@ -21,23 +62,73 @@ struct ims_private_service_subscribe_for_indications_req_msg_v01 {
};
#define IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_REQ_MSG_V01_MAX_MSG_LEN 8
extern struct
qmi_elem_info ims_private_service_subscribe_for_indications_req_msg_v01_ei[];
extern struct qmi_elem_info
ims_private_service_subscribe_for_indications_req_msg_v01_ei[];
struct ims_private_service_subscribe_for_indications_rsp_msg_v01 {
struct qmi_response_type_v01 resp;
};
#define IMS_PRIVATE_SERVICE_SUBSCRIBE_FOR_INDICATIONS_RSP_MSG_V01_MAX_MSG_LEN 7
extern struct
qmi_elem_info ims_private_service_subscribe_for_indications_rsp_msg_v01_ei[];
extern struct qmi_elem_info
ims_private_service_subscribe_for_indications_rsp_msg_v01_ei[];
struct ims_private_service_mt_invite_ind_msg_v01 {
enum ims_subscription_type_enum_v01 subscription_type;
u8 iccid_valid;
char iccid[IMS_PRIVATE_SERVICE_MAX_ICCID_LEN_V01 + 1];
u8 header_value_list_valid;
u32 header_value_list_len;
struct ims_private_service_header_value_v01
header_value_list[IMS_PRIVATE_SERVICE_MAX_MT_INVITE_HEADERS_V01];
};
#define IMS_PRIVATE_SERVICE_MT_INVITE_IND_MSG_V01_MAX_MSG_LEN 30815
extern struct qmi_elem_info ims_private_service_mt_invite_ind_msg_v01_ei[];
struct ims_private_service_wfc_call_status_ind_msg_v01 {
u8 wfc_call_active;
u8 all_wfc_calls_held_valid;
u8 all_wfc_calls_held;
u8 is_wfc_emergency_valid;
u8 is_wfc_emergency;
u8 twt_ims_start_valid;
u64 twt_ims_start;
u8 twt_ims_int_valid;
u16 twt_ims_int;
u8 media_quality_valid;
enum wfc_media_quality_v01 media_quality;
};
#define IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_MSG_V01_MAX_MSG_LEN 4
extern struct
qmi_elem_info ims_private_service_wfc_call_status_ind_msg_v01_ei[];
#define IMS_PRIVATE_SERVICE_WFC_CALL_STATUS_IND_MSG_V01_MAX_MSG_LEN 35
extern struct qmi_elem_info
ims_private_service_wfc_call_status_ind_msg_v01_ei[];
struct ims_private_service_wfc_call_twt_config_req_msg_v01 {
u8 twt_sta_start_valid;
u64 twt_sta_start;
u8 twt_sta_int_valid;
u16 twt_sta_int;
u8 twt_sta_upo_valid;
u16 twt_sta_upo;
u8 twt_sta_sp_valid;
u16 twt_sta_sp;
u8 twt_sta_dl_valid;
u16 twt_sta_dl;
u8 twt_sta_config_changed_valid;
u8 twt_sta_config_changed;
};
#define IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_MSG_V01_MAX_MSG_LEN 35
extern struct qmi_elem_info
ims_private_service_wfc_call_twt_config_req_msg_v01_ei[];
struct ims_private_service_wfc_call_twt_config_rsp_msg_v01 {
struct qmi_response_type_v01 resp;
};
#define IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_RSP_MSG_V01_MAX_MSG_LEN 7
extern struct qmi_elem_info
ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei[];
#endif

200
drivers/net/wireless/cnss2/qmi.c
View file

@ -27,6 +27,7 @@
#define IMS_TIMEOUT QMI_WLFW_TIMEOUT_JF
#define QMI_WLFW_MAX_RECV_BUF_SIZE SZ_8K
#define IMSPRIVATE_SERVICE_MAX_MSG_LEN SZ_8K
#define QMI_WLFW_MAC_READY_TIMEOUT_MS 50
#define QMI_WLFW_MAC_READY_MAX_RETRY 200
@ -97,6 +98,8 @@ static int cnss_wlfw_ind_register_send_sync(struct cnss_plat_data *plat_priv)
req->qdss_trace_free_enable = 1;
req->respond_get_info_enable_valid = 1;
req->respond_get_info_enable = 1;
req->wfc_call_twt_config_enable_valid = 1;
req->wfc_call_twt_config_enable = 1;
ret = qmi_txn_init(&plat_priv->qmi_wlfw, &txn,
wlfw_ind_register_resp_msg_v01_ei, resp);
@ -1481,17 +1484,15 @@ out:
return ret;
}
int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
u32 data_len, const void *data)
static int cnss_wlfw_wfc_call_status_send_sync
(struct cnss_plat_data *plat_priv,
const struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg)
{
struct wlfw_wfc_call_status_req_msg_v01 *req;
struct wlfw_wfc_call_status_resp_msg_v01 *resp;
struct qmi_txn txn;
int ret = 0;
cnss_pr_dbg("Sending WFC call status: state: 0x%lx\n",
plat_priv->driver_state);
req = kzalloc(sizeof(*req), GFP_KERNEL);
if (!req)
return -ENOMEM;
@ -1502,13 +1503,38 @@ int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
return -ENOMEM;
}
req->wfc_call_status_len = data_len;
memcpy(req->wfc_call_status, data, req->wfc_call_status_len);
/**
* WFC Call r1 design has CNSS as pass thru using opaque hex buffer.
* But in r2 update QMI structure is expanded and as an effect qmi
* decoded structures have padding. Thus we cannot use buffer design.
* For backward compatibility for r1 design copy only wfc_call_active
* value in hex buffer.
*/
req->wfc_call_status_len = sizeof(ind_msg->wfc_call_active);
req->wfc_call_status[0] = ind_msg->wfc_call_active;
/* wfc_call_active is mandatory in IMS indication */
req->wfc_call_active_valid = 1;
req->wfc_call_active = ind_msg->wfc_call_active;
req->all_wfc_calls_held_valid = ind_msg->all_wfc_calls_held_valid;
req->all_wfc_calls_held = ind_msg->all_wfc_calls_held;
req->is_wfc_emergency_valid = ind_msg->is_wfc_emergency_valid;
req->is_wfc_emergency = ind_msg->is_wfc_emergency;
req->twt_ims_start_valid = ind_msg->twt_ims_start_valid;
req->twt_ims_start = ind_msg->twt_ims_start;
req->twt_ims_int_valid = ind_msg->twt_ims_int_valid;
req->twt_ims_int = ind_msg->twt_ims_int;
req->media_quality_valid = ind_msg->media_quality_valid;
req->media_quality =
(enum wlfw_wfc_media_quality_v01)ind_msg->media_quality;
cnss_pr_dbg("CNSS->FW: WFC_CALL_REQ: state: 0x%lx\n",
plat_priv->driver_state);
ret = qmi_txn_init(&plat_priv->qmi_wlfw, &txn,
wlfw_wfc_call_status_resp_msg_v01_ei, resp);
if (ret < 0) {
cnss_pr_err("Fail to initialize txn for WFC call status request: err %d\n",
cnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Txn Init: Err %d\n",
ret);
goto out;
}
@ -1519,29 +1545,25 @@ int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
wlfw_wfc_call_status_req_msg_v01_ei, req);
if (ret < 0) {
qmi_txn_cancel(&txn);
cnss_pr_err("Fail to send WFC call status request: err %d\n",
cnss_pr_err("CNSS->FW: WFC_CALL_REQ: QMI Send Err: %d\n",
ret);
goto out;
}
ret = qmi_txn_wait(&txn, QMI_WLFW_TIMEOUT_JF);
if (ret < 0) {
cnss_pr_err("Fail to wait for response of WFC call status request, err %d\n",
cnss_pr_err("FW->CNSS: WFC_CALL_RSP: QMI Wait Err: %d\n",
ret);
goto out;
}
if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
cnss_pr_err("WFC call status request failed, result: %d, err: %d\n",
cnss_pr_err("FW->CNSS: WFC_CALL_RSP: Result: %d Err: %d\n",
resp->resp.result, resp->resp.error);
ret = -resp->resp.result;
goto out;
}
kfree(req);
kfree(resp);
return 0;
ret = 0;
out:
kfree(req);
kfree(resp);
@ -1970,6 +1992,113 @@ static void cnss_wlfw_respond_get_info_ind_cb(struct qmi_handle *qmi_wlfw,
(void *)ind_msg->data,
ind_msg->data_len);
}
static int cnss_ims_wfc_call_twt_cfg_send_sync
(struct cnss_plat_data *plat_priv,
const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg)
{
struct ims_private_service_wfc_call_twt_config_req_msg_v01 *req;
struct ims_private_service_wfc_call_twt_config_rsp_msg_v01 *resp;
struct qmi_txn txn;
int ret = 0;
req = kzalloc(sizeof(*req), GFP_KERNEL);
if (!req)
return -ENOMEM;
resp = kzalloc(sizeof(*resp), GFP_KERNEL);
if (!resp) {
kfree(req);
return -ENOMEM;
}
req->twt_sta_start_valid = ind_msg->twt_sta_start_valid;
req->twt_sta_start = ind_msg->twt_sta_start;
req->twt_sta_int_valid = ind_msg->twt_sta_int_valid;
req->twt_sta_int = ind_msg->twt_sta_int;
req->twt_sta_upo_valid = ind_msg->twt_sta_upo_valid;
req->twt_sta_upo = ind_msg->twt_sta_upo;
req->twt_sta_sp_valid = ind_msg->twt_sta_sp_valid;
req->twt_sta_sp = ind_msg->twt_sta_sp;
req->twt_sta_dl_valid = req->twt_sta_dl_valid;
req->twt_sta_dl = req->twt_sta_dl;
req->twt_sta_config_changed_valid =
ind_msg->twt_sta_config_changed_valid;
req->twt_sta_config_changed = ind_msg->twt_sta_config_changed;
cnss_pr_dbg("CNSS->IMS: TWT_CFG_REQ: state: 0x%lx\n",
plat_priv->driver_state);
ret =
qmi_txn_init(&plat_priv->ims_qmi, &txn,
ims_private_service_wfc_call_twt_config_rsp_msg_v01_ei,
resp);
if (ret < 0) {
cnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Txn Init Err: %d\n",
ret);
goto out;
}
ret =
qmi_send_request(&plat_priv->ims_qmi, NULL, &txn,
QMI_IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_V01,
IMS_PRIVATE_SERVICE_WFC_CALL_TWT_CONFIG_REQ_MSG_V01_MAX_MSG_LEN,
ims_private_service_wfc_call_twt_config_req_msg_v01_ei, req);
if (ret < 0) {
qmi_txn_cancel(&txn);
cnss_pr_err("CNSS->IMS: TWT_CFG_REQ: QMI Send Err: %d\n", ret);
goto out;
}
ret = qmi_txn_wait(&txn, QMI_WLFW_TIMEOUT_JF);
if (ret < 0) {
cnss_pr_err("IMS->CNSS: TWT_CFG_RSP: QMI Wait Err: %d\n", ret);
goto out;
}
if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
cnss_pr_err("IMS->CNSS: TWT_CFG_RSP: Result: %d Err: %d\n",
resp->resp.result, resp->resp.error);
ret = -resp->resp.result;
goto out;
}
ret = 0;
out:
kfree(req);
kfree(resp);
return ret;
}
static void cnss_wlfw_process_twt_cfg_ind(struct qmi_handle *qmi_wlfw,
struct sockaddr_qrtr *sq,
struct qmi_txn *txn,
const void *data)
{
struct cnss_plat_data *plat_priv =
container_of(qmi_wlfw, struct cnss_plat_data, qmi_wlfw);
const struct wlfw_wfc_call_twt_config_ind_msg_v01 *ind_msg = data;
if (!txn) {
cnss_pr_err("FW->CNSS: TWT_CFG_IND: Spurious indication\n");
return;
}
if (!ind_msg) {
cnss_pr_err("FW->CNSS: TWT_CFG_IND: Invalid indication\n");
return;
}
cnss_pr_dbg("FW->CNSS: TWT_CFG_IND: %x %llx, %x %x, %x %x, %x %x, %x %x, %x %x\n",
ind_msg->twt_sta_start_valid, ind_msg->twt_sta_start,
ind_msg->twt_sta_int_valid, ind_msg->twt_sta_int,
ind_msg->twt_sta_upo_valid, ind_msg->twt_sta_upo,
ind_msg->twt_sta_sp_valid, ind_msg->twt_sta_sp,
ind_msg->twt_sta_dl_valid, ind_msg->twt_sta_dl,
ind_msg->twt_sta_config_changed_valid,
ind_msg->twt_sta_config_changed);
cnss_ims_wfc_call_twt_cfg_send_sync(plat_priv, ind_msg);
}
static struct qmi_msg_handler qmi_wlfw_msg_handlers[] = {
{
.type = QMI_INDICATION,
@ -2046,6 +2175,14 @@ static struct qmi_msg_handler qmi_wlfw_msg_handlers[] = {
sizeof(struct wlfw_respond_get_info_ind_msg_v01),
.fn = cnss_wlfw_respond_get_info_ind_cb
},
{
.type = QMI_INDICATION,
.msg_id = QMI_WLFW_WFC_CALL_TWT_CONFIG_IND_V01,
.ei = wlfw_wfc_call_twt_config_ind_msg_v01_ei,
.decoded_size =
sizeof(struct wlfw_wfc_call_twt_config_ind_msg_v01),
.fn = cnss_wlfw_process_twt_cfg_ind
},
{}
};
@ -2460,35 +2597,34 @@ static void ims_subscribe_for_indication_resp_cb(struct qmi_handle *qmi,
}
}
static void ims_wfc_call_status_ind_cb(struct qmi_handle *ims_qmi,
struct sockaddr_qrtr *sq,
struct qmi_txn *txn, const void *data)
static void
cnss_ims_process_wfc_call_ind_cb(struct qmi_handle *ims_qmi,
struct sockaddr_qrtr *sq,
struct qmi_txn *txn, const void *data)
{
struct cnss_plat_data *plat_priv =
container_of(ims_qmi, struct cnss_plat_data, ims_qmi);
const
struct ims_private_service_wfc_call_status_ind_msg_v01 *ind_msg = data;
u32 data_len = 0;
cnss_pr_dbg("Received IMS wfc call status indication\n");
if (!txn) {
cnss_pr_err("Spurious indication\n");
cnss_pr_err("IMS->CNSS: WFC_CALL_IND: Spurious indication\n");
return;
}
if (!ind_msg) {
cnss_pr_err("Invalid indication\n");
cnss_pr_err("IMS->CNSS: WFC_CALL_IND: Invalid indication\n");
return;
}
cnss_pr_dbg("IMS->CNSS: WFC_CALL_IND: %x, %x %x, %x %x, %x %llx, %x %x, %x %x\n",
ind_msg->wfc_call_active, ind_msg->all_wfc_calls_held_valid,
ind_msg->all_wfc_calls_held,
ind_msg->is_wfc_emergency_valid, ind_msg->is_wfc_emergency,
ind_msg->twt_ims_start_valid, ind_msg->twt_ims_start,
ind_msg->twt_ims_int_valid, ind_msg->twt_ims_int,
ind_msg->media_quality_valid, ind_msg->media_quality);
data_len = sizeof(*ind_msg);
if (data_len > QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01) {
cnss_pr_err("Exceed maxinum data len:%u\n", data_len);
return;
}
cnss_wlfw_wfc_call_status_send_sync(plat_priv, data_len, ind_msg);
cnss_wlfw_wfc_call_status_send_sync(plat_priv, ind_msg);
}
static struct qmi_msg_handler qmi_ims_msg_handlers[] = {
@ -2508,7 +2644,7 @@ static struct qmi_msg_handler qmi_ims_msg_handlers[] = {
.ei = ims_private_service_wfc_call_status_ind_msg_v01_ei,
.decoded_size =
sizeof(struct ims_private_service_wfc_call_status_ind_msg_v01),
.fn = ims_wfc_call_status_ind_cb
.fn = cnss_ims_process_wfc_call_ind_cb
},
{}
};

15
drivers/net/wireless/cnss2/qmi.h
View file

@ -4,7 +4,7 @@
#ifndef _CNSS_QMI_H
#define _CNSS_QMI_H
#include <linux/soc/qcom/qmi.h>
#include "wlan_firmware_service_v01.h"
struct cnss_plat_data;
@ -29,7 +29,6 @@ struct cnss_qmi_event_qdss_trace_save_data {
};
#ifdef CONFIG_CNSS2_QMI
#include "wlan_firmware_service_v01.h"
#include "coexistence_service_v01.h"
#include "ip_multimedia_subsystem_private_service_v01.h"
@ -61,8 +60,6 @@ int cnss_wlfw_antenna_grant_send_sync(struct cnss_plat_data *plat_priv);
int cnss_wlfw_dynamic_feature_mask_send_sync(struct cnss_plat_data *plat_priv);
int cnss_wlfw_get_info_send_sync(struct cnss_plat_data *plat_priv, int type,
void *cmd, int cmd_len);
int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
u32 data_len, const void *data);
int cnss_register_coex_service(struct cnss_plat_data *plat_priv);
void cnss_unregister_coex_service(struct cnss_plat_data *plat_priv);
int coex_antenna_switch_to_wlan_send_sync_msg(struct cnss_plat_data *plat_priv);
@ -184,13 +181,6 @@ int cnss_wlfw_get_info_send_sync(struct cnss_plat_data *plat_priv, int type,
return 0;
}
static inline
int cnss_wlfw_wfc_call_status_send_sync(struct cnss_plat_data *plat_priv,
u32 data_len, const void *data);
{
return 0;
}
static inline
int cnss_register_coex_service(struct cnss_plat_data *plat_priv)
{
@ -208,6 +198,9 @@ int coex_antenna_switch_to_wlan_send_sync_msg(struct cnss_plat_data *plat_priv)
static inline
int coex_antenna_switch_to_mdm_send_sync_msg(struct cnss_plat_data *plat_priv)
{
return 0;
}
static inline
int cnss_wlfw_qdss_trace_mem_info_send_sync(struct cnss_plat_data *plat_priv)

269
drivers/net/wireless/cnss2/wlan_firmware_service_v01.c
View file

@ -464,8 +464,7 @@ struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[] = {
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset = offsetof(struct
wlfw_ind_register_req_msg_v01,
.offset = offsetof(struct wlfw_ind_register_req_msg_v01,
fw_ready_enable_valid),
},
{
@ -765,6 +764,24 @@ struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[] = {
.offset = offsetof(struct wlfw_ind_register_req_msg_v01,
m3_dump_upload_req_enable),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x21,
.offset = offsetof(struct wlfw_ind_register_req_msg_v01,
wfc_call_twt_config_enable_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x21,
.offset = offsetof(struct wlfw_ind_register_req_msg_v01,
wfc_call_twt_config_enable),
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
@ -3753,6 +3770,126 @@ struct qmi_elem_info wlfw_wfc_call_status_req_msg_v01_ei[] = {
wlfw_wfc_call_status_req_msg_v01,
wfc_call_status),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
wfc_call_active_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
wfc_call_active),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
all_wfc_calls_held_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
all_wfc_calls_held),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
is_wfc_emergency_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
is_wfc_emergency),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
twt_ims_start_valid),
},
{
.data_type = QMI_UNSIGNED_8_BYTE,
.elem_len = 1,
.elem_size = sizeof(u64),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
twt_ims_start),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
twt_ims_int_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
twt_ims_int),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x15,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
media_quality_valid),
},
{
.data_type = QMI_SIGNED_4_BYTE_ENUM,
.elem_len = 1,
.elem_size = sizeof(enum wlfw_wfc_media_quality_v01),
.array_type = NO_ARRAY,
.tlv_type = 0x15,
.offset = offsetof(struct
wlfw_wfc_call_status_req_msg_v01,
media_quality),
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
@ -4138,3 +4275,131 @@ struct qmi_elem_info wlfw_exit_power_save_resp_msg_v01_ei[] = {
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};
struct qmi_elem_info wlfw_wfc_call_twt_config_ind_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 wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_start_valid),
},
{
.data_type = QMI_UNSIGNED_8_BYTE,
.elem_len = 1,
.elem_size = sizeof(u64),
.array_type = NO_ARRAY,
.tlv_type = 0x10,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_start),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_int_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x11,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_int),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_upo_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x12,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_upo),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_sp_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x13,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_sp),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_dl_valid),
},
{
.data_type = QMI_UNSIGNED_2_BYTE,
.elem_len = 1,
.elem_size = sizeof(u16),
.array_type = NO_ARRAY,
.tlv_type = 0x14,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_dl),
},
{
.data_type = QMI_OPT_FLAG,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x15,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_config_changed_valid),
},
{
.data_type = QMI_UNSIGNED_1_BYTE,
.elem_len = 1,
.elem_size = sizeof(u8),
.array_type = NO_ARRAY,
.tlv_type = 0x15,
.offset =
offsetof(struct wlfw_wfc_call_twt_config_ind_msg_v01,
twt_sta_config_changed),
},
{
.data_type = QMI_EOTI,
.array_type = NO_ARRAY,
.tlv_type = QMI_COMMON_TLV_TYPE,
},
};

47
drivers/net/wireless/cnss2/wlan_firmware_service_v01.h
View file

@ -84,6 +84,7 @@
#define QMI_WLFW_MAC_ADDR_REQ_V01 0x0033
#define QMI_WLFW_EXIT_POWER_SAVE_RESP_V01 0x0050
#define QMI_WLFW_RESPOND_MEM_RESP_V01 0x0036
#define QMI_WLFW_WFC_CALL_TWT_CONFIG_IND_V01 0x0051
#define QMI_WLFW_VBATT_RESP_V01 0x0032
#define QMI_WLFW_MSA_INFO_REQ_V01 0x002D
#define QMI_WLFW_QDSS_TRACE_FREE_IND_V01 0x0046
@ -153,6 +154,7 @@ enum wlfw_mem_type_enum_v01 {
QMI_WLFW_MEM_CAL_V01 = 4,
QMI_WLFW_MEM_DPD_V01 = 5,
QMI_WLFW_MEM_QDSS_V01 = 6,
QMI_WLFW_MEM_HANG_DATA_V01 = 7,
WLFW_MEM_TYPE_ENUM_MAX_VAL_V01 = INT_MAX,
};
@ -163,6 +165,15 @@ enum wlfw_qdss_trace_mode_enum_v01 {
WLFW_QDSS_TRACE_MODE_ENUM_MAX_VAL_V01 = INT_MAX,
};
enum wlfw_wfc_media_quality_v01 {
WLFW_WFC_MEDIA_QUALITY_MIN_VAL_V01 = INT_MIN,
QMI_WLFW_WFC_MEDIA_QUAL_NOT_AVAILABLE_V01 = 0,
QMI_WLFW_WFC_MEDIA_QUAL_BAD_V01 = 1,
QMI_WLFW_WFC_MEDIA_QUAL_GOOD_V01 = 2,
QMI_WLFW_WFC_MEDIA_QUAL_EXCELLENT_V01 = 3,
WLFW_WFC_MEDIA_QUALITY_MAX_VAL_V01 = INT_MAX,
};
enum wlfw_soc_wake_enum_v01 {
WLFW_SOC_WAKE_ENUM_MIN_VAL_V01 = INT_MIN,
QMI_WLFW_WAKE_REQUEST_V01 = 0,
@ -302,9 +313,11 @@ struct wlfw_ind_register_req_msg_v01 {
u8 respond_get_info_enable;
u8 m3_dump_upload_req_enable_valid;
u8 m3_dump_upload_req_enable;
u8 wfc_call_twt_config_enable_valid;
u8 wfc_call_twt_config_enable;
};
#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 74
#define WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN 78
extern struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[];
struct wlfw_ind_register_resp_msg_v01 {
@ -979,9 +992,21 @@ extern struct qmi_elem_info wlfw_antenna_grant_resp_msg_v01_ei[];
struct wlfw_wfc_call_status_req_msg_v01 {
u32 wfc_call_status_len;
u8 wfc_call_status[QMI_WLFW_MAX_WFC_CALL_STATUS_DATA_SIZE_V01];
u8 wfc_call_active_valid;
u8 wfc_call_active;
u8 all_wfc_calls_held_valid;
u8 all_wfc_calls_held;
u8 is_wfc_emergency_valid;
u8 is_wfc_emergency;
u8 twt_ims_start_valid;
u64 twt_ims_start;
u8 twt_ims_int_valid;
u16 twt_ims_int;
u8 media_quality_valid;
enum wlfw_wfc_media_quality_v01 media_quality;
};
#define WLFW_WFC_CALL_STATUS_REQ_MSG_V01_MAX_MSG_LEN 261
#define WLFW_WFC_CALL_STATUS_REQ_MSG_V01_MAX_MSG_LEN 296
extern struct qmi_elem_info wlfw_wfc_call_status_req_msg_v01_ei[];
struct wlfw_wfc_call_status_resp_msg_v01 {
@ -1092,4 +1117,22 @@ struct wlfw_exit_power_save_resp_msg_v01 {
#define WLFW_EXIT_POWER_SAVE_RESP_MSG_V01_MAX_MSG_LEN 7
extern struct qmi_elem_info wlfw_exit_power_save_resp_msg_v01_ei[];
struct wlfw_wfc_call_twt_config_ind_msg_v01 {
u8 twt_sta_start_valid;
u64 twt_sta_start;
u8 twt_sta_int_valid;
u16 twt_sta_int;
u8 twt_sta_upo_valid;
u16 twt_sta_upo;
u8 twt_sta_sp_valid;
u16 twt_sta_sp;
u8 twt_sta_dl_valid;
u16 twt_sta_dl;
u8 twt_sta_config_changed_valid;
u8 twt_sta_config_changed;
};
#define WLFW_WFC_CALL_TWT_CONFIG_IND_MSG_V01_MAX_MSG_LEN 35
extern struct qmi_elem_info wlfw_wfc_call_twt_config_ind_msg_v01_ei[];
#endif