From c0b9416daa53ffe9091f05f67bce5c46022ceca4 Mon Sep 17 00:00:00 2001 From: Srinivas Girigowda Date: Mon, 15 Nov 2021 22:16:29 -0800 Subject: [PATCH] qcacmn: Support TWT wmi APIs() with TWT componentization structs Currently, WMI APIs do not support new TWT public structures. If the TWT componentization feature is enabled, then extend the WMI APIs with TWT componentization structs. Change-Id: Ic987960e880376066b81881dc32ec96faf609cc6 CRs-Fixed: 3085377 --- wmi/inc/wmi_unified_priv.h | 100 ++- wmi/inc/wmi_unified_twt_api.h | 337 +++++++++- wmi/src/wmi_unified_twt_api.c | 292 +++++++++ wmi/src/wmi_unified_twt_tlv.c | 1144 ++++++++++++++++++++++++++++++++- 4 files changed, 1855 insertions(+), 18 deletions(-) diff --git a/wmi/inc/wmi_unified_priv.h b/wmi/inc/wmi_unified_priv.h index aa8651341c..a1c43328be 100644 --- a/wmi/inc/wmi_unified_priv.h +++ b/wmi/inc/wmi_unified_priv.h @@ -99,6 +99,10 @@ #include "wlan_mlo_mgr_public_structs.h" #endif +#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED) +#include +#endif + #define WMI_UNIFIED_MAX_EVENT 0x100 #ifdef WMI_EXT_DBG @@ -2390,8 +2394,102 @@ int (*wmi_check_and_pad_event)(void *os_handle, void *param_struc_ptr, int (*wmi_check_command_params)(void *os_handle, void *param_struc_ptr, uint32_t param_buf_len, uint32_t wmi_cmd_event_id); +#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED) +QDF_STATUS (*send_twt_enable_cmd)(wmi_unified_t wmi_handle, + struct twt_enable_param *params); -#ifdef WLAN_SUPPORT_TWT +QDF_STATUS (*send_twt_disable_cmd)(wmi_unified_t wmi_handle, + struct twt_disable_param *params); + +QDF_STATUS (*send_twt_add_dialog_cmd)(wmi_unified_t wmi_handle, + struct twt_add_dialog_param *params); + +QDF_STATUS (*send_twt_del_dialog_cmd)(wmi_unified_t wmi_handle, + struct twt_del_dialog_param *params); + +QDF_STATUS (*send_twt_pause_dialog_cmd)(wmi_unified_t wmi_handle, + struct twt_pause_dialog_cmd_param *params); + +QDF_STATUS (*send_twt_nudge_dialog_cmd)(wmi_unified_t wmi_handle, + struct twt_nudge_dialog_cmd_param *params); + +QDF_STATUS (*send_twt_resume_dialog_cmd)(wmi_unified_t wmi_handle, + struct twt_resume_dialog_cmd_param *params); +#ifdef WLAN_SUPPORT_BCAST_TWT +QDF_STATUS (*send_twt_btwt_invite_sta_cmd)(wmi_unified_t wmi_handle, + struct twt_btwt_invite_sta_cmd_param *params); + +QDF_STATUS (*send_twt_btwt_remove_sta_cmd)(wmi_unified_t wmi_handle, + struct twt_btwt_remove_sta_cmd_param *params); +#endif + +QDF_STATUS (*extract_twt_enable_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_enable_complete_event_param *params); + +QDF_STATUS (*extract_twt_disable_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_disable_complete_event_param *params); + +QDF_STATUS (*extract_twt_add_dialog_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_add_dialog_complete_event_param *params); + +QDF_STATUS (*extract_twt_add_dialog_comp_additional_params) + ( + wmi_unified_t wmi_handle, uint8_t *evt_buf, + uint32_t evt_buf_len, uint32_t idx, + struct twt_add_dialog_additional_params *additional_params + ); + +QDF_STATUS (*extract_twt_del_dialog_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_del_dialog_complete_event_param *params); + +QDF_STATUS (*extract_twt_pause_dialog_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_pause_dialog_complete_event_param *params); + +QDF_STATUS (*extract_twt_nudge_dialog_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_nudge_dialog_complete_event_param *params); + +QDF_STATUS (*extract_twt_resume_dialog_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_resume_dialog_complete_event_param *params); + +QDF_STATUS (*extract_twt_notify_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_notify_event_param *params); +QDF_STATUS (*extract_twt_ack_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_ack_complete_event_param *params); +#ifdef WLAN_SUPPORT_BCAST_TWT +QDF_STATUS (*extract_twt_btwt_invite_sta_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_btwt_invite_sta_complete_event_param *params); + +QDF_STATUS (*extract_twt_btwt_remove_sta_comp_event)(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_btwt_remove_sta_complete_event_param *params); +#endif + +QDF_STATUS(*extract_twt_session_stats_event) + ( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param *params + ); +QDF_STATUS(*extract_twt_session_stats_data) + ( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param *params, + struct twt_session_stats_info *session, + uint32_t idx + ); + +#elif defined(WLAN_SUPPORT_TWT) QDF_STATUS (*send_twt_enable_cmd)(wmi_unified_t wmi_handle, struct wmi_twt_enable_param *params); diff --git a/wmi/inc/wmi_unified_twt_api.h b/wmi/inc/wmi_unified_twt_api.h index 9233f885a5..c8f38018b3 100644 --- a/wmi/inc/wmi_unified_twt_api.h +++ b/wmi/inc/wmi_unified_twt_api.h @@ -1,5 +1,6 @@ /* * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. + * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the @@ -23,8 +24,331 @@ #define _WMI_UNIFIED_TWT_API_H_ #include "wmi_unified_twt_param.h" +#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED) +#include +/** + * wmi_unified_twt_enable_cmd() - Send WMI command to Enable TWT + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS +wmi_unified_twt_enable_cmd(wmi_unified_t wmi_handle, + struct twt_enable_param *params); +/** + * wmi_unified_twt_disable_cmd() - Send WMI command to disable TWT + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS +wmi_unified_twt_disable_cmd(wmi_unified_t wmi_handle, + struct twt_disable_param *params); +/** + * wmi_unified_twt_add_dialog_cmd() - Send WMI command to add TWT dialog + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS +wmi_unified_twt_add_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_add_dialog_param *params); + +/** + * wmi_unified_twt_del_dialog_cmd() - Send WMI command to delete TWT dialog + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS +wmi_unified_twt_del_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_del_dialog_param *params); + +/** + * wmi_unified_twt_pause_dialog_cmd() - Send WMI command to pause TWT dialog + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS +wmi_unified_twt_pause_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_pause_dialog_cmd_param *params); + +/** + * wmi_unified_twt_nudge_dialog_cmd() - Send WMI command to nudge TWT dialog + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS +wmi_unified_twt_nudge_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_nudge_dialog_cmd_param *params); + +/** + * wmi_unified_twt_resume_dialog_cmd() - Send WMI command to resume TWT dialog + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_unified_twt_resume_dialog_cmd( + wmi_unified_t wmi_handle, + struct twt_resume_dialog_cmd_param *params); + +#ifdef WLAN_SUPPORT_BCAST_TWT +/** + * wmi_unified_twt_btwt_invite_sta_cmd() - Send WMI command for bTWT sta + * invitation + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_unified_twt_btwt_invite_sta_cmd( + wmi_unified_t wmi_handle, + struct twt_btwt_invite_sta_cmd_param *params); + +/** + * wmi_unified_twt_btwt_remove_sta_cmd() - Send WMI command for bTWT sta kickoff + * @wmi_handle: wmi handle + * @params: Parameters to be configured + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_unified_twt_btwt_remove_sta_cmd( + wmi_unified_t wmi_handle, + struct twt_btwt_remove_sta_cmd_param *params); +#endif + +/** + * wmi_extract_twt_enable_comp_event() - Extract WMI event params for TWT enable + * completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_enable_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_enable_complete_event_param *params); + +/** + * wmi_extract_twt_disable_comp_event() - Extract WMI event params for TWT + * disable completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_disable_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_disable_complete_event_param *params); + +/** + * wmi_extract_twt_add_dialog_comp_event() - Extract WMI event params for TWT + * add dialog completion event + * @wmi_hdl: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_add_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_add_dialog_complete_event_param *params); + +/** + * wmi_extract_twt_add_dialog_comp_additional_params() - Extracts additional + * twt parameters, as part of add dialog completion event + * @wmi_hdl: wmi handle + * @evt_buf: Pointer event buffer + * @evt_buf_len: length of the add dialog event buffer + * @idx: index of num_twt_params to extract + * @additional_params: additional parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_add_dialog_comp_additional_params( + wmi_unified_t wmi_handle, uint8_t *evt_buf, + uint32_t evt_buf_len, uint32_t idx, + struct twt_add_dialog_additional_params *additional_params); + +/** + * wmi_extract_twt_del_dialog_comp_event() - Extract WMI event params for TWT + * delete dialog completion event + * @wmi_hdl: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_del_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_del_dialog_complete_event_param *params); + +/** + * wmi_extract_twt_pause_dialog_comp_event() - Extract WMI event params for TWT + * pause dialog completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_pause_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_pause_dialog_complete_event_param *params); + +/** + * wmi_extract_twt_nudge_dialog_comp_event() - Extract WMI event params for TWT + * nudge dialog completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_nudge_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_nudge_dialog_complete_event_param *params); + +/** + * wmi_extract_twt_resume_dialog_comp_event() - Extract WMI event params for TWT + * resume dialog completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_resume_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_resume_dialog_complete_event_param *params); + +/** + * wmi_extract_twt_notify_event() - Extract WMI event params for TWT + * notify event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_notify_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_notify_event_param *params); + +#ifdef WLAN_SUPPORT_BCAST_TWT +/** + * wmi_extract_twt_btwt_invite_sta_comp_event() - Extract WMI event params for + * BTWT sta invitation completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_btwt_invite_sta_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_btwt_invite_sta_complete_event_param *params); + +/** + * wmi_extract_twt_btwt_remove_sta_comp_event() - Extract WMI event params for + * BTWT sta kickoff completion event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_btwt_remove_sta_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_btwt_remove_sta_complete_event_param *params); +#endif + +/** + * wmi_extract_twt_session_stats_event() - Extract WMI event params for TWT + * session stats event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_session_stats_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param *params); + +/** + * wmi_extract_twt_session_stats_data() - Extract one TWT session from TWT + * session stats event + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * @session: Session struct to save one TWT session + * @idx: TWT session index + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_session_stats_data( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param *params, + struct twt_session_stats_info *session, + uint32_t idx); + +void wmi_twt_attach_tlv(struct wmi_unified *wmi_handle); + +/** + * wmi_extract_twt_cap_service_ready_ext2: Extract TWT bitmap value + * received through extended + * service ready2 event + * @wmi_handle: WMI handle + * @evt_buf: Event buffer + * @param: Pointer to TWT bitmap param + * + * Return: QDF_STATUS_SUCCESS for success or error code + */ +QDF_STATUS wmi_extract_twt_cap_service_ready_ext2( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct wmi_twt_cap_bitmap_params *params); + +/** + * wmi_extract_twt_ack_comp_event() - Extract WMI event params for TWT ack event + * + * @wmi_handle: wmi handle + * @evt_buf: Pointer event buffer + * @params: Parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure + */ +QDF_STATUS wmi_extract_twt_ack_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_ack_complete_event_param *param); +#elif defined(WLAN_SUPPORT_TWT) /** * wmi_unified_twt_enable_cmd() - Send WMI command to Enable TWT * @wmi_handle: wmi handle @@ -317,14 +641,7 @@ QDF_STATUS wmi_extract_twt_session_stats_data( struct wmi_host_twt_session_stats_info *session, uint32_t idx); -#ifdef WLAN_SUPPORT_TWT void wmi_twt_attach_tlv(struct wmi_unified *wmi_handle); -#else -static void wmi_twt_attach_tlv(struct wmi_unified *wmi_handle) -{ - return; -} -#endif /** * wmi_extract_twt_cap_service_ready_ext2: Extract TWT bitmap value @@ -354,5 +671,9 @@ QDF_STATUS wmi_extract_twt_ack_comp_event( wmi_unified_t wmi_handle, uint8_t *evt_buf, struct wmi_twt_ack_complete_event_param *param); - +#else +static inline void wmi_twt_attach_tlv(struct wmi_unified *wmi_handle) +{ +} +#endif #endif /* _WMI_UNIFIED_TWT_API_H_ */ diff --git a/wmi/src/wmi_unified_twt_api.c b/wmi/src/wmi_unified_twt_api.c index 7b98165f0f..8a50c44f47 100644 --- a/wmi/src/wmi_unified_twt_api.c +++ b/wmi/src/wmi_unified_twt_api.c @@ -1,5 +1,6 @@ /* * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. + * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the @@ -22,7 +23,297 @@ #include "wmi_unified_priv.h" #include "wmi_unified_twt_api.h" +#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED) +#include +QDF_STATUS +wmi_unified_twt_enable_cmd(wmi_unified_t wmi_handle, + struct twt_enable_param *params) +{ + if (wmi_handle->ops->send_twt_enable_cmd) + return wmi_handle->ops->send_twt_enable_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS +wmi_unified_twt_disable_cmd(wmi_unified_t wmi_handle, + struct twt_disable_param *params) +{ + if (wmi_handle->ops->send_twt_disable_cmd) + return wmi_handle->ops->send_twt_disable_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS +wmi_unified_twt_add_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_add_dialog_param *params) +{ + if (wmi_handle->ops->send_twt_add_dialog_cmd) + return wmi_handle->ops->send_twt_add_dialog_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS +wmi_unified_twt_del_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_del_dialog_param *params) +{ + if (wmi_handle->ops->send_twt_del_dialog_cmd) + return wmi_handle->ops->send_twt_del_dialog_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS +wmi_unified_twt_pause_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_pause_dialog_cmd_param *params) +{ + if (wmi_handle->ops->send_twt_pause_dialog_cmd) + return wmi_handle->ops->send_twt_pause_dialog_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS +wmi_unified_twt_nudge_dialog_cmd(wmi_unified_t wmi_handle, + struct twt_nudge_dialog_cmd_param *params) +{ + if (wmi_handle->ops->send_twt_nudge_dialog_cmd) + return wmi_handle->ops->send_twt_nudge_dialog_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_unified_twt_resume_dialog_cmd( + wmi_unified_t wmi_handle, + struct twt_resume_dialog_cmd_param *params) +{ + if (wmi_handle->ops->send_twt_resume_dialog_cmd) + return wmi_handle->ops->send_twt_resume_dialog_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +#ifdef WLAN_SUPPORT_BCAST_TWT +QDF_STATUS wmi_unified_twt_btwt_invite_sta_cmd( + wmi_unified_t wmi_handle, + struct twt_btwt_invite_sta_cmd_param *params) +{ + if (wmi_handle->ops->send_twt_btwt_invite_sta_cmd) + return wmi_handle->ops->send_twt_btwt_invite_sta_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_unified_twt_btwt_remove_sta_cmd( + wmi_unified_t wmi_handle, + struct twt_btwt_remove_sta_cmd_param *params) +{ + if (wmi_handle->ops->send_twt_btwt_remove_sta_cmd) + return wmi_handle->ops->send_twt_btwt_remove_sta_cmd( + wmi_handle, params); + + return QDF_STATUS_E_FAILURE; +} +#endif + +QDF_STATUS wmi_extract_twt_enable_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_enable_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_enable_comp_event) + return wmi_handle->ops->extract_twt_enable_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_disable_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_disable_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_disable_comp_event) + return wmi_handle->ops->extract_twt_disable_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_add_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_add_dialog_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_add_dialog_comp_event) + return wmi_handle->ops->extract_twt_add_dialog_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_add_dialog_comp_additional_params( + wmi_unified_t wmi_handle, uint8_t *evt_buf, + uint32_t evt_buf_len, uint32_t idx, + struct twt_add_dialog_additional_params *additional_params) +{ + if (wmi_handle->ops->extract_twt_add_dialog_comp_additional_params) + return wmi_handle->ops-> + extract_twt_add_dialog_comp_additional_params( + wmi_handle, evt_buf, evt_buf_len, idx, + additional_params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_del_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_del_dialog_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_del_dialog_comp_event) + return wmi_handle->ops->extract_twt_del_dialog_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_pause_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_pause_dialog_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_pause_dialog_comp_event) + return wmi_handle->ops->extract_twt_pause_dialog_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_nudge_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_nudge_dialog_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_nudge_dialog_comp_event) + return wmi_handle->ops->extract_twt_nudge_dialog_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_resume_dialog_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_resume_dialog_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_resume_dialog_comp_event) + return wmi_handle->ops->extract_twt_resume_dialog_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_notify_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_notify_event_param *params) +{ + if (wmi_handle->ops->extract_twt_notify_event) + return wmi_handle->ops->extract_twt_notify_event(wmi_handle, + evt_buf, + params); + + return QDF_STATUS_E_FAILURE; +} + +#ifdef WLAN_SUPPORT_BCAST_TWT +QDF_STATUS wmi_extract_twt_btwt_invite_sta_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_btwt_invite_sta_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_btwt_invite_sta_comp_event) + return wmi_handle->ops->extract_twt_btwt_invite_sta_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_btwt_remove_sta_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_btwt_remove_sta_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_btwt_remove_sta_comp_event) + return wmi_handle->ops->extract_twt_btwt_remove_sta_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} +#endif + +QDF_STATUS wmi_extract_twt_session_stats_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param *params) +{ + if (wmi_handle->ops->extract_twt_session_stats_event) + return wmi_handle->ops->extract_twt_session_stats_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_session_stats_data( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param *params, + struct twt_session_stats_info *session, + uint32_t idx) +{ + if (wmi_handle->ops->extract_twt_session_stats_data) + return wmi_handle->ops->extract_twt_session_stats_data( + wmi_handle, evt_buf, params, session, idx); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_cap_service_ready_ext2( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct wmi_twt_cap_bitmap_params *params) +{ + if (wmi_handle->ops->extract_twt_cap_service_ready_ext2) + return wmi_handle->ops->extract_twt_cap_service_ready_ext2( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} + +QDF_STATUS wmi_extract_twt_ack_comp_event( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_ack_complete_event_param *params) +{ + if (wmi_handle->ops->extract_twt_ack_comp_event) + return wmi_handle->ops->extract_twt_ack_comp_event( + wmi_handle, evt_buf, params); + + return QDF_STATUS_E_FAILURE; +} +#elif WLAN_SUPPORT_TWT QDF_STATUS wmi_unified_twt_enable_cmd(wmi_unified_t wmi_handle, struct wmi_twt_enable_param *params) @@ -310,3 +601,4 @@ QDF_STATUS wmi_extract_twt_ack_comp_event( return QDF_STATUS_E_FAILURE; } +#endif diff --git a/wmi/src/wmi_unified_twt_tlv.c b/wmi/src/wmi_unified_twt_tlv.c index a9885f0f22..e6a0ddaf37 100644 --- a/wmi/src/wmi_unified_twt_tlv.c +++ b/wmi/src/wmi_unified_twt_tlv.c @@ -1,5 +1,6 @@ /* * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. + * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the @@ -22,6 +23,1137 @@ #include "wmi_unified_twt_param.h" #include "wmi_unified_twt_api.h" +#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED) +static QDF_STATUS send_twt_enable_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_enable_param *params) +{ + wmi_twt_enable_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_enable_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_enable_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_enable_cmd_fixed_param)); + + cmd->pdev_id = + wmi_handle->ops->convert_pdev_id_host_to_target( + wmi_handle, + params->pdev_id); + cmd->sta_cong_timer_ms = params->sta_cong_timer_ms; + cmd->mbss_support = params->mbss_support; + cmd->default_slot_size = params->default_slot_size; + cmd->congestion_thresh_setup = params->congestion_thresh_setup; + cmd->congestion_thresh_teardown = params->congestion_thresh_teardown; + cmd->congestion_thresh_critical = params->congestion_thresh_critical; + cmd->interference_thresh_teardown = + params->interference_thresh_teardown; + cmd->interference_thresh_setup = params->interference_thresh_setup; + cmd->min_no_sta_setup = params->min_no_sta_setup; + cmd->min_no_sta_teardown = params->min_no_sta_teardown; + cmd->no_of_bcast_mcast_slots = params->no_of_bcast_mcast_slots; + cmd->min_no_twt_slots = params->min_no_twt_slots; + cmd->max_no_sta_twt = params->max_no_sta_twt; + cmd->mode_check_interval = params->mode_check_interval; + cmd->add_sta_slot_interval = params->add_sta_slot_interval; + cmd->remove_sta_slot_interval = params->remove_sta_slot_interval; + + TWT_EN_DIS_FLAGS_SET_BTWT(cmd->flags, params->b_twt_enable); + TWT_EN_DIS_FLAGS_SET_L_MBSSID(cmd->flags, + params->b_twt_legacy_mbss_enable); + TWT_EN_DIS_FLAGS_SET_AX_MBSSID(cmd->flags, + params->b_twt_ax_mbss_enable); + if (params->ext_conf_present) { + TWT_EN_DIS_FLAGS_SET_SPLIT_CONFIG(cmd->flags, 1); + TWT_EN_DIS_FLAGS_SET_REQ_RESP(cmd->flags, params->twt_role); + TWT_EN_DIS_FLAGS_SET_I_B_TWT(cmd->flags, params->twt_oper); + } + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_ENABLE_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_err("Failed to send WMI_TWT_ENABLE_CMDID"); + wmi_buf_free(buf); + } + + return status; +} + +static QDF_STATUS send_twt_disable_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_disable_param *params) +{ + wmi_twt_disable_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_disable_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_disable_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_disable_cmd_fixed_param)); + + cmd->pdev_id = + wmi_handle->ops->convert_pdev_id_host_to_target( + wmi_handle, + params->pdev_id); + if (params->ext_conf_present) { + TWT_EN_DIS_FLAGS_SET_SPLIT_CONFIG(cmd->flags, 1); + TWT_EN_DIS_FLAGS_SET_REQ_RESP(cmd->flags, params->twt_role); + TWT_EN_DIS_FLAGS_SET_I_B_TWT(cmd->flags, params->twt_oper); + } + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_DISABLE_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_err("Failed to send WMI_TWT_DISABLE_CMDID"); + wmi_buf_free(buf); + } + + return status; +} + +#ifdef WLAN_SUPPORT_BCAST_TWT +static void +twt_add_dialog_set_bcast_twt_params(struct twt_add_dialog_param *params, + wmi_twt_add_dialog_cmd_fixed_param *cmd) +{ + TWT_FLAGS_SET_BTWT_ID0(cmd->flags, params->flag_b_twt_id0); + cmd->b_twt_persistence = params->b_twt_persistence; + cmd->b_twt_recommendation = params->b_twt_recommendation; +} +#else +static void +twt_add_dialog_set_bcast_twt_params(struct twt_add_dialog_param *params, + wmi_twt_add_dialog_cmd_fixed_param *cmd) +{ +} +#endif + +static QDF_STATUS +send_twt_add_dialog_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_add_dialog_param *params) +{ + wmi_twt_add_dialog_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_add_dialog_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_add_dialog_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_add_dialog_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + cmd->wake_intvl_us = params->wake_intvl_us; + cmd->wake_intvl_mantis = params->wake_intvl_mantis; + cmd->wake_dura_us = params->wake_dura_us; + cmd->sp_offset_us = params->sp_offset_us; + cmd->min_wake_intvl_us = params->min_wake_intvl_us; + cmd->max_wake_intvl_us = params->max_wake_intvl_us; + cmd->min_wake_dura_us = params->min_wake_dura_us; + cmd->max_wake_dura_us = params->max_wake_dura_us; + cmd->sp_start_tsf_lo = (uint32_t)(params->wake_time_tsf & 0xFFFFFFFF); + cmd->sp_start_tsf_hi = (uint32_t)(params->wake_time_tsf >> 32); + cmd->announce_timeout_us = params->announce_timeout_us; + TWT_FLAGS_SET_CMD(cmd->flags, params->twt_cmd); + TWT_FLAGS_SET_BROADCAST(cmd->flags, params->flag_bcast); + TWT_FLAGS_SET_TRIGGER(cmd->flags, params->flag_trigger); + TWT_FLAGS_SET_FLOW_TYPE(cmd->flags, params->flag_flow_type); + TWT_FLAGS_SET_PROTECTION(cmd->flags, params->flag_protection); + + twt_add_dialog_set_bcast_twt_params(params, cmd); + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_ADD_DIALOG_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_err("Failed to send WMI_TWT_ADD_DIALOG_CMDID"); + wmi_buf_free(buf); + } + + return status; +} + +#ifdef WLAN_SUPPORT_BCAST_TWT +static void +twt_del_dialog_set_bcast_twt_params(struct twt_del_dialog_param *params, + wmi_twt_del_dialog_cmd_fixed_param *cmd) +{ + cmd->b_twt_persistence = params->b_twt_persistence; +} +#else +static void +twt_del_dialog_set_bcast_twt_params(struct twt_del_dialog_param *params, + wmi_twt_del_dialog_cmd_fixed_param *cmd) +{ +} +#endif + +static QDF_STATUS +send_twt_del_dialog_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_del_dialog_param *params) +{ + wmi_twt_del_dialog_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_del_dialog_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_del_dialog_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_del_dialog_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + + twt_del_dialog_set_bcast_twt_params(params, cmd); + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_DEL_DIALOG_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_err("Failed to send WMI_TWT_DEL_DIALOG_CMDID"); + wmi_buf_free(buf); + } + + return status; +} + +static QDF_STATUS +send_twt_pause_dialog_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_pause_dialog_cmd_param *params) +{ + wmi_twt_pause_dialog_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_pause_dialog_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_pause_dialog_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_pause_dialog_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_PAUSE_DIALOG_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_err("Failed to send WMI_TWT_PAUSE_DIALOG_CMDID"); + wmi_buf_free(buf); + } + + return status; +} + +static QDF_STATUS +send_twt_nudge_dialog_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_nudge_dialog_cmd_param *params) +{ + wmi_twt_nudge_dialog_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) + return QDF_STATUS_E_FAILURE; + + cmd = (wmi_twt_nudge_dialog_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_nudge_dialog_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_nudge_dialog_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + cmd->suspend_duration_ms = params->suspend_duration / 1000; + cmd->next_twt_size = params->next_twt_size; + + wmi_debug("vdev_id: %d dialog_id: %d duration(in ms): %u next_twt_size: %d " + "peer_macaddr: "QDF_MAC_ADDR_FMT, cmd->vdev_id, + cmd->dialog_id, cmd->suspend_duration_ms, cmd->next_twt_size, + QDF_MAC_ADDR_REF(params->peer_macaddr.bytes)); + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_NUDGE_DIALOG_CMDID); + if (QDF_IS_STATUS_ERROR(status)) + wmi_buf_free(buf); + + return status; +} + +static QDF_STATUS send_twt_resume_dialog_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_resume_dialog_cmd_param *params) +{ + wmi_twt_resume_dialog_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_resume_dialog_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_resume_dialog_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_resume_dialog_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + cmd->sp_offset_us = params->sp_offset_us; + cmd->next_twt_size = params->next_twt_size; + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_RESUME_DIALOG_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_err("Failed to send WMI_TWT_RESUME_DIALOG_CMDID"); + wmi_buf_free(buf); + } + + return status; +} + +#ifdef WLAN_SUPPORT_BCAST_TWT +static QDF_STATUS +send_twt_btwt_invite_sta_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_btwt_invite_sta_cmd_param *params) +{ + wmi_twt_btwt_invite_sta_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_btwt_invite_sta_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_btwt_invite_sta_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_btwt_invite_sta_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_BTWT_INVITE_STA_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_buf_free(buf); + wmi_err("Failed to send WMI_TWT_BTWT_INVITE_STA_CMDID"); + } + + return status; +} + +static QDF_STATUS +send_twt_btwt_remove_sta_cmd_tlv(wmi_unified_t wmi_handle, + struct twt_btwt_remove_sta_cmd_param + *params) +{ + wmi_twt_btwt_remove_sta_cmd_fixed_param *cmd; + wmi_buf_t buf; + QDF_STATUS status; + + buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); + if (!buf) { + wmi_err("Failed to allocate memory"); + return QDF_STATUS_E_FAILURE; + } + + cmd = (wmi_twt_btwt_remove_sta_cmd_fixed_param *)wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_twt_btwt_remove_sta_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_twt_btwt_remove_sta_cmd_fixed_param)); + + cmd->vdev_id = params->vdev_id; + WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, + &cmd->peer_macaddr); + cmd->dialog_id = params->dialog_id; + + status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), + WMI_TWT_BTWT_REMOVE_STA_CMDID); + if (QDF_IS_STATUS_ERROR(status)) { + wmi_buf_free(buf); + wmi_err("Failed to send WMI_TWT_BTWT_REMOVE_STA_CMDID"); + } + + return status; +} +#endif + +static enum HOST_TWT_ENABLE_STATUS +wmi_twt_enable_status_to_host_twt_status(WMI_ENABLE_TWT_STATUS_T status) +{ + switch (status) { + case WMI_ENABLE_TWT_STATUS_OK: + return HOST_TWT_ENABLE_STATUS_OK; + case WMI_ENABLE_TWT_STATUS_ALREADY_ENABLED: + return HOST_TWT_ENABLE_STATUS_ALREADY_ENABLED; + case WMI_ENABLE_TWT_STATUS_NOT_READY: + return HOST_TWT_ENABLE_STATUS_NOT_READY; + case WMI_ENABLE_TWT_INVALID_PARAM: + return HOST_TWT_ENABLE_INVALID_PARAM; + default: + return HOST_TWT_ENABLE_STATUS_UNKNOWN_ERROR; + } +} + +static QDF_STATUS extract_twt_enable_comp_event_tlv(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_enable_complete_event_param *params) +{ + WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_enable_complete_event_fixed_param *ev; + + param_buf = (WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->pdev_id = + wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, + ev->pdev_id); + params->status = wmi_twt_enable_status_to_host_twt_status(ev->status); + + return QDF_STATUS_SUCCESS; +} + +static enum HOST_TWT_DISABLE_STATUS +wmi_twt_disable_status_to_host_twt_status(WMI_DISABLE_TWT_STATUS_T status) +{ + switch (status) { + case WMI_DISABLE_TWT_STATUS_OK: + return HOST_TWT_DISABLE_STATUS_OK; + case WMI_DISABLE_TWT_STATUS_ROAM_IN_PROGRESS: + return HOST_TWT_DISABLE_STATUS_ROAM_IN_PROGRESS; + case WMI_DISABLE_TWT_STATUS_CHAN_SW_IN_PROGRESS: + return HOST_TWT_DISABLE_STATUS_CHAN_SW_IN_PROGRESS; + case WMI_DISABLE_TWT_STATUS_SCAN_IN_PROGRESS: + return HOST_TWT_DISABLE_STATUS_SCAN_IN_PROGRESS; + default: + return HOST_TWT_DISABLE_STATUS_UNKNOWN_ERROR; + } +} + +static QDF_STATUS extract_twt_disable_comp_event_tlv(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_disable_complete_event_param *params) +{ + WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_disable_complete_event_fixed_param *ev; + + param_buf = (WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->pdev_id = + wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, + ev->pdev_id); + params->status = wmi_twt_disable_status_to_host_twt_status(ev->status); + + return QDF_STATUS_SUCCESS; +} + +static enum HOST_TWT_ADD_STATUS +wmi_get_converted_twt_add_dialog_status(WMI_ADD_TWT_STATUS_T tgt_status) +{ + switch (tgt_status) { + case WMI_ADD_TWT_STATUS_OK: + return HOST_TWT_ADD_STATUS_OK; + case WMI_ADD_TWT_STATUS_TWT_NOT_ENABLED: + return HOST_TWT_ADD_STATUS_TWT_NOT_ENABLED; + case WMI_ADD_TWT_STATUS_USED_DIALOG_ID: + return HOST_TWT_ADD_STATUS_USED_DIALOG_ID; + case WMI_ADD_TWT_STATUS_INVALID_PARAM: + return HOST_TWT_ADD_STATUS_INVALID_PARAM; + case WMI_ADD_TWT_STATUS_NOT_READY: + return HOST_TWT_ADD_STATUS_NOT_READY; + case WMI_ADD_TWT_STATUS_NO_RESOURCE: + return HOST_TWT_ADD_STATUS_NO_RESOURCE; + case WMI_ADD_TWT_STATUS_NO_ACK: + return HOST_TWT_ADD_STATUS_NO_ACK; + case WMI_ADD_TWT_STATUS_NO_RESPONSE: + return HOST_TWT_ADD_STATUS_NO_RESPONSE; + case WMI_ADD_TWT_STATUS_DENIED: + return HOST_TWT_ADD_STATUS_DENIED; + case WMI_ADD_TWT_STATUS_AP_PARAMS_NOT_IN_RANGE: + return HOST_TWT_ADD_STATUS_AP_PARAMS_NOT_IN_RANGE; + case WMI_ADD_TWT_STATUS_AP_IE_VALIDATION_FAILED: + return HOST_TWT_ADD_STATUS_AP_IE_VALIDATION_FAILED; + case WMI_ADD_TWT_STATUS_ROAM_IN_PROGRESS: + return HOST_TWT_ADD_STATUS_ROAM_IN_PROGRESS; + case WMI_ADD_TWT_STATUS_CHAN_SW_IN_PROGRESS: + return HOST_TWT_ADD_STATUS_CHAN_SW_IN_PROGRESS; + case WMI_ADD_TWT_STATUS_SCAN_IN_PROGRESS: + return HOST_TWT_ADD_STATUS_SCAN_IN_PROGRESS; + default: + return HOST_TWT_ADD_STATUS_UNKNOWN_ERROR; + } +} + +/** + * extract_twt_add_dialog_comp_event_tlv - Extacts twt add dialog complete wmi + * event from firmware + * @wmi_hande: WMI handle + * @evt_buf: Pointer to wmi event buf of twt add dialog complete event + * @params: Pointer to store the extracted parameters + * + * Return: QDF_STATUS_SUCCESS on success or QDF STATUS error values on failure + */ +static QDF_STATUS extract_twt_add_dialog_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_add_dialog_complete_event_param *params) +{ + WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_add_dialog_complete_event_fixed_param *ev; + + param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->status = wmi_get_converted_twt_add_dialog_status(ev->status); + params->dialog_id = ev->dialog_id; + params->num_additional_twt_params = param_buf->num_twt_params; + + return QDF_STATUS_SUCCESS; +} + +/** + * extract_twt_add_dialog_comp_additional_parameters() - Extracts additional twt + * twt parameters, as part of add dialog completion event + * @wmi_hdl: wmi handle + * @evt_buf: Pointer event buffer + * @evt_buf_len: length of the add dialog event buffer + * @idx: index of num_twt_params + * @additional_params: twt additional parameters to extract + * + * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_INVAL for failure + */ +static QDF_STATUS extract_twt_add_dialog_comp_additional_parameters +( + wmi_unified_t wmi_handle, uint8_t *evt_buf, + uint32_t evt_buf_len, uint32_t idx, + struct twt_add_dialog_additional_params *additional_params +) +{ + WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_add_dialog_complete_event_fixed_param *ev; + uint32_t flags = 0; + uint32_t expected_len; + + param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + if (idx >= param_buf->num_twt_params) { + wmi_err("Invalid idx %d while num_twt_params = %d", + idx, param_buf->num_twt_params); + return QDF_STATUS_E_INVAL; + } + + if (!param_buf->twt_params) { + wmi_err("Unable to extract additional twt parameters"); + return QDF_STATUS_E_INVAL; + } + + expected_len = (sizeof(wmi_twt_add_dialog_complete_event_fixed_param) + + WMI_TLV_HDR_SIZE + (param_buf->num_twt_params * + sizeof(wmi_twt_add_dialog_additional_params))); + + if (evt_buf_len != expected_len) { + wmi_err("Got invalid len data from FW %d expected %d", + evt_buf_len, expected_len); + return QDF_STATUS_E_INVAL; + } + + flags = param_buf->twt_params[idx].flags; + additional_params->twt_cmd = TWT_FLAGS_GET_CMD(flags); + additional_params->bcast = TWT_FLAGS_GET_BROADCAST(flags); + additional_params->trig_en = TWT_FLAGS_GET_TRIGGER(flags); + additional_params->announce = TWT_FLAGS_GET_FLOW_TYPE(flags); + additional_params->protection = TWT_FLAGS_GET_PROTECTION(flags); + additional_params->b_twt_id0 = TWT_FLAGS_GET_BTWT_ID0(flags); + additional_params->info_frame_disabled = + TWT_FLAGS_GET_TWT_INFO_FRAME_DISABLED(flags); + additional_params->wake_dur_us = param_buf->twt_params[idx].wake_dur_us; + additional_params->wake_intvl_us = + param_buf->twt_params[idx].wake_intvl_us; + additional_params->sp_offset_us = + param_buf->twt_params[idx].sp_offset_us; + additional_params->sp_tsf_us_lo = + param_buf->twt_params[idx].sp_tsf_us_lo; + additional_params->sp_tsf_us_hi = + param_buf->twt_params[idx].sp_tsf_us_hi; + + return QDF_STATUS_SUCCESS; +} + +static enum HOST_TWT_DEL_STATUS +wmi_get_converted_twt_del_dialog_status(WMI_DEL_TWT_STATUS_T tgt_status) +{ + switch (tgt_status) { + case WMI_DEL_TWT_STATUS_OK: + return HOST_TWT_DEL_STATUS_OK; + case WMI_DEL_TWT_STATUS_DIALOG_ID_NOT_EXIST: + return HOST_TWT_DEL_STATUS_DIALOG_ID_NOT_EXIST; + case WMI_DEL_TWT_STATUS_INVALID_PARAM: + return HOST_TWT_DEL_STATUS_INVALID_PARAM; + case WMI_DEL_TWT_STATUS_DIALOG_ID_BUSY: + return HOST_TWT_DEL_STATUS_DIALOG_ID_BUSY; + case WMI_DEL_TWT_STATUS_NO_RESOURCE: + return HOST_TWT_DEL_STATUS_NO_RESOURCE; + case WMI_DEL_TWT_STATUS_NO_ACK: + return HOST_TWT_DEL_STATUS_NO_ACK; + case WMI_DEL_TWT_STATUS_PEER_INIT_TEARDOWN: + return HOST_TWT_DEL_STATUS_PEER_INIT_TEARDOWN; + case WMI_DEL_TWT_STATUS_ROAMING: + return HOST_TWT_DEL_STATUS_ROAMING; + case WMI_DEL_TWT_STATUS_CONCURRENCY: + return HOST_TWT_DEL_STATUS_CONCURRENCY; + case WMI_DEL_TWT_STATUS_CHAN_SW_IN_PROGRESS: + return HOST_TWT_DEL_STATUS_CHAN_SW_IN_PROGRESS; + case WMI_DEL_TWT_STATUS_SCAN_IN_PROGRESS: + return HOST_TWT_DEL_STATUS_SCAN_IN_PROGRESS; + default: + return HOST_TWT_DEL_STATUS_UNKNOWN_ERROR; + } +} + +static QDF_STATUS extract_twt_del_dialog_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_del_dialog_complete_event_param *params) +{ + WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_del_dialog_complete_event_fixed_param *ev; + + param_buf = (WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->dialog_id = ev->dialog_id; + params->status = wmi_get_converted_twt_del_dialog_status(ev->status); + + return QDF_STATUS_SUCCESS; +} + +static enum HOST_TWT_PAUSE_STATUS +wmi_twt_pause_status_to_host_twt_status(WMI_PAUSE_TWT_STATUS_T status) +{ + switch (status) { + case WMI_PAUSE_TWT_STATUS_OK: + return HOST_TWT_PAUSE_STATUS_OK; + case WMI_PAUSE_TWT_STATUS_DIALOG_ID_NOT_EXIST: + return HOST_TWT_PAUSE_STATUS_DIALOG_ID_NOT_EXIST; + case WMI_PAUSE_TWT_STATUS_INVALID_PARAM: + return HOST_TWT_PAUSE_STATUS_INVALID_PARAM; + case WMI_PAUSE_TWT_STATUS_DIALOG_ID_BUSY: + return HOST_TWT_PAUSE_STATUS_DIALOG_ID_BUSY; + case WMI_PAUSE_TWT_STATUS_NO_RESOURCE: + return HOST_TWT_PAUSE_STATUS_NO_RESOURCE; + case WMI_PAUSE_TWT_STATUS_NO_ACK: + return HOST_TWT_PAUSE_STATUS_NO_ACK; + case WMI_PAUSE_TWT_STATUS_ALREADY_PAUSED: + return HOST_TWT_PAUSE_STATUS_ALREADY_PAUSED; + case WMI_PAUSE_TWT_STATUS_CHAN_SW_IN_PROGRESS: + return HOST_TWT_PAUSE_STATUS_CHAN_SW_IN_PROGRESS; + case WMI_PAUSE_TWT_STATUS_ROAM_IN_PROGRESS: + return HOST_TWT_PAUSE_STATUS_ROAM_IN_PROGRESS; + case WMI_PAUSE_TWT_STATUS_SCAN_IN_PROGRESS: + return HOST_TWT_PAUSE_STATUS_SCAN_IN_PROGRESS; + default: + return HOST_TWT_PAUSE_STATUS_UNKNOWN_ERROR; + } +} + +static QDF_STATUS extract_twt_pause_dialog_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_pause_dialog_complete_event_param *params) +{ + WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_pause_dialog_complete_event_fixed_param *ev; + + param_buf = (WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->status = wmi_twt_pause_status_to_host_twt_status(ev->status); + params->dialog_id = ev->dialog_id; + + return QDF_STATUS_SUCCESS; +} + +static enum HOST_TWT_NUDGE_STATUS +wmi_twt_nudge_status_to_host_twt_status(WMI_TWT_NUDGE_STATUS_T status) +{ + switch (status) { + case WMI_NUDGE_TWT_STATUS_OK: + return HOST_TWT_NUDGE_STATUS_OK; + case WMI_NUDGE_TWT_STATUS_DIALOG_ID_NOT_EXIST: + return HOST_TWT_NUDGE_STATUS_DIALOG_ID_NOT_EXIST; + case WMI_NUDGE_TWT_STATUS_INVALID_PARAM: + return HOST_TWT_NUDGE_STATUS_INVALID_PARAM; + case WMI_NUDGE_TWT_STATUS_DIALOG_ID_BUSY: + return HOST_TWT_NUDGE_STATUS_DIALOG_ID_BUSY; + case WMI_NUDGE_TWT_STATUS_NO_RESOURCE: + return HOST_TWT_NUDGE_STATUS_NO_RESOURCE; + case WMI_NUDGE_TWT_STATUS_NO_ACK: + return HOST_TWT_NUDGE_STATUS_NO_ACK; + case WMI_NUDGE_TWT_STATUS_CHAN_SW_IN_PROGRESS: + return HOST_TWT_NUDGE_STATUS_CHAN_SW_IN_PROGRESS; + case WMI_NUDGE_TWT_STATUS_ROAM_IN_PROGRESS: + return HOST_TWT_NUDGE_STATUS_ROAM_IN_PROGRESS; + case WMI_NUDGE_TWT_STATUS_SCAN_IN_PROGRESS: + return HOST_TWT_NUDGE_STATUS_SCAN_IN_PROGRESS; + default: + return HOST_TWT_NUDGE_STATUS_UNKNOWN_ERROR; + } +} + +static QDF_STATUS extract_twt_nudge_dialog_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_nudge_dialog_complete_event_param *params) +{ + WMI_TWT_NUDGE_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_nudge_dialog_complete_event_fixed_param *ev; + + param_buf = (WMI_TWT_NUDGE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->status = wmi_twt_nudge_status_to_host_twt_status(ev->status); + params->dialog_id = ev->dialog_id; + params->next_twt_tsf_us_lo = ev->sp_tsf_us_lo; + params->next_twt_tsf_us_hi = ev->sp_tsf_us_hi; + + wmi_debug("vdev_id: %d dialog_id: %d tsf hi : %x tsf lo: %x", + params->vdev_id, params->dialog_id, + params->next_twt_tsf_us_hi, params->next_twt_tsf_us_lo); + + return QDF_STATUS_SUCCESS; +} + +static enum HOST_TWT_RESUME_STATUS +wmi_get_converted_twt_resume_dialog_status(WMI_RESUME_TWT_STATUS_T tgt_status) +{ + switch (tgt_status) { + case WMI_RESUME_TWT_STATUS_OK: + return HOST_TWT_RESUME_STATUS_OK; + case WMI_RESUME_TWT_STATUS_DIALOG_ID_NOT_EXIST: + return HOST_TWT_RESUME_STATUS_DIALOG_ID_NOT_EXIST; + case WMI_RESUME_TWT_STATUS_INVALID_PARAM: + return HOST_TWT_RESUME_STATUS_INVALID_PARAM; + case WMI_RESUME_TWT_STATUS_DIALOG_ID_BUSY: + return HOST_TWT_RESUME_STATUS_DIALOG_ID_BUSY; + case WMI_RESUME_TWT_STATUS_NOT_PAUSED: + return HOST_TWT_RESUME_STATUS_NOT_PAUSED; + case WMI_RESUME_TWT_STATUS_NO_RESOURCE: + return HOST_TWT_RESUME_STATUS_NO_RESOURCE; + case WMI_RESUME_TWT_STATUS_NO_ACK: + return HOST_TWT_RESUME_STATUS_NO_ACK; + case WMI_RESUME_TWT_STATUS_CHAN_SW_IN_PROGRESS: + return HOST_TWT_RESUME_STATUS_CHAN_SW_IN_PROGRESS; + case WMI_RESUME_TWT_STATUS_ROAM_IN_PROGRESS: + return HOST_TWT_RESUME_STATUS_ROAM_IN_PROGRESS; + case WMI_RESUME_TWT_STATUS_SCAN_IN_PROGRESS: + return HOST_TWT_RESUME_STATUS_SCAN_IN_PROGRESS; + default: + return HOST_TWT_RESUME_STATUS_UNKNOWN_ERROR; + } +} + +static QDF_STATUS extract_twt_resume_dialog_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_resume_dialog_complete_event_param *params) +{ + WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_resume_dialog_complete_event_fixed_param *ev; + + param_buf = + (WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->status = wmi_get_converted_twt_resume_dialog_status(ev->status); + params->dialog_id = ev->dialog_id; + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS extract_twt_notify_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_notify_event_param *params) +{ + WMI_TWT_NOTIFY_EVENTID_param_tlvs *param_buf; + wmi_twt_notify_event_fixed_param *ev; + + param_buf = + (WMI_TWT_NOTIFY_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + + return QDF_STATUS_SUCCESS; +} + +#ifdef WLAN_SUPPORT_BCAST_TWT +static QDF_STATUS +extract_twt_btwt_invite_sta_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct + twt_btwt_invite_sta_complete_event_param + *params) +{ + WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_btwt_invite_sta_complete_event_fixed_param *ev; + + param_buf = + (WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->status = ev->status; + params->dialog_id = ev->dialog_id; + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS +extract_twt_btwt_remove_sta_comp_event_tlv( + wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct + twt_btwt_remove_sta_complete_event_param + *params) +{ + WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *param_buf; + wmi_twt_btwt_remove_sta_complete_event_fixed_param *ev; + + param_buf = + (WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + + params->vdev_id = ev->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, + params->peer_macaddr.bytes); + params->status = ev->status; + params->dialog_id = ev->dialog_id; + + return QDF_STATUS_SUCCESS; +} +#endif + +#ifdef WLAN_SUPPORT_BCAST_TWT +static void +wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) +{ + ops->send_twt_btwt_invite_sta_cmd = send_twt_btwt_invite_sta_cmd_tlv; + ops->send_twt_btwt_remove_sta_cmd = send_twt_btwt_remove_sta_cmd_tlv; + ops->extract_twt_btwt_invite_sta_comp_event = + extract_twt_btwt_invite_sta_comp_event_tlv; + ops->extract_twt_btwt_remove_sta_comp_event = + extract_twt_btwt_remove_sta_comp_event_tlv; +} +#else +static void +wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) +{ +} +#endif + +static QDF_STATUS +extract_twt_session_stats_event_tlv(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param + *params) +{ + WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *param_buf; + wmi_pdev_twt_session_stats_event_fixed_param *ev; + + param_buf = + (WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ev = param_buf->fixed_param; + params->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( + wmi_handle, + ev->pdev_id); + params->num_sessions = param_buf->num_twt_sessions; + + wmi_debug("pdev_id=%d, num of TWT sessions=%d", + params->pdev_id, params->num_sessions); + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS +extract_twt_session_stats_event_data(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_session_stats_event_param + *params, + struct twt_session_stats_info + *session, + uint32_t idx) +{ + WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *param_buf; + wmi_twt_session_stats_info *twt_session; + uint32_t flags; + wmi_mac_addr *m1; + uint8_t *m2; + + param_buf = + (WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + if (idx >= param_buf->num_twt_sessions) { + wmi_err("wrong idx, idx=%d, num_sessions=%d", + idx, param_buf->num_twt_sessions); + return QDF_STATUS_E_INVAL; + } + + twt_session = ¶m_buf->twt_sessions[idx]; + + session->vdev_id = twt_session->vdev_id; + m1 = &twt_session->peer_mac; + m2 = session->peer_mac.bytes; + WMI_MAC_ADDR_TO_CHAR_ARRAY(m1, m2); + session->event_type = twt_session->event_type; + flags = twt_session->flow_id_flags; + session->flow_id = WMI_TWT_SESSION_FLAG_FLOW_ID_GET(flags); + session->bcast = WMI_TWT_SESSION_FLAG_BCAST_TWT_GET(flags); + session->trig = WMI_TWT_SESSION_FLAG_TRIGGER_TWT_GET(flags); + session->announ = WMI_TWT_SESSION_FLAG_ANNOUN_TWT_GET(flags); + session->protection = WMI_TWT_SESSION_FLAG_TWT_PROTECTION_GET(flags); + session->info_frame_disabled = + WMI_TWT_SESSION_FLAG_TWT_INFO_FRAME_DISABLED_GET(flags); + session->dialog_id = twt_session->dialog_id; + session->wake_dura_us = twt_session->wake_dura_us; + session->wake_intvl_us = twt_session->wake_intvl_us; + session->sp_offset_us = twt_session->sp_offset_us; + session->sp_tsf_us_lo = twt_session->sp_tsf_us_lo; + session->sp_tsf_us_hi = twt_session->sp_tsf_us_hi; + wmi_debug("type=%d id=%d bcast=%d trig=%d announ=%d diagid=%d wake_dur=%ul wake_int=%ul offset=%ul", + session->event_type, session->flow_id, + session->bcast, session->trig, + session->announ, session->dialog_id, session->wake_dura_us, + session->wake_intvl_us, session->sp_offset_us); + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS extract_twt_cap_service_ready_ext2_tlv( + wmi_unified_t wmi_handle, uint8_t *event, + struct wmi_twt_cap_bitmap_params *var) +{ + WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *param_buf; + wmi_twt_caps_params *twt_caps; + + param_buf = (WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *)event; + if (!param_buf) + return QDF_STATUS_E_INVAL; + + twt_caps = param_buf->twt_caps; + if (!twt_caps) + return QDF_STATUS_E_INVAL; + + var->twt_ack_support_cap = WMI_GET_BITS(twt_caps->twt_capability_bitmap, + 0, 1); + + return QDF_STATUS_SUCCESS; +} + +static enum WMI_HOST_TWT_CMD_FOR_ACK_EVENT +wmi_get_converted_twt_command_for_ack_event(WMI_CMD_ID tgt_cmd) +{ + switch (tgt_cmd) { + case WMI_TWT_ADD_DIALOG_CMDID: + return WMI_HOST_TWT_ADD_DIALOG_CMDID; + case WMI_TWT_DEL_DIALOG_CMDID: + return WMI_HOST_TWT_DEL_DIALOG_CMDID; + case WMI_TWT_PAUSE_DIALOG_CMDID: + return WMI_HOST_TWT_PAUSE_DIALOG_CMDID; + case WMI_TWT_RESUME_DIALOG_CMDID: + return WMI_HOST_TWT_RESUME_DIALOG_CMDID; + case WMI_TWT_NUDGE_DIALOG_CMDID: + return WMI_HOST_TWT_NUDGE_DIALOG_CMDID; + default: + return WMI_HOST_TWT_UNKNOWN_CMDID; + } +} + +static QDF_STATUS +extract_twt_ack_comp_event_tlv(wmi_unified_t wmi_handle, + uint8_t *evt_buf, + struct twt_ack_complete_event_param *var) +{ + WMI_TWT_ACK_EVENTID_param_tlvs *param_buf; + wmi_twt_ack_event_fixed_param *ack_event; + + param_buf = (WMI_TWT_ACK_EVENTID_param_tlvs *)evt_buf; + if (!param_buf) { + wmi_err("evt_buf is NULL"); + return QDF_STATUS_E_INVAL; + } + + ack_event = param_buf->fixed_param; + + var->vdev_id = ack_event->vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ack_event->peer_macaddr, + var->peer_macaddr.bytes); + var->dialog_id = ack_event->dialog_id; + var->twt_cmd_ack = wmi_get_converted_twt_command_for_ack_event( + ack_event->twt_cmd); + + switch (ack_event->twt_cmd) { + case WMI_TWT_ADD_DIALOG_CMDID: + var->status = wmi_get_converted_twt_add_dialog_status( + ack_event->status); + break; + case WMI_TWT_DEL_DIALOG_CMDID: + var->status = wmi_get_converted_twt_del_dialog_status( + ack_event->status); + break; + case WMI_TWT_PAUSE_DIALOG_CMDID: + var->status = wmi_twt_pause_status_to_host_twt_status( + ack_event->status); + break; + case WMI_TWT_RESUME_DIALOG_CMDID: + var->status = wmi_get_converted_twt_resume_dialog_status( + ack_event->status); + break; + case WMI_TWT_NUDGE_DIALOG_CMDID: + var->status = wmi_twt_nudge_status_to_host_twt_status( + ack_event->status); + break; + default: + break; + } + return QDF_STATUS_SUCCESS; +} +#elif WLAN_SUPPORT_TWT static QDF_STATUS send_twt_enable_cmd_tlv(wmi_unified_t wmi_handle, struct wmi_twt_enable_param *params) { @@ -132,15 +1264,12 @@ twt_add_dialog_set_bcast_twt_params(struct wmi_twt_add_dialog_param *params, TWT_FLAGS_SET_BTWT_ID0(cmd->flags, params->flag_b_twt_id0); cmd->b_twt_persistence = params->b_twt_persistence; cmd->b_twt_recommendation = params->b_twt_recommendation; - - return; } #else static void twt_add_dialog_set_bcast_twt_params(struct wmi_twt_add_dialog_param *params, wmi_twt_add_dialog_cmd_fixed_param *cmd) { - return; } #endif @@ -202,14 +1331,12 @@ twt_del_dialog_set_bcast_twt_params(struct wmi_twt_del_dialog_param *params, wmi_twt_del_dialog_cmd_fixed_param *cmd) { cmd->b_twt_persistence = params->b_twt_persistence; - return; } #else static void twt_del_dialog_set_bcast_twt_params(struct wmi_twt_del_dialog_param *params, wmi_twt_del_dialog_cmd_fixed_param *cmd) { - return; } #endif @@ -465,7 +1592,8 @@ static QDF_STATUS extract_twt_disable_comp_event_tlv(wmi_unified_t wmi_handle, #if 0 params->pdev_id = - wmi_handle->ops->convert_pdev_id_target_to_host(ev->pdev_id); + wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, + ev->pdev_id); params->status = ev->status; #endif @@ -938,14 +2066,11 @@ wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) extract_twt_btwt_invite_sta_comp_event_tlv; ops->extract_twt_btwt_remove_sta_comp_event = extract_twt_btwt_remove_sta_comp_event_tlv; - - return; } #else static void wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) { - return; } #endif @@ -1130,6 +2255,7 @@ extract_twt_ack_comp_event_tlv(wmi_unified_t wmi_handle, } return QDF_STATUS_SUCCESS; } +#endif void wmi_twt_attach_tlv(wmi_unified_t wmi_handle) {