samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: FIPS waikiki WMI changes

Browse Source 
Add FIPS Waikiki WMI changes.

Change-Id: Ie84c2db885b7357dd3466df3494d345ce2e5a132
This commit is contained in:
Disha Das
2021-11-09 20:14:13 +05:30
committed by Madan Koyyalamudi
parent 65137277e8
commit d3873b0cc6
5 changed files with 534 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
wmi/inc/wmi_unified_api.h
View File

@@ -1970,6 +1970,43 @@ QDF_STATUS
wmi_unified_pdev_fips_cmd_send(wmi_unified_t wmi_handle, wmi_unified_pdev_fips_cmd_send(wmi_unified_t wmi_handle,
struct fips_params *param); struct fips_params *param);
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
/**
* wmi_unified_pdev_fips_extend_cmd_send() - WMI pdev fips extend cmd function
* @wmi_handle: handle to WMI.
* @param: pointer to hold pdev fips extend param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_pdev_fips_extend_cmd_send(wmi_unified_t wmi_handle,
struct fips_extend_params *param);
/**
* wmi_unified_pdev_fips_mode_set_cmd() - WMI pdev fips mode enable cmd
* @wmi_handle: handle to WMI.
* @param: pointer to hold pdev fips mode param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_pdev_fips_mode_set_cmd(wmi_unified_t wmi_handle,
struct fips_mode_set_params *param);
/**
* wmi_extract_fips_extend_event_data() - extract fips extend event data
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: pointer to FIPS extend event param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_fips_extend_event_data(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_fips_extend_event_param
*param);
#endif
#ifdef WLAN_FEATURE_DISA #ifdef WLAN_FEATURE_DISA
/** /**
* wmi_unified_encrypt_decrypt_send_cmd() - send encryptdecrypt cmd to fw * wmi_unified_encrypt_decrypt_send_cmd() - send encryptdecrypt cmd to fw

81
wmi/inc/wmi_unified_param.h
View File

@@ -3270,6 +3270,64 @@ struct fips_params {
uint32_t pdev_id; uint32_t pdev_id;
}; };
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
#define MAX_KEY_LEN_FIPS_EXTEND 64
#define MAX_NONCEIV_LEN_FIPS_EXTEND 16
/**
* struct fips_extend_cmd_params - FIPS extend params config for first frag
* @fips_cmd: 1 - Encrypt, 2 - Decrypt
* key_cipher: 0 - CCM, 1 - GCM
* @key_len: length of key
* @key: key_data
* @nonce_iv_len: length of nonce or iv
* @nonce_iv: nonce_iv
* @tag_len: length of tag/mic
* @aad_len: length of aad
* @payload_len: length of payload
*/
struct fips_extend_cmd_params {
u_int32_t fips_cmd;
u_int32_t key_cipher;
u_int32_t key_len;
u_int8_t key[MAX_KEY_LEN_FIPS_EXTEND];
u_int32_t nonce_iv_len;
u_int8_t nonce_iv[MAX_NONCEIV_LEN_FIPS_EXTEND];
u_int32_t tag_len;
u_int32_t aad_len;
u_int32_t payload_len;
};
/**
* struct fips_extend_params - FIPS extend params config
* @pdev_id: pdev_id for identifying the MAC
* @cookie: cookie value
* @frag_idx: fragment index
* @more_bit: more bit
* @data_len: length of data buf
* @cmd_params: cmd_params set for first fragment
* @data: pointer data buf
*/
struct fips_extend_params {
uint32_t pdev_id;
u_int32_t cookie;
u_int32_t frag_idx;
u_int32_t more_bit;
u_int32_t data_len;
struct fips_extend_cmd_params cmd_params;
u_int32_t *data;
};
/**
* struct fips_mode_set_params - FIPS mode enable param
* @pdev_id: pdev_id for identifying the MAC
* @mode: value to disable or enable fips extend mode
*/
struct fips_mode_set_params {
uint32_t pdev_id;
uint32_t mode;
};
#endif
#ifdef WLAN_FEATURE_DISA_FIPS #ifdef WLAN_FEATURE_DISA_FIPS
/** /**
* struct disa_encrypt_decrypt_req_params - disa encrypt request * struct disa_encrypt_decrypt_req_params - disa encrypt request
@@ -4660,6 +4718,7 @@ typedef enum {
wmi_mlo_teardown_complete_event_id, wmi_mlo_teardown_complete_event_id,
wmi_mlo_link_set_active_resp_eventid, wmi_mlo_link_set_active_resp_eventid,
#endif #endif
wmi_pdev_fips_extend_event_id,
wmi_events_max, wmi_events_max,
} wmi_conv_event_id; } wmi_conv_event_id;
@@ -6931,6 +6990,28 @@ struct wmi_host_fips_event_param {
uint32_t *data; uint32_t *data;
}; };
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
/*
* struct wmi_host_fips_extend_event_param: FIPS extend event param
* @pdev_id: pdev id
* @fips_cookie: fips_cookie
* @cmd_frag_idx: cmd_frag_idx
* @more_bit: more_bit
* @error_status: Error status: 0 (no err), 1, or OPER_TIMEOUR
* @data_len: FIPS data length
* @data: pointer to data
*/
struct wmi_host_fips_extend_event_param {
uint32_t pdev_id;
uint32_t fips_cookie;
uint32_t cmd_frag_idx;
uint32_t more_bit;
uint32_t error_status;
uint32_t data_len;
uint32_t *data;
};
#endif
#ifdef WLAN_FEATURE_DISA_FIPS #ifdef WLAN_FEATURE_DISA_FIPS
/** /**
* struct disa_encrypt_decrypt_resp_params - disa encrypt response * struct disa_encrypt_decrypt_resp_params - disa encrypt response

16
wmi/inc/wmi_unified_priv.h
View File

@@ -1252,6 +1252,14 @@ QDF_STATUS (*send_set_bwf_cmd)(wmi_unified_t wmi_handle,
QDF_STATUS (*send_pdev_fips_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_pdev_fips_cmd)(wmi_unified_t wmi_handle,
struct fips_params *param); struct fips_params *param);
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
QDF_STATUS (*send_pdev_fips_extend_cmd)(wmi_unified_t wmi_handle,
struct fips_extend_params *param);
QDF_STATUS (*send_pdev_fips_mode_set_cmd)(wmi_unified_t wmi_handle,
struct fips_mode_set_params *param);
#endif
QDF_STATUS (*send_wlan_profile_enable_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_wlan_profile_enable_cmd)(wmi_unified_t wmi_handle,
struct wlan_profile_params *param); struct wlan_profile_params *param);
@@ -1763,6 +1771,14 @@ QDF_STATUS (*extract_dcs_awgn_info)(
QDF_STATUS (*extract_fips_event_data)(wmi_unified_t wmi_handle, QDF_STATUS (*extract_fips_event_data)(wmi_unified_t wmi_handle,
void *evt_buf, struct wmi_host_fips_event_param *param); void *evt_buf, struct wmi_host_fips_event_param *param);
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
QDF_STATUS
(*extract_fips_extend_ev_data)(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_host_fips_extend_event_param
*param);
#endif
#ifdef WLAN_FEATURE_DISA #ifdef WLAN_FEATURE_DISA
QDF_STATUS QDF_STATUS
(*extract_encrypt_decrypt_resp_event)(wmi_unified_t wmi_handle, (*extract_encrypt_decrypt_resp_event)(wmi_unified_t wmi_handle,

39
wmi/src/wmi_unified_api.c
View File

@@ -1143,6 +1143,30 @@ wmi_unified_pdev_fips_cmd_send(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
QDF_STATUS
wmi_unified_pdev_fips_extend_cmd_send(wmi_unified_t wmi_handle,
struct fips_extend_params *param)
{
if (wmi_handle->ops->send_pdev_fips_extend_cmd)
return wmi_handle->ops->send_pdev_fips_extend_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_pdev_fips_mode_set_cmd(wmi_unified_t wmi_handle,
struct fips_mode_set_params *param)
{
if (wmi_handle->ops->send_pdev_fips_mode_set_cmd)
return wmi_handle->ops->send_pdev_fips_mode_set_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
#endif
#ifdef WLAN_FEATURE_DISA #ifdef WLAN_FEATURE_DISA
QDF_STATUS QDF_STATUS
wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl, wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl,
@@ -1924,6 +1948,21 @@ wmi_extract_fips_event_data(wmi_unified_t wmi_handle, void *evt_buf,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
QDF_STATUS
wmi_extract_fips_extend_event_data(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_fips_extend_event_param
*param)
{
if (wmi_handle->ops->extract_fips_extend_ev_data) {
return wmi_handle->ops->extract_fips_extend_ev_data(wmi_handle,
evt_buf,
param);
}
return QDF_STATUS_E_FAILURE;
}
#endif
/** /**
* wmi_unified_extract_pn() - extract pn event data * wmi_unified_extract_pn() - extract pn event data
* @wmi_handle: wmi handle * @wmi_handle: wmi handle

367
wmi/src/wmi_unified_tlv.c
View File

@@ -8242,13 +8242,146 @@ static QDF_STATUS send_flush_logs_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
} }
#ifdef BIG_ENDIAN_HOST #ifdef BIG_ENDIAN_HOST
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
/** /**
* fips_conv_data_be() - LE to BE conversion of FIPS ev data * fips_extend_align_data_be() - LE to BE conversion of FIPS extend ev data
* @param data_len - data length * @param - fips extend param related parameters
* @param data - pointer to data *
* * Return: QDF_STATUS - success or error status
* Return: QDF_STATUS - success or error status
*/ */
static QDF_STATUS fips_extend_align_data_be(wmi_unified_t wmi_handle,
struct fips_extend_params *param)
{
unsigned char *key_unaligned, *nonce_iv_unaligned, *data_unaligned;
int c;
u_int8_t *key_aligned = NULL;
u_int8_t *nonce_iv_aligned = NULL;
u_int8_t *data_aligned = NULL;
int ret = QDF_STATUS_SUCCESS;
/* Assigning unaligned space to copy the key */
key_unaligned = qdf_mem_malloc(sizeof(u_int8_t) *
param->cmd_params.key_len + FIPS_ALIGN);
/* Checking if kmalloc is successful to allocate space */
if (!key_unaligned)
return QDF_STATUS_E_INVAL;
data_unaligned = qdf_mem_malloc(sizeof(u_int8_t) * param->data_len +
FIPS_ALIGN);
/* Checking if kmalloc is successful to allocate space */
if (!data_unaligned) {
ret = QDF_STATUS_E_INVAL;
goto fips_align_fail_data;
}
/* Checking if space is aligned */
if (!FIPS_IS_ALIGNED(key_unaligned, FIPS_ALIGN)) {
/* align to 4 */
key_aligned = (u_int8_t *)FIPS_ALIGNTO(key_unaligned,
FIPS_ALIGN);
} else {
key_aligned = (u_int8_t *)key_unaligned;
}
/* memset and copy content from key to key aligned */
OS_MEMSET(key_aligned, 0, param->cmd_params.key_len);
OS_MEMCPY(key_aligned, param->cmd_params.key,
param->cmd_params.key_len);
/* print a hexdump for host debug */
wmi_debug("Aligned and Copied Key: ");
qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
key_aligned, param->cmd_params.key_len);
/* Checking of space is aligned */
if (!FIPS_IS_ALIGNED(data_unaligned, FIPS_ALIGN)) {
/* align to 4 */
data_aligned =
(u_int8_t *)FIPS_ALIGNTO(data_unaligned, FIPS_ALIGN);
} else {
data_aligned = (u_int8_t *)data_unaligned;
}
/* memset and copy content from data to data aligned */
OS_MEMSET(data_aligned, 0, param->data_len);
OS_MEMCPY(data_aligned, param->data, param->data_len);
/* print a hexdump for host debug */
wmi_debug("\t Properly Aligned and Copied Data: ");
qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
data_aligned, param->data_len);
/* converting to little Endian */
for (c = 0; c < param->cmd_params.key_len / 4; c++) {
*((u_int32_t *)key_aligned + c) =
qdf_cpu_to_le32(*((u_int32_t *)key_aligned + c));
}
for (c = 0; c < param->data_len / 4; c++) {
*((u_int32_t *)data_aligned + c) =
qdf_cpu_to_le32(*((u_int32_t *)data_aligned + c));
}
/* update endian data */
OS_MEMCPY(param->cmd_params.key, key_aligned,
param->cmd_params.key_len);
OS_MEMCPY(param->data, data_aligned, param->data_len);
if (param->cmd_params.nonce_iv_len) {
nonce_iv_unaligned = qdf_mem_malloc(sizeof(u_int8_t) *
param->cmd_params.nonce_iv_len +
FIPS_ALIGN);
/* Checking if kmalloc is successful to allocate space */
if (!nonce_iv_unaligned) {
ret = QDF_STATUS_E_INVAL;
goto fips_align_fail_nonce_iv;
}
/* Checking if space is aligned */
if (!FIPS_IS_ALIGNED(nonce_iv_unaligned, FIPS_ALIGN)) {
/* align to 4 */
nonce_iv_aligned =
(u_int8_t *)FIPS_ALIGNTO(nonce_iv_unaligned,
FIPS_ALIGN);
} else {
nonce_iv_aligned = (u_int8_t *)nonce_iv_unaligned;
}
/* memset and copy content from iv to iv aligned */
OS_MEMSET(nonce_iv_aligned, 0, param->cmd_params.nonce_iv_len);
OS_MEMCPY(nonce_iv_aligned, param->cmd_params.nonce_iv,
param->cmd_params.nonce_iv_len);
/* print a hexdump for host debug */
wmi_debug("\t Aligned and Copied Nonce_IV: ");
qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
nonce_iv_aligned,
param->cmd_params.nonce_iv_len);
for (c = 0; c < param->cmd_params.nonce_iv_len / 4; c++) {
*((u_int32_t *)nonce_iv_aligned + c) =
qdf_cpu_to_le32(*((u_int32_t *)nonce_iv_aligned + c));
}
}
/* clean up allocated spaces */
qdf_mem_free(nonce_iv_unaligned);
nonce_iv_unaligned = NULL;
nonce_iv_aligned = NULL;
fips_align_fail_nonce_iv:
qdf_mem_free(data_unaligned);
data_unaligned = NULL;
data_aligned = NULL;
fips_align_fail_data:
qdf_mem_free(key_unaligned);
key_unaligned = NULL;
key_aligned = NULL;
return ret;
}
#endif
static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle, static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle,
struct fips_params *param) struct fips_params *param)
{ {
@@ -8336,13 +8469,26 @@ static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
#else #else
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
/**
* fips_extend_align_data_be() - DUMMY for LE platform
*
* Return: QDF_STATUS - success
*/
static QDF_STATUS fips_extend_align_data_be(wmi_unified_t wmi_handle,
struct fips_extend_params *param)
{
return QDF_STATUS_SUCCESS;
}
#endif
/** /**
* fips_align_data_be() - DUMMY for LE platform * fips_align_data_be() - DUMMY for LE platform
* *
* Return: QDF_STATUS - success * Return: QDF_STATUS - success
*/ */
static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle, static QDF_STATUS fips_align_data_be(wmi_unified_t wmi_handle,
struct fips_params *param) struct fips_params *param)
{ {
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
@@ -8529,6 +8675,166 @@ send_pdev_fips_cmd_tlv(wmi_unified_t wmi_handle,
return retval; return retval;
} }
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
/**
* send_pdev_fips_extend_cmd_tlv() - send pdev fips cmd to fw
* @wmi_handle: wmi handle
* @param: pointer to hold pdev fips param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_pdev_fips_extend_cmd_tlv(wmi_unified_t wmi_handle,
struct fips_extend_params *param)
{
wmi_pdev_fips_extend_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint32_t len = sizeof(wmi_pdev_fips_extend_cmd_fixed_param);
QDF_STATUS retval = QDF_STATUS_SUCCESS;
len += WMI_TLV_HDR_SIZE;
if (param->frag_idx == 0)
len += sizeof(wmi_fips_extend_cmd_init_params);
/* Length TLV placeholder for array of bytes */
len += WMI_TLV_HDR_SIZE;
if (param->data_len)
len += (param->data_len * sizeof(uint8_t));
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_pdev_fips_extend_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_fips_extend_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_fips_extend_cmd_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
param->pdev_id);
cmd->fips_cookie = param->cookie;
cmd->frag_idx = param->frag_idx;
cmd->more_bit = param->more_bit;
cmd->data_len = param->data_len;
if (fips_extend_align_data_be(wmi_handle, param) !=
QDF_STATUS_SUCCESS) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
buf_ptr = (uint8_t *)(cmd + 1);
if (cmd->frag_idx == 0) {
wmi_fips_extend_cmd_init_params *cmd_params;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_fips_extend_cmd_init_params));
buf_ptr += WMI_TLV_HDR_SIZE;
cmd_params = (wmi_fips_extend_cmd_init_params *)buf_ptr;
WMITLV_SET_HDR(buf_ptr,
WMITLV_TAG_STRUC_wmi_fips_extend_cmd_init_params,
WMITLV_GET_STRUCT_TLVLEN(wmi_fips_extend_cmd_init_params));
cmd_params->fips_cmd = param->cmd_params.fips_cmd;
cmd_params->key_cipher = param->cmd_params.key_cipher;
cmd_params->key_len = param->cmd_params.key_len;
cmd_params->nonce_iv_len = param->cmd_params.nonce_iv_len;
cmd_params->tag_len = param->cmd_params.tag_len;
cmd_params->aad_len = param->cmd_params.aad_len;
cmd_params->payload_len = param->cmd_params.payload_len;
qdf_mem_copy(cmd_params->key, param->cmd_params.key,
param->cmd_params.key_len);
qdf_mem_copy(cmd_params->nonce_iv, param->cmd_params.nonce_iv,
param->cmd_params.nonce_iv_len);
wmi_debug("Key len = %d, IVNoncelen = %d, Tlen = %d, Alen = %d, Plen = %d",
cmd_params->key_len, cmd_params->nonce_iv_len,
cmd_params->tag_len, cmd_params->aad_len,
cmd_params->payload_len);
buf_ptr += sizeof(wmi_fips_extend_cmd_init_params);
} else {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
buf_ptr += WMI_TLV_HDR_SIZE;
}
if (param->data) {
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->data_len);
buf_ptr += WMI_TLV_HDR_SIZE;
if (param->data_len)
qdf_mem_copy(buf_ptr,
(uint8_t *)param->data, param->data_len);
wmi_debug("Data: ");
qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
buf_ptr, cmd->data_len);
if (param->data_len)
buf_ptr += param->data_len;
wmi_mtrace(WMI_PDEV_FIPS_EXTEND_CMDID, NO_SESSION, 0);
retval = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_FIPS_EXTEND_CMDID);
wmi_debug("return value %d", retval);
} else {
wmi_debug("Key or Data is NULL");
wmi_buf_free(buf);
retval = QDF_STATUS_E_BADMSG;
}
return retval;
}
/**
* send_pdev_fips_mode_set_cmd_tlv() - send pdev fips cmd to fw
* @wmi_handle: wmi handle
* @param: pointer to hold pdev fips param
*
* Return: 0 for success or error code
*/
static QDF_STATUS
send_pdev_fips_mode_set_cmd_tlv(wmi_unified_t wmi_handle,
struct fips_mode_set_params *param)
{
wmi_pdev_fips_mode_set_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint32_t len = sizeof(wmi_pdev_fips_mode_set_cmd_fixed_param);
QDF_STATUS retval = QDF_STATUS_SUCCESS;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_pdev_fips_mode_set_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_fips_mode_set_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_fips_mode_set_cmd_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
param->pdev_id);
cmd->fips_mode_set = param->mode;
wmi_mtrace(WMI_PDEV_FIPS_MODE_SET_CMDID, NO_SESSION, 0);
retval = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_FIPS_MODE_SET_CMDID);
if (retval) {
wmi_err("Failed to send FIPS mode enable cmd");
wmi_buf_free(buf);
}
return retval;
}
#endif
/** /**
* send_wlan_profile_enable_cmd_tlv() - send wlan profile enable command * send_wlan_profile_enable_cmd_tlv() - send wlan profile enable command
* to fw * to fw
@@ -12566,6 +12872,45 @@ static QDF_STATUS extract_fips_event_data_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
/**
* extract_fips_extend_event_data_tlv() - extract fips event data
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: pointer FIPS event params
*
* Return: 0 for success or error code
*/
static QDF_STATUS
extract_fips_extend_event_data_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_host_fips_extend_event_param
*param)
{
WMI_PDEV_FIPS_EXTEND_EVENTID_param_tlvs *param_buf;
wmi_pdev_fips_extend_event_fixed_param *event;
param_buf = (WMI_PDEV_FIPS_EXTEND_EVENTID_param_tlvs *)evt_buf;
event = (wmi_pdev_fips_extend_event_fixed_param *)param_buf->fixed_param;
if (fips_conv_data_be(event->data_len, param_buf->data) !=
QDF_STATUS_SUCCESS)
return QDF_STATUS_E_FAILURE;
param->data = (uint32_t *)param_buf->data;
param->data_len = event->data_len;
param->error_status = event->error_status;
param->fips_cookie = event->fips_cookie;
param->cmd_frag_idx = event->cmd_frag_idx;
param->more_bit = event->more_bit;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
wmi_handle,
event->pdev_id);
return QDF_STATUS_SUCCESS;
}
#endif
#ifdef WLAN_FEATURE_DISA #ifdef WLAN_FEATURE_DISA
/** /**
* extract_encrypt_decrypt_resp_event_tlv() - extract encrypt decrypt resp * extract_encrypt_decrypt_resp_event_tlv() - extract encrypt decrypt resp
@@ -16536,6 +16881,9 @@ struct wmi_ops tlv_ops = {
.extract_pdev_utf_event = extract_pdev_utf_event_tlv, .extract_pdev_utf_event = extract_pdev_utf_event_tlv,
.wmi_set_htc_tx_tag = wmi_set_htc_tx_tag_tlv, .wmi_set_htc_tx_tag = wmi_set_htc_tx_tag_tlv,
.extract_fips_event_data = extract_fips_event_data_tlv, .extract_fips_event_data = extract_fips_event_data_tlv,
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
.extract_fips_extend_ev_data = extract_fips_extend_event_data_tlv,
#endif
#if defined(WLAN_SUPPORT_FILS) || defined(CONFIG_BAND_6GHZ) #if defined(WLAN_SUPPORT_FILS) || defined(CONFIG_BAND_6GHZ)
.send_vdev_fils_enable_cmd = send_vdev_fils_enable_cmd_send, .send_vdev_fils_enable_cmd = send_vdev_fils_enable_cmd_send,
#endif #endif
@@ -16544,6 +16892,10 @@ struct wmi_ops tlv_ops = {
extract_encrypt_decrypt_resp_event_tlv, extract_encrypt_decrypt_resp_event_tlv,
#endif #endif
.send_pdev_fips_cmd = send_pdev_fips_cmd_tlv, .send_pdev_fips_cmd = send_pdev_fips_cmd_tlv,
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
.send_pdev_fips_extend_cmd = send_pdev_fips_extend_cmd_tlv,
.send_pdev_fips_mode_set_cmd = send_pdev_fips_mode_set_cmd_tlv,
#endif
.extract_get_pn_data = extract_get_pn_data_tlv, .extract_get_pn_data = extract_get_pn_data_tlv,
.send_pdev_get_pn_cmd = send_pdev_get_pn_cmd_tlv, .send_pdev_get_pn_cmd = send_pdev_get_pn_cmd_tlv,
.send_wlan_profile_enable_cmd = send_wlan_profile_enable_cmd_tlv, .send_wlan_profile_enable_cmd = send_wlan_profile_enable_cmd_tlv,
@@ -16942,6 +17294,9 @@ static void populate_tlv_events_id(uint32_t *event_ids)
event_ids[wmi_soc_set_dual_mac_config_resp_event_id] = event_ids[wmi_soc_set_dual_mac_config_resp_event_id] =
WMI_SOC_SET_DUAL_MAC_CONFIG_RESP_EVENTID; WMI_SOC_SET_DUAL_MAC_CONFIG_RESP_EVENTID;
event_ids[wmi_pdev_fips_event_id] = WMI_PDEV_FIPS_EVENTID; event_ids[wmi_pdev_fips_event_id] = WMI_PDEV_FIPS_EVENTID;
#ifdef WLAN_FEATURE_FIPS_BER_CCMGCM
event_ids[wmi_pdev_fips_extend_event_id] = WMI_PDEV_FIPS_EXTEND_EVENTID;
#endif
event_ids[wmi_pdev_csa_switch_count_status_event_id] = event_ids[wmi_pdev_csa_switch_count_status_event_id] =
WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID; WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID;
event_ids[wmi_vdev_ocac_complete_event_id] = event_ids[wmi_vdev_ocac_complete_event_id] =