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) {