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

Add 'qcom/opensource/wlan/qca-wifi-host-cmn/' from commit 'fec800ab539956671af604bdd6e1ee3b84eef491'

Browse Source 
git-subtree-dir: qcom/opensource/wlan/qca-wifi-host-cmn
git-subtree-mainline: 5add812a59
git-subtree-split: fec800ab53
Change-Id:
repo: https://git.codelinaro.org/clo/la/platform/vendor/qcom-opensource/wlan/qca-wifi-host-cmn
tag: LA.VENDOR.14.3.0.r1-17300-lanai.QSSI15.0
This commit is contained in:
David Wronek
2024-10-06 16:49:55 +02:00
parent 5add812a59 fec800ab53
commit af9c28c32a
1248 changed files with 924106 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_filtered_logging.h Normal file
View File

@@ -0,0 +1,200 @@
/*
* Copyright (c) 2015-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef WMI_FILTERED_LOGGING_H
#define WMI_FILTERED_LOGGING_H
#include <qdf_debugfs.h>
#include "wmi_unified_priv.h"
#ifdef WMI_INTERFACE_FILTERED_EVENT_LOGGING
/**
* wmi_specific_cmd_record() - Record user specified command
* @wmi_handle: handle to WMI
* @id: cmd id
* @buf: buf containing cmd details
*
* Check if the command id is in target list,
* if found, record it.
*
* Context: the function will not sleep, caller is expected to hold
* proper locking.
*
* Return: none
*/
void wmi_specific_cmd_record(wmi_unified_t wmi_handle,
uint32_t id, uint8_t *buf);
/**
* wmi_specific_evt_record() - Record user specified event
* @wmi_handle: handle to WMI
* @id: cmd id
* @buf: buf containing event details
*
* Check if the event id is in target list,
* if found, record it.
*
* Context: the function will not sleep, caller is expected to hold
* proper locking.
*
* Return: none
*/
void wmi_specific_evt_record(wmi_unified_t wmi_handle,
uint32_t id, uint8_t *buf);
/**
* wmi_filtered_logging_init() - initialize filtered logging
* @wmi_handle: handle to WMI
*
* Context: the function will not sleep, no lock needed
*
* Return: none
*/
void wmi_filtered_logging_init(wmi_unified_t wmi_handle);
/**
* wmi_filtered_logging_free() - free the buffers for filtered logging
* @wmi_handle: handle to WMI
*
* Context: the function will not sleep, no lock needed
*
* Return: none
*/
void wmi_filtered_logging_free(wmi_unified_t wmi_handle);
/*
* Debugfs read/write functions
*/
/**
* debug_filtered_wmi_cmds_show() - debugfs read function for filtered_wmi_cmds
* @m: seq_file handle
* @v: not used, offset of read
* Return: number of bytes read
*/
int debug_filtered_wmi_cmds_show(qdf_debugfs_file_t m, void *v);
/**
* debug_filtered_wmi_evts_show() - debugfs read function for filtered_wmi_evts
* @m: seq_file handle
* @v: not used, offset of read
* Return: number of bytes read
*/
int debug_filtered_wmi_evts_show(qdf_debugfs_file_t m, void *v);
/**
* debug_wmi_filtered_command_log_show() - debugfs read function for
* wmi_filtered_command_log
* @m: seq_file handle
* @v: not used, offset of read
* Return: number of bytes read
*/
int debug_wmi_filtered_command_log_show(qdf_debugfs_file_t m, void *v);
/**
* debug_wmi_filtered_event_log_show() - debugfs read function for
* wmi_filtered_event_log
* @m: seq_file handle
* @v: not used, offset of read
* Return: number of bytes read
*/
int debug_wmi_filtered_event_log_show(qdf_debugfs_file_t m, void *v);
/**
* debug_filtered_wmi_cmds_write() - debugfs write for filtered_wmi_cmds
*
* @file: file handler to access wmi_handle
* @buf: received data buffer
* @count: length of received buffer
* @ppos: Not used
*
* Return: count
*/
ssize_t debug_filtered_wmi_cmds_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos);
/**
* debug_filtered_wmi_evts_write() - debugfs write for filtered_wmi_evts
*
* @file: file handler to access wmi_handle
* @buf: received data buffer
* @count: length of received buffer
* @ppos: Not used
*
* Return: count
*/
ssize_t debug_filtered_wmi_evts_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos);
/**
* debug_wmi_filtered_command_log_write() - debugfs write for
* filtered_command_log
*
* @file: file handler to access wmi_handle
* @buf: received data buffer
* @count: length of received buffer
* @ppos: Not used
*
* Return: count
*/
ssize_t debug_wmi_filtered_command_log_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos);
/**
* debug_wmi_filtered_event_log_write() - debugfs write for filtered_event_log
*
* @file: file handler to access wmi_handle
* @buf: received data buffer
* @count: length of received buffer
* @ppos: Not used
*
* Return: count
*/
ssize_t debug_wmi_filtered_event_log_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos);
#else /* WMI_INTERFACE_FILTERED_EVENT_LOGGING */
static inline void wmi_specific_cmd_record(wmi_unified_t wmi_handle,
uint32_t id, uint8_t *buf)
{
/* do nothing */
}
static inline void wmi_specific_evt_record(wmi_unified_t wmi_handle,
uint32_t id, uint8_t *buf)
{
/* do nothing */
}
static inline void wmi_filtered_logging_init(wmi_unified_t wmi_handle)
{
/* do nothing */
}
static inline void wmi_filtered_logging_free(wmi_unified_t wmi_handle)
{
/* do nothing */
}
#endif /* end of WMI_INTERFACE_FILTERED_EVENT_LOGGING */
#endif /*WMI_FILTERED_LOGGING_H*/

54
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_hang_event.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef WMI_HANG_EVENT_H
#define WMI_HANG_EVENT_H
#include <wmi_unified_priv.h>
#ifdef WLAN_HANG_EVENT
/**
* wmi_hang_event_notifier_register() - wmi hang event notifier register
* @wmi_hdl: WMI Handle
*
* This function registers wmi layer notifier for the hang event notifier chain.
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_hang_event_notifier_register(struct wmi_unified *wmi_hdl);
/**
* wmi_hang_event_notifier_unregister() - wmi hang event notifier unregister
*
* This function unregisters wmi layer notifier for the hang event notifier
* chain.
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_hang_event_notifier_unregister(void);
#else
static inline
QDF_STATUS wmi_hang_event_notifier_register(struct wmi_unified *wmi_hdl)
{
return 0;
}
static inline QDF_STATUS wmi_hang_event_notifier_unregister(void)
{
return 0;
}
#endif
#endif

329
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_11be_api.h Normal file
View File

@@ -0,0 +1,329 @@
/*
* Copyright (c) 2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) specific to 11be.
*/
#ifndef _WMI_UNIFIED_11BE_API_H_
#define _WMI_UNIFIED_11BE_API_H_
#include <wmi_unified_api.h>
#include <wmi_unified_priv.h>
#ifdef WLAN_FEATURE_11BE_MLO
/**
* wmi_extract_mlo_link_set_active_resp() - extract mlo link set active
* response event
* @wmi: wmi handle
* @evt_buf: pointer to event buffer
* @evt: Pointer to hold mlo link set active response event
*
* This function gets called to extract mlo link set active response event
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_mlo_link_set_active_resp(wmi_unified_t wmi,
void *evt_buf,
struct mlo_link_set_active_resp *evt);
/**
* wmi_send_mlo_link_set_active_cmd() - send mlo link set active command
* @wmi_handle: WMI handle for this pdev
* @param: Pointer to mlo link set active param
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_send_mlo_link_set_active_cmd(wmi_unified_t wmi_handle,
struct mlo_link_set_active_param *param);
/**
* wmi_extract_mgmt_rx_ml_cu_params() - extract mlo cu params from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @cu_params: Pointer to mlo CU params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_mgmt_rx_ml_cu_params(wmi_unified_t wmi_handle, void *evt_buf,
struct mlo_mgmt_ml_info *cu_params);
/**
* wmi_send_mlo_link_removal_cmd() - Send WMI command for MLO link removal
* @wmi: wmi handle
* @param: MLO link removal command parameters
*
* Return: QDF_STATUS_SUCCESS of operation
*/
QDF_STATUS wmi_send_mlo_link_removal_cmd(
wmi_unified_t wmi,
const struct mlo_link_removal_cmd_params *param);
/**
* wmi_send_mlo_vdev_pause() - Send WMI command for MLO vdev pause
* @wmi: wmi handle
* @info: MLO vdev pause information
*
* Return: QDF_STATUS_SUCCESS of operation
*/
QDF_STATUS wmi_send_mlo_vdev_pause(wmi_unified_t wmi,
struct mlo_vdev_pause *info);
/**
* wmi_extract_mlo_link_removal_evt_fixed_param() - Extract fixed parameters TLV
* from the MLO link removal WMI event
* @wmi_handle: wmi handle
* @buf: pointer to event buffer
* @params: MLO link removal event parameters
*
* Return: QDF_STATUS_SUCCESS of operation
*/
QDF_STATUS wmi_extract_mlo_link_removal_evt_fixed_param(
struct wmi_unified *wmi_handle,
void *buf,
struct mlo_link_removal_evt_params *params);
/**
* wmi_extract_mlo_link_removal_tbtt_update() - Extract TBTT update TLV
* from the MLO link removal WMI event
* @wmi_handle: wmi handle
* @buf: pointer to event buffer
* @tbtt_info: TBTT information
*
* Return: QDF_STATUS of operation
*/
QDF_STATUS wmi_extract_mlo_link_removal_tbtt_update(
struct wmi_unified *wmi_handle,
void *buf,
struct mlo_link_removal_tbtt_info *tbtt_info);
/**
* wmi_extract_mgmt_rx_mlo_link_removal_info() - Extract MLO link removal info
* from MGMT Rx event
* @wmi: wmi handle
* @buf: event buffer
* @link_removal_info: link removal information array to be populated
* @num_link_removal_info: Number of elements in @link_removal_info
*
* Return: QDF_STATUS of operation
*/
QDF_STATUS wmi_extract_mgmt_rx_mlo_link_removal_info(
struct wmi_unified *wmi,
void *buf,
struct mgmt_rx_mlo_link_removal_info *link_removal_info,
int num_link_removal_info);
#endif /*WLAN_FEATURE_11BE_MLO*/
#ifdef WLAN_FEATURE_11BE
/**
* wmi_send_mlo_peer_tid_to_link_map_cmd() - send TID-to-link mapping command
* @wmi: WMI handle for this pdev
* @params: Pointer to TID-to-link mapping params
* @t2lm_info: T2LM info presence flag
*/
QDF_STATUS wmi_send_mlo_peer_tid_to_link_map_cmd(
wmi_unified_t wmi,
struct wmi_host_tid_to_link_map_params *params,
bool t2lm_info);
/**
* wmi_send_mlo_vdev_tid_to_link_map_cmd() - send TID-to-link mapping command
* per vdev
* @wmi: WMI handle for this pdev
* @params: Pointer to TID-to-link mapping params
*/
QDF_STATUS wmi_send_mlo_vdev_tid_to_link_map_cmd(
wmi_unified_t wmi,
struct wmi_host_tid_to_link_map_ap_params *params);
/**
* wmi_send_mlo_link_state_request_cmd - send mlo link status command
* @wmi: wmi handle
* @params: Pointer to link state params
*/
QDF_STATUS wmi_send_mlo_link_state_request_cmd(
wmi_unified_t wmi,
struct wmi_host_link_state_params *params);
/**
* wmi_send_link_set_bss_params_cmd - send link set bss cmd
* @wmi: wmi handler
* @params: pointer to link bss param
*/
QDF_STATUS wmi_send_link_set_bss_params_cmd(
wmi_unified_t wmi,
struct wmi_host_link_bss_params *params);
/**
* wmi_extract_mlo_vdev_tid_to_link_map_event() - extract mlo t2lm info for vdev
* @wmi: wmi handle
* @evt_buf: pointer to event buffer
* @resp: Pointer to host structure to get the t2lm info
*
* This function gets called to extract mlo t2lm info for particular pdev
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_mlo_vdev_tid_to_link_map_event(
wmi_unified_t wmi, void *evt_buf,
struct mlo_vdev_host_tid_to_link_map_resp *resp);
/**
* wmi_extract_mlo_vdev_bcast_tid_to_link_map_event() - extract bcast mlo t2lm
* info for vdev
* @wmi: wmi handle
* @evt_buf: pointer to event buffer
* @bcast: Pointer to host structure to get the t2lm bcast info
*
* This function gets called to extract bcast mlo t2lm info for particular pdev
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_mlo_vdev_bcast_tid_to_link_map_event(
wmi_unified_t wmi,
void *evt_buf,
struct mlo_bcast_t2lm_info *bcast);
/**
* wmi_extract_mlo_link_state_info_event - extract mlo link status info
* @wmi: wmi handle
* @evt_buf: pointer to event buffer
* @params: pointer to host struct to get mlo link state
*/
QDF_STATUS wmi_extract_mlo_link_state_info_event(
wmi_unified_t wmi,
void *evt_buf,
struct ml_link_state_info_event *params);
#ifdef WLAN_FEATURE_11BE_MLO_ADV_FEATURE
/**
* wmi_send_mlo_link_switch_req_cnf_cmd() - Send WMI command to FW on
* status of Link switch request received.
* @wmi: wmi handle
* @params: Params to send to FW.
*
* Return: QDF_STATUS.
*/
QDF_STATUS
wmi_send_mlo_link_switch_req_cnf_cmd(wmi_unified_t wmi,
struct wlan_mlo_link_switch_cnf *params);
/**
* wmi_extract_mlo_link_switch_request_evt() - Extract fixed params TLV
* from the MLO link switch request WMI event.
* @wmi: wmi handle
* @buf: pointer to event buffer
* @req: MLO link switch request event params.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_extract_mlo_link_switch_request_evt(struct wmi_unified *wmi, void *buf,
struct wlan_mlo_link_switch_req *req);
#else
static inline QDF_STATUS
wmi_send_mlo_link_switch_req_cnf_cmd(wmi_unified_t wmi,
struct wlan_mlo_link_switch_cnf *params)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS
wmi_extract_mlo_link_switch_request_evt(struct wmi_unified *wmi, void *buf,
struct wlan_mlo_link_switch_req *req)
{
return QDF_STATUS_SUCCESS;
}
#endif
/**
* wmi_extract_mlo_link_disable_request_evt() - Extract fixed parameters TLV
* from the MLO link disable request WMI event
* @wmi: wmi handle
* @buf: pointer to event buffer
* @params: MLO link disable request event parameters
*
* Return: QDF_STATUS_SUCCESS of operation
*/
QDF_STATUS wmi_extract_mlo_link_disable_request_evt(
struct wmi_unified *wmi,
void *buf,
struct mlo_link_disable_request_evt_params *params);
/**
* wmi_extract_mlo_link_state_switch_evt() - Extract the MLO link switch state
* event parameters
* @wmi: wmi handle
* @buf: pointer to event buffer
* @len: event data length
* @info: Info on link switch state change event
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_extract_mlo_link_state_switch_evt(struct wmi_unified *wmi, void *buf,
uint8_t len,
struct mlo_link_switch_state_info *info);
#endif /* WLAN_FEATURE_11BE */
#ifdef QCA_SUPPORT_PRIMARY_LINK_MIGRATE
/**
* wmi_unified_peer_ptqm_migrate_send() - send PEER ptqm migrate command to fw
* @wmi_hdl: wmi handle
* @param: pointer to hold peer ptqm migrate parameters
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_peer_ptqm_migrate_send(
wmi_unified_t wmi_hdl,
struct peer_ptqm_migrate_params *param);
/**
* wmi_extract_peer_ptqm_migrate_event() - extract peer ptqm migrate event params
* @wmi: wmi handle
* @evt_buf: pointer to event buffer
* @resp: Pointer to host structure to get the event params
*
* This function gets called to extract peer ptqm migrate event params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_ptqm_migrate_event(
wmi_unified_t wmi, void *evt_buf,
struct peer_ptqm_migrate_event_params *resp);
/**
* wmi_extract_peer_ptqm_entry_param() - extract peer entry ptqm migrate param
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into pdev stats
* @entry: Pointer to peer entry params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_ptqm_entry_param(
wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
struct peer_entry_ptqm_migrate_event_params *entry);
#endif /* QCA_SUPPORT_PRIMARY_LINK_MIGRATE */
#endif /*_WMI_UNIFIED_11BE_API_H_*/

113
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_11be_param.h Normal file
View File

@@ -0,0 +1,113 @@
/*
* Copyright (c) 2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_11BE_PARAM_H_
#define _WMI_UNIFIED_11BE_PARAM_H_
#include <wmi_unified_param.h>
#ifdef WLAN_FEATURE_11BE_MLO
#define MAX_LINK_IN_MLO 6
/** struct wmi_mlo_setup_params - MLO setup command params
* @mld_grp_id: Unique ID to FW for MLD group
* @pdev_id: pdev id of radio on which this command is sent
* @num_valid_hw_links: Num of valid links in partner_links array
* @partner_links[MAX_LINK_IN_MLO]: Partner link IDs
*/
struct wmi_mlo_setup_params {
uint32_t mld_grp_id;
uint32_t pdev_id;
uint8_t num_valid_hw_links;
uint32_t partner_links[MAX_LINK_IN_MLO];
};
/** struct wmi_mlo_ready_params - MLO ready command params
* @pdev_id: pdev id of radio on which this command is sent
*/
struct wmi_mlo_ready_params {
uint32_t pdev_id;
};
/** enum wmi_mlo_teardown_reason - Reason code in WMI MLO teardown command
* @WMI_HOST_MLO_TEARDOWN_REASON_DOWN: Wifi down
* @WMI_HOST_MLO_TEARDOWN_REASON_SSR: Wifi Recovery
* @WMI_HOST_MLO_TEARDOWN_REASON_MODE1_SSR: Recovery Mode1 SSR teardown
* @WMI_HOST_MLO_TEARDOWN_REASON_STANDBY: Network Standby mode teardown
*/
enum wmi_mlo_teardown_reason {
WMI_HOST_MLO_TEARDOWN_REASON_DOWN,
WMI_HOST_MLO_TEARDOWN_REASON_SSR,
WMI_HOST_MLO_TEARDOWN_REASON_MODE1_SSR,
WMI_HOST_MLO_TEARDOWN_REASON_STANDBY,
};
/** struct wmi_mlo_teardown_params - MLO teardown command params
* @pdev_id: pdev id of radio on which this command is sent
* @reason: reason code from enum wmi_mlo_teardown_reason
* @umac_reset: trigger umac reset for mode1 or not
*/
struct wmi_mlo_teardown_params {
uint32_t pdev_id;
enum wmi_mlo_teardown_reason reason;
bool umac_reset;
bool standby_active;
};
/** enum wmi_mlo_setup_status - Status code in WMI MLO setup completion event
* @WMI_HOST_MLO_SETUP_STATUS_SUCCESS: Success
* @WMI_HOST_MLO_SETUP_STATUS_FAILURE: Failure
*/
enum wmi_mlo_setup_status {
WMI_HOST_MLO_SETUP_STATUS_SUCCESS,
WMI_HOST_MLO_SETUP_STATUS_FAILURE,
};
/** struct wmi_mlo_setup_complete_params - MLO setup complete event params
* @pdev_id: pdev id of radio on which this event is received
* @status: status code
* @max_ml_peer_ids: Maximum ML Peer ID's
*/
struct wmi_mlo_setup_complete_params {
uint32_t pdev_id;
enum wmi_mlo_setup_status status;
uint32_t max_ml_peer_ids;
};
/** enum wmi_mlo_teardown_status - Status code in WMI MLO teardown completion
* event
* @WMI_HOST_MLO_TEARDOWN_STATUS_SUCCESS: Success
* @WMI_HOST_MLO_TEARDOWN_STATUS_FAILURE: Failure
* @WMI_HOST_MLO_TEARDOWN_STATUS_ONGOING: Ongoing
*/
enum wmi_mlo_teardown_status {
WMI_HOST_MLO_TEARDOWN_STATUS_SUCCESS,
WMI_HOST_MLO_TEARDOWN_STATUS_FAILURE,
WMI_HOST_MLO_TEARDOWN_STATUS_ONGOING,
};
/** struct wmi_mlo_teardown_cmpl_params - MLO setup teardown event params
* @pdev_id: pdev id of radio on which this event is received
* @status: Teardown status from enum wmi_mlo_teardown_status
*/
struct wmi_mlo_teardown_cmpl_params {
uint32_t pdev_id;
enum wmi_mlo_teardown_status status;
};
#endif
#endif

80
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_11be_setup_api.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright (c) 2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_11BE_SETUP_API_H_
#define _WMI_UNIFIED_11BE_SETUP_API_H_
#include <wmi_unified_11be_param.h>
#ifdef WLAN_FEATURE_11BE_MLO
/**
* wmi_mlo_setup_cmd_send() - Send MLO setup command
* @wmi_handle: WMI handle for this pdev
* @params: MLO setup params
*
* Return: QDF_STATUS code
*/
QDF_STATUS wmi_mlo_setup_cmd_send(wmi_unified_t wmi_handle,
struct wmi_mlo_setup_params *params);
/**
* wmi_mlo_teardown_cmd_send() - Send MLO teardown command
* @wmi_handle: WMI handle for this pdev
* @params: MLO teardown params
*
* Return: QDF_STATUS code
*/
QDF_STATUS wmi_mlo_teardown_cmd_send(wmi_unified_t wmi_handle,
struct wmi_mlo_teardown_params *params);
/**
* wmi_mlo_ready_cmd_send() - Send MLO ready command
* @wmi_handle: WMI handle for this pdev
* @params: MLO ready params
*
* Return: QDF_STATUS code
*/
QDF_STATUS wmi_mlo_ready_cmd_send(wmi_unified_t wmi_handle,
struct wmi_mlo_ready_params *params);
/**
* wmi_extract_mlo_setup_cmpl_event() - Extract MLO setup completion event
* @wmi_handle: WMI handle for this pdev
* @buf: Event buffer
* @params: MLO setup event params
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_extract_mlo_setup_cmpl_event(wmi_unified_t wmi_handle,
uint8_t *buf,
struct wmi_mlo_setup_complete_params *params);
/**
* wmi_extract_mlo_teardown_cmpl_event() - Extract MLO teardown completion
* @wmi_handle: WMI handle for this pdev
* @buf: Event buffer
* @param: MLO teardown event params
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_extract_mlo_teardown_cmpl_event(wmi_unified_t wmi_handle,
uint8_t *buf,
struct wmi_mlo_teardown_cmpl_params *param);
#endif /*WLAN_FEATURE_11BE_MLO*/
#endif /*_WMI_UNIFIED_11BE_SETUP_API_H_*/

380
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_11be_tlv.h Normal file
View File

@@ -0,0 +1,380 @@
/*
* Copyright (c) 2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2024 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_11BE_TLV_H_
#define _WMI_UNIFIED_11BE_TLV_H_
#ifdef WLAN_FEATURE_11BE_MLO
/**
* vdev_create_mlo_params_size() - Get MLO params size in vdev create
* @param: pointer to vdev create request param
* Return: size of MLO params in vdev create
*/
size_t vdev_create_mlo_params_size(struct vdev_create_params *param);
/**
* vdev_create_add_mlo_params() - Add MLO params in vdev create cmd
* @buf_ptr: pointer to vdev create buffer.
* @param: pointer to vdev create request param
*
* Return: pointer to new offset of vdev create buffer
*/
uint8_t *vdev_create_add_mlo_params(uint8_t *buf_ptr,
struct vdev_create_params *param);
/**
* vdev_start_mlo_params_size() - Get MLO params size in vdev start
* @req: Vdev start request params
*
* Return: size of MLO params in vdev start
*/
size_t vdev_start_mlo_params_size(struct vdev_start_params *req);
/**
* vdev_start_add_mlo_params() - Add MLO params in vdev start cmd
* @buf_ptr: pointer to vdev start buffer.
* @req: pointer to vdev create request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *vdev_start_add_mlo_params(uint8_t *buf_ptr,
struct vdev_start_params *req);
/**
* vdev_start_add_ml_partner_links() - Add MLO partner links in vdev start cmd
* @buf_ptr: pointer to vdev start cmd buffer.
* @req: pointer to vdev start request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *vdev_start_add_ml_partner_links(uint8_t *buf_ptr,
struct vdev_start_params *req);
/**
* bcn_tmpl_mlo_param_size() - Get ML param size in beacon template
* @param: Pointer to beacon template param
*
* Return: size of ML params in beacon template
*/
size_t bcn_tmpl_mlo_param_size(struct beacon_tmpl_params *param);
/**
* bcn_tmpl_add_ml_partner_links - Add MLO partner links in beacon template
* command
* @buf_ptr: pointer to beacon cmd buffer.
* @param: pointer to beacon template params
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *bcn_tmpl_add_ml_partner_links(uint8_t *buf_ptr,
struct beacon_tmpl_params *param);
/**
* bcn_tmpl_ml_info_size() - Get ML info size in beacon template
* @param: Pointer to beacon template param
*
* Return: size of ML info in beacon template
*/
size_t bcn_tmpl_ml_info_size(struct beacon_tmpl_params *param);
/**
* bcn_tmpl_add_ml_info() - Add MLO info to update Critical Update info in
* beacon template command
* @buf_ptr: pointer to beacon cmd buffer.
* @param: pointer to beacon template params
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *bcn_tmpl_add_ml_info(uint8_t *buf_ptr,
struct beacon_tmpl_params *param);
/**
* prb_resp_tmpl_ml_info_size() - Get ML info size in 20TU probe resp template
* @param: Pointer to 20TU probe response template param
*
* Return: size of ML info in 20TU probe response template
*/
size_t prb_resp_tmpl_ml_info_size(struct wmi_probe_resp_params *param);
/**
* prb_resp_tmpl_add_ml_info() - Add MLO info to update Critical Update info in
* 20TU probe response template command
* @buf_ptr: pointer to 20TU probe response cmd buffer.
* @param: pointer to 20TU probe response template params
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *prb_resp_tmpl_add_ml_info(uint8_t *buf_ptr,
struct wmi_probe_resp_params *param);
/**
* peer_create_add_mlo_params() - Add MLO params in peer create cmd
* @buf_ptr: pointer to peer create cmd buffer.
* @req: pointer to peer create request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *peer_create_add_mlo_params(uint8_t *buf_ptr,
struct peer_create_params *req);
/**
* peer_create_mlo_params_size() - Get ML params size in peer create
* @req: pointer to peer create request param
*
* Return: size of ML params in peer create cmd
*/
size_t peer_create_mlo_params_size(struct peer_create_params *req);
/**
* peer_assoc_mlo_params_size() - Get ML params size in peer assoc
* @req: pointer to peer assoc request param
*
* Return: size of ML params in peer assoc cmd
*/
size_t peer_assoc_mlo_params_size(struct peer_assoc_params *req);
/**
* peer_assoc_add_mlo_params() - Add MLO params in peer assoc cmd
* @buf_ptr: pointer to peer assoc cmd buffer.
* @req: pointer to peer assoc request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *peer_assoc_add_mlo_params(uint8_t *buf_ptr,
struct peer_assoc_params *req);
/**
* peer_assoc_add_ml_partner_links() - Add MLO partner links in peer assoc cmd
* @buf_ptr: pointer to peer assoc cmd buffer.
* @req: pointer to peer assoc request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *peer_assoc_add_ml_partner_links(uint8_t *buf_ptr,
struct peer_assoc_params *req);
/**
* peer_assoc_t2lm_params_size() - Get T2LM param size in peer assoc
* @req: pointer to peer create request param
*
* Return: size of ML params in peer create cmd
*/
size_t peer_assoc_t2lm_params_size(struct peer_assoc_params *req);
/**
* peer_assoc_add_tid_to_link_map() - Add TID-to-link mapping in peer assoc cmd
* @buf_ptr: pointer to peer assoc cmd buffer.
* @req: pointer to peer assoc request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *peer_assoc_add_tid_to_link_map(uint8_t *buf_ptr,
struct peer_assoc_params *req);
/**
* peer_delete_mlo_params_size() - Get MLO params size in pdev delete
* @req: peer delete request params
*
* Return: size of MLO params in vdev start
*/
size_t peer_delete_mlo_params_size(struct peer_delete_cmd_params *req);
/**
* peer_delete_add_mlo_params() - Add MLO params in peer delete cmd
* @buf_ptr: pointer to peer delete cmd buffer.
* @req: pointer to peer delete request param
*
* Return: pointer to new offset of cmd buffer
*/
uint8_t *peer_delete_add_mlo_params(uint8_t *buf_ptr,
struct peer_delete_cmd_params *req);
/**
* vdev_stop_mlo_params_size() - Get MLO params size in vdev stop
* @params: VDEV stop request params
*
* Return: size of MLO params in VDEV stop
*/
size_t vdev_stop_mlo_params_size(struct vdev_stop_params *params);
/**
* vdev_stop_add_mlo_params() - Add MLO params in VDEV stop cmd
* @buf_ptr: Pointer to VDEV stop cmd buffer.
* @params: VDEV stop request params
*
* Return: Pointer to new offset of cmd buffer.
*/
uint8_t *vdev_stop_add_mlo_params(uint8_t *buf_ptr,
struct vdev_stop_params *params);
/** wmi_11be_tlv_attach_tlv - Attach 11be relaated callbacks
* @wmi_handle: WMI handle
*/
void wmi_11be_attach_tlv(wmi_unified_t wmi_handle);
/**
* extract_mgmt_rx_mlo_link_removal_tlv_count() - Extract the number of link
* removal TLVs from MGMT Rx event
* @num_link_removal_tlvs: Number of link removal TLVs
* @hdr: MGMT Rx event parameters to be populated
*
* Return: None
*/
static inline void
extract_mgmt_rx_mlo_link_removal_tlv_count(
int num_link_removal_tlvs,
struct mgmt_rx_event_params *hdr)
{
hdr->num_link_removal_info = num_link_removal_tlvs;
}
#else
static uint8_t *vdev_create_add_mlo_params(uint8_t *buf_ptr,
struct vdev_create_params *param)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t vdev_create_mlo_params_size(struct vdev_create_params *param)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *vdev_start_add_mlo_params(uint8_t *buf_ptr,
struct vdev_start_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t vdev_start_mlo_params_size(struct vdev_start_params *req)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *vdev_start_add_ml_partner_links(uint8_t *buf_ptr,
struct vdev_start_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t bcn_tmpl_mlo_param_size(struct beacon_tmpl_params *param)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *bcn_tmpl_add_ml_partner_links(uint8_t *buf_ptr,
struct beacon_tmpl_params *param)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t bcn_tmpl_ml_info_size(struct beacon_tmpl_params *param)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *bcn_tmpl_add_ml_info(uint8_t *buf_ptr,
struct beacon_tmpl_params *param)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t prb_resp_tmpl_ml_info_size(struct wmi_probe_resp_params *param)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *prb_resp_tmpl_add_ml_info(uint8_t *buf_ptr,
struct wmi_probe_resp_params *param)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static uint8_t *peer_create_add_mlo_params(uint8_t *buf_ptr,
struct peer_create_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t peer_create_mlo_params_size(struct peer_create_params *req)
{
return WMI_TLV_HDR_SIZE;
}
static size_t peer_assoc_mlo_params_size(struct peer_assoc_params *req)
{
size_t peer_assoc_mlo_size =
WMI_TLV_HDR_SIZE +
WMI_TLV_HDR_SIZE;
return peer_assoc_mlo_size;
}
static uint8_t *peer_assoc_add_mlo_params(uint8_t *buf_ptr,
struct peer_assoc_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static uint8_t *peer_assoc_add_ml_partner_links(uint8_t *buf_ptr,
struct peer_assoc_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t peer_assoc_t2lm_params_size(struct peer_assoc_params *req)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *peer_assoc_add_tid_to_link_map(uint8_t *buf_ptr,
struct peer_assoc_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static size_t peer_delete_mlo_params_size(struct peer_delete_cmd_params *req)
{
return WMI_TLV_HDR_SIZE;
}
static uint8_t *peer_delete_add_mlo_params(uint8_t *buf_ptr,
struct peer_delete_cmd_params *req)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static inline size_t vdev_stop_mlo_params_size(struct vdev_stop_params *params)
{
return WMI_TLV_HDR_SIZE;
}
static inline uint8_t *vdev_stop_add_mlo_params(uint8_t *buf_ptr,
struct vdev_stop_params *params)
{
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
return buf_ptr + WMI_TLV_HDR_SIZE;
}
static void wmi_11be_attach_tlv(wmi_unified_t wmi_handle)
{ }
static inline void
extract_mgmt_rx_mlo_link_removal_tlv_count(
int num_link_removal_tlvs,
struct mgmt_rx_event_params *hdr)
{
}
#endif /*WLAN_FEATURE_11BE_MLO*/
#endif /*_WMI_UNIFIED_11BE_TLV_H_*/

96
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_action_oui_tlv.h Normal file
View File

@@ -0,0 +1,96 @@
/*
* Copyright (c) 2016-2018 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_ACTION_OUI_TLV_H_
#define _WMI_UNIFIED_ACTION_OUI_TLV_H_
#ifdef WLAN_FEATURE_ACTION_OUI
#include "wmi.h"
#include "wmi_unified.h"
#include "wmi_unified_api.h"
#include "wmi_unified_param.h"
/**
* wmi_get_action_oui_info_mask() - convert info mask to firmware specific
* @info_mask: host specific info mask
*
* Return: firmware specific information mask
*/
uint32_t wmi_get_action_oui_info_mask(uint32_t info_mask);
/**
* wmi_get_action_oui_id() - convert action id to firmware specific
* @action_id: host specific action id
* @id: output pointer to hold converted fw specific action id
*
* Return: true on conversion else failure
*/
bool wmi_get_action_oui_id(enum action_oui_id action_id,
wmi_vendor_oui_action_id *id);
/**
* wmi_fill_oui_extensions() - populates wmi_vendor_oui_ext array
* @extension: pointer to user supplied action oui extensions
* @no_oui_extns: number of action oui extensions
* @cmd_ext: output pointer to TLV
*
* This function parses the user supplied input data and populates the
* array of variable structures TLV in WMI_PDEV_CONFIG_VENDOR_OUI_ACTION_CMDID
*
* Return: None
*/
void wmi_fill_oui_extensions(struct action_oui_extension *extension,
uint32_t no_oui_extns,
wmi_vendor_oui_ext *cmd_ext);
/**
* wmi_fill_oui_extensions_buffer() - populates data buffer in action oui cmd
* @extension: pointer to user supplied action oui extensions
* @cmd_ext: pointer to vendor_oui_ext TLV in action oui cmd
* @no_oui_extns: number of action oui extensions
* @rem_var_buf_len: remaining length of buffer to be populated
* @var_buf: output pointer to hold variable length data
*
* This function parses the user supplied input data and populates the variable
* buffer of type array byte TLV in WMI_PDEV_CONFIG_VENDOR_OUI_ACTION_CMDID
*
* Return: QDF_STATUS_SUCCESS for successful fill else QDF_STATUS_E_INVAL
*/
QDF_STATUS
wmi_fill_oui_extensions_buffer(struct action_oui_extension *extension,
wmi_vendor_oui_ext *cmd_ext,
uint32_t no_oui_extns, uint32_t rem_var_buf_len,
uint8_t *var_buf);
/**
* send_action_oui_cmd_tlv() - send action oui cmd to firmware
* @wmi_handle: wmi handler
* @req: pointer to action oui info
*
* Return: QDF_STATUS_SUCCESS on successful transmission else
* QDF_STATUS_E_INVAL or QDF_STATUS_E_NOMEM
*/
QDF_STATUS
send_action_oui_cmd_tlv(wmi_unified_t wmi_handle,
struct action_oui_request *req);
#endif /* WLAN_FEATURE_ACTION_OUI */
#endif /* _WMI_UNIFIED_ACTION_OUI_TLV_H_ */

100
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_apf_tlv.h Normal file
View File

@@ -0,0 +1,100 @@
/*
* Copyright (c) 2016-2018 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_APF_TLV_H_
#define _WMI_UNIFIED_APF_TLV_H_
#ifdef FEATURE_WLAN_APF
#include "wmi_unified.h"
#include "wmi_unified_api.h"
#include "wmi_unified_param.h"
/**
* wmi_send_set_active_apf_mode_cmd_tlv() - configure active APF mode in FW
* @wmi_handle: the WMI handle
* @vdev_id: the Id of the vdev to apply the configuration to
* @ucast_mode: the active APF mode to configure for unicast packets
* @mcast_bcast_mode: the active APF mode to configure for multicast/broadcast
* packets
*
* Return: QDF status
*/
QDF_STATUS
wmi_send_set_active_apf_mode_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t vdev_id,
enum wmi_host_active_apf_mode ucast_mode,
enum wmi_host_active_apf_mode
mcast_bcast_mode);
/**
* wmi_send_apf_enable_cmd_tlv() - send cmd to enable/disable APF interpreter
* @wmi_handle: the WMI handle
* @vdev_id: VDEV on which APF interpreter is to be enabled/disabled
* @enable: true: enable, false: disable
*
* Return: QDF status
*/
QDF_STATUS
wmi_send_apf_enable_cmd_tlv(wmi_unified_t wmi_handle, uint32_t vdev_id,
bool enable);
/**
* wmi_send_apf_write_work_memory_cmd_tlv() - send cmd to write into the APF
* work
* memory
* @wmi_handle: the WMI handle
* @apf_write_params: parameters and buffer pointer for the write
*
* Return: QDF status
*/
QDF_STATUS
wmi_send_apf_write_work_memory_cmd_tlv(wmi_unified_t wmi_handle,
struct wmi_apf_write_memory_params
*apf_write_params);
/**
* wmi_send_apf_read_work_memory_cmd_tlv() - send cmd to read part of APF
* work memory
* @wmi_handle: the WMI handle
* @apf_read_params: contains relative address and length to read from
*
* Return: QDF status
*/
QDF_STATUS
wmi_send_apf_read_work_memory_cmd_tlv(wmi_unified_t wmi_handle,
struct wmi_apf_read_memory_params
*apf_read_params);
/**
* wmi_extract_apf_read_memory_resp_event_tlv() - extract read memory response
* event into the given structure pointer
* @wmi_handle: the WMI handle
* @evt_buf: Pointer to the event buffer
* @resp: pointer to memory to extract event parameters into
*
* Return: QDF status
*/
QDF_STATUS
wmi_extract_apf_read_memory_resp_event_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_apf_read_memory_resp_event_params
*resp);
#endif /* FEATURE_WLAN_APF */
#endif /* _WMI_UNIFIED_APF_TLV_H_ */

5261
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_api.h Normal file
View File

File diff suppressed because it is too large Load Diff

43
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_bcn_api.h Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (c) 2013-2019 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) specific to beacon component
*/
#ifndef _WMI_UNIFIED_BCN_API_H_
#define _WMI_UNIFIED_BCN_API_H_
#include "wmi_unified_param.h"
#include "wmi_unified.h"
#include "wmi_unified_priv.h"
/**
* wmi_unified_bcn_buf_ll_cmd() - prepare and send beacon buffer to fw for LL
* @wmi_handle: wmi handle
* @param: bcn ll cmd parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_bcn_buf_ll_cmd(wmi_unified_t wmi_handle,
wmi_bcn_send_from_host_cmd_fixed_param * param);
#endif

87
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_cfr_api.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright (c) 2019, 2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_CFR_API_H_
#define _WMI_UNIFIED_CFR_API_H_
#include "wmi_unified_param.h"
#include "wmi_unified_cfr_param.h"
#ifdef WLAN_CFR_ENABLE
/**
* wmi_unified_send_peer_cfr_capture_cmd() - WMI function to start CFR capture
* for a peer
* @wmi_handle: WMI handle
* @param: configuration params for capture
*
* Return: QDF_STATUS_SUCCESS if success, else returns proper error code.
*/
QDF_STATUS
wmi_unified_send_peer_cfr_capture_cmd(wmi_unified_t wmi_handle,
struct peer_cfr_params *param);
/**
* wmi_extract_cfr_peer_tx_event_param() - WMI function to extract cfr tx event
* for a peer
* @wmi_handle: WMI handle
* @evt_buf: Buffer holding event data
* @peer_tx_event: pointer to hold tx event data
*
* Return: QDF_STATUS_SUCCESS if success, else returns proper error code.
*/
QDF_STATUS
wmi_extract_cfr_peer_tx_event_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_cfr_peer_tx_event_param *peer_tx_event);
#ifdef WLAN_ENH_CFR_ENABLE
/**
* wmi_unified_send_cfr_rcc_cmd() - WMI function to send CFR RCC param
* @wmi_handle: WMI handle
* @cfg: pointer to RCC param
*
* Return: QDF_STATUS_SUCCESS if success, else returns proper error code.
*/
QDF_STATUS wmi_unified_send_cfr_rcc_cmd(wmi_unified_t wmi_handle,
struct cfr_rcc_param *cfg);
/**
* wmi_extract_cfr_pdev_phase_delta_event() - WMI function to extract the
* phase delta information.
* @wmi_handle: WMI handle
* @evt_buf: Buffer holding the event data
* @param: phase delta params to be updated from event
*
* Return: QDF_STATUS_SUCCESS if success, else returns proper error code.
*/
QDF_STATUS
wmi_extract_cfr_pdev_phase_delta_event(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_cfr_phase_delta_param *param);
#ifdef WLAN_RCC_ENHANCED_AOA_SUPPORT
QDF_STATUS
wmi_extract_cfr_pdev_enhanced_aoa_phasedelta_event_fixed_param
(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_cfr_enh_phase_delta_param *param);
QDF_STATUS
wmi_extract_cfr_pdev_enhanced_aoa_phasedelta_event_data
(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_cfr_enh_phase_delta_param *param);
#endif /* WLAN_RCC_ENHANCED_AOA_SUPPORT */
#endif
#endif /* WLAN_CFR_ENABLE */
#endif /* _WMI_UNIFIED_CFR_API_H_ */

46
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_cfr_param.h Normal file
View File

@@ -0,0 +1,46 @@
/*
* Copyright (c) 2019, The Linux Foundation. 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_CFR_PARAM_H_
#define _WMI_UNIFIED_CFR_PARAM_H_
#ifdef WLAN_CFR_ENABLE
#define WMI_HOST_PEER_CFR_TIMER_ENABLE 1
#define WMI_HOST_PEER_CFR_TIMER_DISABLE 0
/**
* struct peer_cfr_params - peer cfr capture cmd parameter
* @request: enable/disable cfr capture
* @macaddr: macaddr of the client
* @vdev_id: vdev id
* @periodicity: cfr capture period
* @bandwidth: bandwidth of cfr capture
* @capture_method: cfr capture method/type
*/
struct peer_cfr_params {
uint32_t request;
uint8_t *macaddr;
uint32_t vdev_id;
uint32_t periodicity;
uint32_t bandwidth;
uint32_t capture_method;
};
#endif /* WLAN_CFR_ENABLE */
#endif /* _WMI_UNIFIED_CFR_PARAM_H_ */

85
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_concurrency_api.h Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright (c) 2013-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to concurrency component.
*/
#ifndef _WMI_UNIFIED_CONCURRENCY_API_H_
#define _WMI_UNIFIED_CONCURRENCY_API_H_
/**
* wmi_unified_set_mcc_channel_time_quota_cmd() - set MCC channel time quota
* @wmi_handle: wmi handle
* @adapter_1_chan_freq: adapter 1 channel number
* @adapter_1_quota: adapter 1 quota
* @adapter_2_chan_freq: adapter 2 channel number
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_mcc_channel_time_quota_cmd(
wmi_unified_t wmi_handle,
uint32_t adapter_1_chan_freq,
uint32_t adapter_1_quota, uint32_t adapter_2_chan_freq);
#ifdef WLAN_FEATURE_MCC_QUOTA
/**
* wmi_extract_mcc_quota_ev_param() - extract mcc_quota param from wmi event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold mcc_quota param
*
* Return: QDF_STATUS_SUCCESS on success or error code
*/
QDF_STATUS wmi_extract_mcc_quota_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct mcc_quota_info *param);
#endif
/**
* wmi_unified_set_mcc_channel_time_latency_cmd() - set MCC channel time latency
* @wmi_handle: wmi handle
* @mcc_channel_freq: mcc channel freq
* @mcc_channel_time_latency: MCC channel time latency.
*
* Currently used to set time latency for an MCC vdev/adapter using operating
* channel of it and channel number. The info is provided run time using
* iwpriv command: iwpriv <wlan0 | p2p0> setMccLatency <latency in ms>.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_mcc_channel_time_latency_cmd(
wmi_unified_t wmi_handle,
uint32_t mcc_channel_freq, uint32_t mcc_channel_time_latency);
/**
* wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd() - control mcc
* scheduler
* @wmi_handle: wmi handle
* @mcc_adaptive_scheduler: enable/disable
* @pdev_id: pdev id
*
* This function enable/disable mcc adaptive scheduler in fw.
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd(
wmi_unified_t wmi_handle, uint32_t mcc_adaptive_scheduler,
uint32_t pdev_id);
#endif /* _WMI_UNIFIED_CONCURRENCY_API_H_ */

183
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_cp_stats_api.h Normal file
View File

@@ -0,0 +1,183 @@
/*
* Copyright (c) 2013-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021,2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to cp stats component.
*/
#ifndef _WMI_UNIFIED_CP_STATS_API_H_
#define _WMI_UNIFIED_CP_STATS_API_H_
#ifdef QCA_SUPPORT_MC_CP_STATS
#include <wmi_unified_mc_cp_stats_api.h>
#endif
#include <wlan_cp_stats_public_structs.h>
#if defined(WLAN_SUPPORT_INFRA_CTRL_PATH_STATS) || \
defined(WLAN_CONFIG_TELEMETRY_AGENT)
/**
* wmi_unified_infra_cp_stats_request_send() - WMI request infra_cp_stats
* function
* @wmi_handle: wmi handle
* @param: pointer to hold infra_cp_stats request parameters
*
* Return: QDF_STATUS_SUCCESS on Success, other QDF_STATUS error
* codes on failure
*/
QDF_STATUS
wmi_unified_infra_cp_stats_request_send(
wmi_unified_t wmi_handle,
struct infra_cp_stats_cmd_info *param);
/**
* wmi_unified_extract_infra_cp_stats() - extract various infra cp statistics
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @evt_buf_len: length of event buffer
* @params: pointer to store the extracted event info
*
* This function extracts the infra cp statistics from the event
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_extract_infra_cp_stats(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t evt_buf_len,
struct infra_cp_stats_event *params);
/**
* wmi_stats_handler() - parse the wmi event and fill the stats values
* @wmi_handle: wmi handle
* @buff: Buffer containing wmi event
* @len: length of event buffer
* @params: buffer to hold parameters extracted from response event
*
* Return: QDF_STATUS_SUCCESS on success, else other qdf error values
*/
QDF_STATUS wmi_stats_handler(wmi_unified_t wmi_handle, void *buff, int32_t len,
struct infra_cp_stats_event *params);
QDF_STATUS
extract_infra_cp_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t evt_buf_len,
struct infra_cp_stats_event *params);
#endif /* WLAN_SUPPORT_INFRA_CTRL_PATH_STATS */
/**
* wmi_unified_stats_request_send() - WMI request stats function
* @wmi_handle: handle to WMI
* @macaddr: MAC address
* @param: pointer to hold stats request parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param);
#ifdef WLAN_FEATURE_BIG_DATA_STATS
/**
* wmi_unified_big_data_stats_request_send() - WMI request big data stats
* function
* @wmi_handle: handle to WMI
* @param: pointer to hold stats request parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_big_data_stats_request_send(wmi_unified_t wmi_handle,
struct stats_request_params *param);
#endif
/**
* wmi_extract_stats_param() - extract all stats count from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @stats_param: Pointer to hold stats count
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_stats_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param);
/**
* wmi_extract_pdev_stats() - extract pdev stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into pdev stats
* @pdev_stats: Pointer to hold pdev stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_pdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_pdev_stats *pdev_stats);
/**
* wmi_extract_vdev_stats() - extract vdev stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into vdev stats
* @vdev_stats: Pointer to hold vdev stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_vdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats);
/**
* wmi_extract_peer_stats() - extract peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into peer stats
* @peer_stats: Pointer to hold peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats *peer_stats);
/**
* wmi_extract_peer_extd_stats() - extract extended peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into extended peer stats
* @peer_extd_stats: Pointer to hold extended peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_extd_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats);
#ifdef WLAN_FEATURE_SON
/**
* wmi_extract_inst_rssi_stats_resp() - extract inst rssi stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @inst_rssi_resp: pointer to hold inst rssi stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_inst_rssi_stats_resp(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_inst_rssi_stats_resp *inst_rssi_resp);
#endif
#endif /* _WMI_UNIFIED_CP_STATS_API_H_ */

65
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_crypto_api.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright (c) 2019, 2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) specific to crypto component.
*/
#ifndef _WMI_UNIFIED_CRYPTO_API_H_
#define _WMI_UNIFIED_CRYPTO_API_H_
/*
* WMI_ADD_CIPHER_KEY_CMDID
*/
typedef enum {
PAIRWISE_USAGE = 0x00,
GROUP_USAGE = 0x01,
TX_USAGE = 0x02, /* default Tx Key - Static WEP only */
PMK_USAGE = 0x04, /* PMK cache */
} KEY_USAGE;
/**
* wmi_extract_install_key_comp_event() - extract params of install key complete
* from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @len: length of the event buffer
* @param: Pointer to hold params of install key complete
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_install_key_comp_event(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t len,
struct wmi_install_key_comp_event *param);
/**
* wmi_send_vdev_set_ltf_key_seed_cmd - Set LTF key seed for PASN key
* derivation.
* @wmi: WMI handle
* @data: LTF Keyseed data
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_send_vdev_set_ltf_key_seed_cmd(wmi_unified_t wmi,
struct wlan_crypto_ltf_keyseed_data *data);
#endif

111
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_dbr_api.h Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright (c) 2013-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to DBR component.
*/
#ifndef _WMI_UNIFIED_DBR_API_H_
#define _WMI_UNIFIED_DBR_API_H_
#include "wmi_unified_dbr_param.h"
/**
* wmi_unified_dbr_ring_cfg: Configure direct buffer rx rings
* @wmi_handle: WMI handle
* @cfg: pointer to direct buffer rx config request
*
* Return: QDF status of operation
*/
QDF_STATUS wmi_unified_dbr_ring_cfg(wmi_unified_t wmi_handle,
struct direct_buf_rx_cfg_req *cfg);
/**
* wmi_extract_dbr_buf_release_fixed : Extract direct buffer rx fixed param
* from buffer release event
* @wmi_handle: WMI handle
* @evt_buf: Event buffer
* @param: Pointer to direct buffer rx response struct
*
* Return: QDF status of operation
*/
QDF_STATUS wmi_extract_dbr_buf_release_fixed(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct direct_buf_rx_rsp *param);
/**
* wmi_extract_dbr_buf_release_entry: Extract direct buffer rx buffer tlv
*
* @wmi_handle: WMI handle
* @evt_buf: Event buffer
* @idx: Index of the module for which capability is received
* @param: Pointer to direct buffer rx entry
*
* Return: QDF status of operation
*/
QDF_STATUS wmi_extract_dbr_buf_release_entry(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_entry *param);
/**
* wmi_extract_dbr_buf_metadata: Extract direct buffer metadata
*
* @wmi_handle: WMI handle
* @evt_buf: Event buffer
* @idx: Index of the module for which capability is received
* @param: Pointer to direct buffer metadata
*
* Return: QDF status of operation
*/
QDF_STATUS wmi_extract_dbr_buf_metadata(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_metadata *param);
/**
* wmi_extract_dbr_buf_cv_metadata: Extract direct buffer TxBF cbf cv metadata
*
* @wmi_handle: WMI handle
* @evt_buf: Event buffer
* @idx: Index of the module for which capability is received
* @param: Pointer to direct buffer cv metadata
*
* Return: QDF status of operation
*/
QDF_STATUS wmi_extract_dbr_buf_cv_metadata(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_cv_metadata *param);
/**
* wmi_extract_dbr_buf_cqi_metadata: Extract direct buffer TxBF cqi metadata
*
* @wmi_handle: WMI handle
* @evt_buf: Event buffer
* @idx: Index of the module for which capability is received
* @param: Pointer to direct buffer cqi metadata
*
* Return: QDF status of operation
*/
QDF_STATUS wmi_extract_dbr_buf_cqi_metadata(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_cqi_metadata *param);
#endif /* _WMI_UNIFIED_DBR_API_H_ */

229
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_dbr_param.h Normal file
View File

@@ -0,0 +1,229 @@
/*
* Copyright (c) 2016-2018, 2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_DBR_PARAM_H_
#define _WMI_UNIFIED_DBR_PARAM_H_
#define WMI_HOST_DBR_RING_ADDR_LO_S 0
#define WMI_HOST_DBR_RING_ADDR_LO_M 0xffffffff
#define WMI_HOST_DBR_RING_ADDR_LO \
(WMI_HOST_DBR_RING_ADDR_LO_M << WMI_HOST_DBR_RING_ADDR_LO_S)
#define WMI_HOST_DBR_RING_ADDR_LO_GET(dword) \
WMI_HOST_F_MS(dword, WMI_HOST_DBR_RING_ADDR_LO)
#define WMI_HOST_DBR_RING_ADDR_LO_SET(dword, val) \
WMI_HOST_F_RMW(dword, val, WMI_HOST_DBR_RING_ADDR_LO)
#define WMI_HOST_DBR_RING_ADDR_HI_S 0
#define WMI_HOST_DBR_RING_ADDR_HI_M 0xf
#define WMI_HOST_DBR_RING_ADDR_HI \
(WMI_HOST_DBR_RING_ADDR_HI_M << WMI_HOST_DBR_RING_ADDR_HI_S)
#define WMI_HOST_DBR_RING_ADDR_HI_GET(dword) \
WMI_HOST_F_MS(dword, WMI_HOST_DBR_RING_ADDR_HI)
#define WMI_HOST_DBR_RING_ADDR_HI_SET(dword, val) \
WMI_HOST_F_RMW(dword, val, WMI_HOST_DBR_RING_ADDR_HI)
#define WMI_HOST_DBR_DATA_ADDR_LO_S 0
#define WMI_HOST_DBR_DATA_ADDR_LO_M 0xffffffff
#define WMI_HOST_DBR_DATA_ADDR_LO \
(WMI_HOST_DBR_DATA_ADDR_LO_M << WMI_HOST_DBR_DATA_ADDR_LO_S)
#define WMI_HOST_DBR_DATA_ADDR_LO_GET(dword) \
WMI_HOST_F_MS(dword, WMI_HOST_DBR_DATA_ADDR_LO)
#define WMI_HOST_DBR_DATA_ADDR_LO_SET(dword, val) \
WMI_HOST_F_RMW(dword, val, WMI_HOST_DBR_DATA_ADDR_LO)
#define WMI_HOST_DBR_DATA_ADDR_HI_S 0
#define WMI_HOST_DBR_DATA_ADDR_HI_M 0xf
#define WMI_HOST_DBR_DATA_ADDR_HI \
(WMI_HOST_DBR_DATA_ADDR_HI_M << WMI_HOST_DBR_DATA_ADDR_HI_S)
#define WMI_HOST_DBR_DATA_ADDR_HI_GET(dword) \
WMI_HOST_F_MS(dword, WMI_HOST_DBR_DATA_ADDR_HI)
#define WMI_HOST_DBR_DATA_ADDR_HI_SET(dword, val) \
WMI_HOST_F_RMW(dword, val, WMI_HOST_DBR_DATA_ADDR_HI)
#define WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_S 12
#define WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_M 0x7ffff
#define WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA \
(WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_M << \
WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_S)
#define WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_GET(dword) \
WMI_HOST_F_MS(dword, WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA)
#define WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA_SET(dword, val) \
WMI_HOST_F_RMW(dword, val, WMI_HOST_DBR_DATA_ADDR_HI_HOST_DATA)
#define WMI_HOST_MAX_NUM_CHAINS 8
/**
* struct direct_buf_rx_rsp: direct buffer rx response structure
*
* @pdev_id: Index of the pdev for which response is received
* @mod_id: Index of the module for which respone is received
* @num_buf_release_entry: Number of buffers released through event
* @num_meta_data_entry: Number of meta data released
* @num_cv_meta_data_entry: Number of cv meta data released
* @num_cqi_meta_data_entry: Number of cqi meta data released
* @dbr_entries: Pointer to direct buffer rx entry struct
*/
struct direct_buf_rx_rsp {
uint32_t pdev_id;
uint32_t mod_id;
uint32_t num_buf_release_entry;
uint32_t num_meta_data_entry;
uint32_t num_cv_meta_data_entry;
uint32_t num_cqi_meta_data_entry;
struct direct_buf_rx_entry *dbr_entries;
};
/**
* struct direct_buf_rx_cfg_req: direct buffer rx config request structure
*
* @pdev_id: Index of the pdev for which response is received
* @mod_id: Index of the module for which respone is received
* @base_paddr_lo: Lower 32bits of ring base address
* @base_paddr_hi: Higher 32bits of ring base address
* @head_idx_paddr_lo: Lower 32bits of head idx register address
* @head_idx_paddr_hi: Higher 32bits of head idx register address
* @tail_idx_paddr_lo: Lower 32bits of tail idx register address
* @tail_idx_paddr_hi: Higher 32bits of tail idx register address
* @buf_size: Size of the buffer for each pointer in the ring
* @num_elems: Number of pointers allocated and part of the source ring
* @event_timeout_ms:
* @num_resp_per_event:
*/
struct direct_buf_rx_cfg_req {
uint32_t pdev_id;
uint32_t mod_id;
uint32_t base_paddr_lo;
uint32_t base_paddr_hi;
uint32_t head_idx_paddr_lo;
uint32_t head_idx_paddr_hi;
uint32_t tail_idx_paddr_hi;
uint32_t tail_idx_paddr_lo;
uint32_t buf_size;
uint32_t num_elems;
uint32_t event_timeout_ms;
uint32_t num_resp_per_event;
};
/**
* struct direct_buf_rx_metadata: direct buffer metadata
*
* @noisefloor: noisefloor
* @reset_delay: reset delay
* @cfreq1: center frequency 1
* @cfreq2: center frequency 2
* @ch_width: channel width
*/
struct direct_buf_rx_metadata {
int32_t noisefloor[WMI_HOST_MAX_NUM_CHAINS];
uint32_t reset_delay;
uint32_t cfreq1;
uint32_t cfreq2;
uint32_t ch_width;
};
/**
* struct direct_buf_rx_cv_metadata: direct buffer metadata for TxBF CV upload
*
* @is_valid: Set cv metadata is valid,
* false if sw_peer_id is invalid or FCS error
* @fb_type: Feedback type, 0 for SU 1 for MU
* @asnr_len: Average SNR length
* @asnr_offset: Average SNR offset
* @dsnr_len: Delta SNR length
* @dsnr_offset: Delta SNR offset
* @peer_mac: Peer macaddr
* @fb_params: Feedback params, [1:0] Nc [3:2] nss_num
*/
struct direct_buf_rx_cv_metadata {
uint32_t is_valid;
uint32_t fb_type;
uint16_t asnr_len;
uint16_t asnr_offset;
uint16_t dsnr_len;
uint16_t dsnr_offset;
struct qdf_mac_addr peer_mac;
uint32_t fb_params;
};
/*
* In CQI data buffer, each user CQI data will be stored
* in a fixed offset of 64 locations from each other,
* and each location corresponds to 64-bit length.
*/
#define CQI_USER_DATA_LENGTH (64 * 8)
#define CQI_USER_DATA_OFFSET(idx) ((idx) * CQI_USER_DATA_LENGTH)
#define MAX_NUM_CQI_USERS 3
/*
* struct direct_buf_rx_cqi_per_user_info: Per user CQI data
*
* @asnr_len: Average SNR length
* @asnr_offset: Average SNR offset
* @fb_params: Feedback params, [1:0] Nc
* @peer_mac: Peer macaddr
*/
struct direct_buf_rx_cqi_per_user_info {
uint16_t asnr_len;
uint16_t asnr_offset;
uint32_t fb_params;
struct qdf_mac_addr peer_mac;
};
/**
* struct direct_buf_rx_cqi_metadata: direct buffer metadata for CQI upload
*
* @num_users: Number of user info in a metadta buffer
* @is_valid: Set cqi metadata is valid,
* false if sw_peer_id is invalid or FCS error
* @fb_type: Feedback type, 0 for SU 1 for MU 2 for CQI
* @fb_params: Feedback params
* [0] is_valid0
* [1] is_valid1
* [2] is_valid2
* [4:3] Nc0
* [5:4] Nc1
* [6:5] Nc2
* @user_info: Per user CQI info
*/
struct direct_buf_rx_cqi_metadata {
uint8_t num_users;
uint32_t is_valid;
uint32_t fb_type;
uint32_t fb_params;
struct direct_buf_rx_cqi_per_user_info user_info[MAX_NUM_CQI_USERS];
};
/**
* struct direct_buf_rx_entry: direct buffer rx release entry structure
*
* @paddr_lo: LSB 32-bits of the buffer
* @paddr_hi: MSB 32-bits of the buffer
* @len: Length of the buffer
*/
struct direct_buf_rx_entry {
uint32_t paddr_lo;
uint32_t paddr_hi;
uint32_t len;
};
#endif /* _WMI_UNIFIED_DBR_PARAM_H_ */

88
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_dcs_api.h Normal file
View File

@@ -0,0 +1,88 @@
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) which are specific to DFS module.
*/
#ifndef _WMI_UNIFIED_DCS_API_H_
#define _WMI_UNIFIED_DCS_API_H_
#include <qdf_status.h>
#include <wmi_unified_api.h>
#include <wmi_unified_priv.h>
#include <wlan_objmgr_vdev_obj.h>
/**
* wmi_extract_dcs_interference_type() - extract dcs interference type
* @wmi_hdl: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold dcs interference param
*
* This function gets called to extract dcs interference type from dcs FW event
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_dcs_interference_type(
void *wmi_hdl,
void *evt_buf,
struct wlan_host_dcs_interference_param *param);
/**
* wmi_extract_dcs_im_tgt_stats() - extract dcs im target stats
* @wmi_hdl: wmi handle
* @evt_buf: pointer to event buffer
* @wlan_stat: Pointer to hold wlan stats
*
* This function gets called to extract dcs im target stats from event
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_dcs_im_tgt_stats(
void *wmi_hdl,
void *evt_buf,
struct wlan_host_dcs_im_tgt_stats *wlan_stat);
/**
* wmi_extract_dcs_awgn_info() - extract DCS AWGN interference info from event
* @wmi_hdl: WMI handle
* @evt_buf: Pointer to event buffer
* @awgn_info: Pointer to hold AWGN interference info
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_dcs_awgn_info(wmi_unified_t wmi_hdl, void *evt_buf,
struct wlan_host_dcs_awgn_info *awgn_info);
/**
* wmi_send_dcs_pdev_param() - send dcs pdev param
* @wmi_handle: wmi handle
* @pdev_idx: pdev id
* @is_host_pdev_id: host pdev_id or not
* @dcs_enable: value of dcs enable
*
* This functions gets called to send dcs pdev param
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_send_dcs_pdev_param(wmi_unified_t wmi_handle,
uint32_t pdev_idx,
bool is_host_pdev_id,
uint32_t dcs_enable);
#endif /* _WMI_UNIFIED_DCS_API_H_ */

131
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_dfs_api.h Normal file
View File

@@ -0,0 +1,131 @@
/*
* Copyright (c) 2017-2019, 2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) which are specific to DFS module.
*/
#ifndef _WMI_UNIFIED_DFS_API_H_
#define _WMI_UNIFIED_DFS_API_H_
#include <wlan_objmgr_vdev_obj.h>
#include <wlan_dfs_utils_api.h>
/**
* wmi_extract_dfs_cac_complete_event() - function to handle cac complete event
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @vdev_id: vdev id
* @len: length of buffer
*
* Return: 0 for success or error code
*/
QDF_STATUS wmi_extract_dfs_cac_complete_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
uint32_t *vdev_id,
uint32_t len);
/**
* wmi_extract_dfs_ocac_complete_event() - function to handle off channel
* CAC complete event
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @param: off channel cac complete params
*
* Return: 0 for success or error code
*/
QDF_STATUS
wmi_extract_dfs_ocac_complete_event(wmi_unified_t wmi_handle, uint8_t *evt_buf,
struct vdev_adfs_complete_status *param);
/**
* wmi_extract_dfs_radar_detection_event() - function to handle radar event
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @radar_found: radar found event info
* @len: length of buffer
*
* Return: 0 for success or error code
*/
QDF_STATUS wmi_extract_dfs_radar_detection_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct radar_found_info *radar_found,
uint32_t len);
#ifdef MOBILE_DFS_SUPPORT
/**
* wmi_extract_wlan_radar_event_info() - function to handle radar pulse event.
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @wlan_radar_event: pointer to radar event info structure
* @len: length of buffer
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_extract_wlan_radar_event_info(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct radar_event_info *wlan_radar_event,
uint32_t len);
#endif
#if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD)
/**
* wmi_send_usenol_pdev_param() - function to send usenol pdev param.
* @wmi_handle: wmi handle
* @usenol: value of usenol
* @pdev: pointer to objmgr_pdev structure
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_send_usenol_pdev_param(wmi_unified_t wmi_handle, bool usenol,
struct wlan_objmgr_pdev *pdev);
/**
* wmi_send_subchan_marking_pdev_param() - Function to send subchannel
* marking pdev param.
* @wmi_handle: WMI handle.
* @subchanmark: Value of use subchannel marking.
* @pdev: Pointer to objmgr_pdev structure.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_send_subchan_marking_pdev_param(wmi_unified_t wmi_handle,
bool subchanmark,
struct wlan_objmgr_pdev *pdev);
#else
static inline QDF_STATUS
wmi_send_usenol_pdev_param(wmi_unified_t wmi_hdl, bool usenol,
struct wlan_objmgr_pdev *pdev)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS
wmi_send_subchan_marking_pdev_param(wmi_unified_t wmi_handle,
bool subchanmark,
struct wlan_objmgr_pdev *pdev)
{
return QDF_STATUS_SUCCESS;
}
#endif
#endif /* _WMI_UNIFIED_DFS_API_H_ */

169
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_extscan_api.h Normal file
View File

@@ -0,0 +1,169 @@
/*
* Copyright (c) 2013-2019 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _WMI_UNIFIED_EXTSCAN_API_H_
#define _WMI_UNIFIED_EXTSCAN_API_H_
/**
* wmi_unified_reset_passpoint_network_list_cmd() - reset passpoint network list
* @wmi_handle: wmi handle
* @req: passpoint network request structure
*
* This function sends down WMI command with network id set to wildcard id.
* firmware shall clear all the config entries
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_reset_passpoint_network_list_cmd(
wmi_unified_t wmi_handle,
struct wifi_passpoint_req_param *req);
/**
* wmi_unified_set_passpoint_network_list_cmd() - set passpoint network list
* @wmi_handle: wmi handle
* @req: passpoint network request structure
*
* This function reads the incoming @req and fill in the destination
* WMI structure and send down the passpoint configs down to the firmware
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_passpoint_network_list_cmd(
wmi_unified_t wmi_handle,
struct wifi_passpoint_req_param *req);
/** wmi_unified_set_epno_network_list_cmd() - set epno network list
* @wmi_handle: wmi handle
* @req: epno config params request structure
*
* This function reads the incoming epno config request structure
* and constructs the WMI message to the firmware.
*
* Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures,
* error number otherwise
*/
QDF_STATUS wmi_unified_set_epno_network_list_cmd(
wmi_unified_t wmi_handle,
struct wifi_enhanced_pno_params *req);
/**
* wmi_unified_extscan_get_capabilities_cmd() - extscan get capabilities
* @wmi_handle: wmi handle
* @pgetcapab: get capabilities params
*
* This function send request to fw to get extscan capabilities.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_extscan_get_capabilities_cmd(
wmi_unified_t wmi_handle,
struct extscan_capabilities_params *pgetcapab);
/**
* wmi_unified_extscan_get_cached_results_cmd() - extscan get cached results
* @wmi_handle: wmi handle
* @pcached_results: cached results parameters
*
* This function send request to fw to get cached results.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_extscan_get_cached_results_cmd(
wmi_unified_t wmi_handle,
struct extscan_cached_result_params *pcached_results);
/**
* wmi_unified_extscan_stop_change_monitor_cmd() - send stop change monitor cmd
* @wmi_handle: wmi handle
* @reset_req: Reset change request params
*
* This function sends stop change monitor request to fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_extscan_stop_change_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_capabilities_reset_params *reset_req);
/**
* wmi_unified_extscan_start_change_monitor_cmd() - start change monitor cmd
* @wmi_handle: wmi handle
* @psigchange: change monitor request params
*
* This function sends start change monitor request to fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_extscan_start_change_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_set_sig_changereq_params *psigchange);
/**
* wmi_unified_extscan_stop_hotlist_monitor_cmd() - stop hotlist monitor
* @wmi_handle: wmi handle
* @photlist_reset: hotlist reset params
*
* This function configures hotlist monitor to stop in fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_extscan_stop_hotlist_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_bssid_hotlist_reset_params *photlist_reset);
/**
* wmi_unified_extscan_start_hotlist_monitor_cmd() - start hotlist monitor
* @wmi_handle: wmi handle
* @params: hotlist params
*
* This function configures hotlist monitor to start in fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_extscan_start_hotlist_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_bssid_hotlist_set_params *params);
/**
* wmi_unified_stop_extscan_cmd() - stop extscan command to fw.
* @wmi_handle: wmi handle
* @pstopcmd: stop scan command request params
*
* This function sends stop extscan request to fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
*/
QDF_STATUS wmi_unified_stop_extscan_cmd(
wmi_unified_t wmi_handle,
struct extscan_stop_req_params *pstopcmd);
/**
* wmi_unified_start_extscan_cmd() - start extscan command to fw.
* @wmi_handle: wmi handle
* @pstart: scan command request params
*
* This function sends start extscan request to fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
*/
QDF_STATUS wmi_unified_start_extscan_cmd(
wmi_unified_t wmi_handle,
struct wifi_scan_cmd_req_params *pstart);
#endif /* _WMI_UNIFIED_EXTSCAN_API_H_ */

123
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_fwol_api.h Normal file
View File

@@ -0,0 +1,123 @@
/*
* Copyright (c) 2019-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to fw offload component.
*/
#ifndef _WMI_UNIFIED_FWOL_API_H_
#define _WMI_UNIFIED_FWOL_API_H_
#include "wlan_fwol_public_structs.h"
#ifdef WLAN_FEATURE_ELNA
/**
* wmi_unified_send_set_elna_bypass_cmd() - Send WMI set eLNA bypass cmd
* @wmi_handle: wmi handle
* @req: set eLNA bypass request
*
* Send WMI set eLNA bypass command to firmware.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_unified_send_set_elna_bypass_cmd(struct wmi_unified *wmi_handle,
struct set_elna_bypass_request *req);
/**
* wmi_unified_send_get_elna_bypass_cmd() - Send WMI get eLNA bypass cmd
* @wmi_handle: wmi handle
* @req: get eLNA bypass request
*
* Send WMI get eLNA bypass command to firmware.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_unified_send_get_elna_bypass_cmd(struct wmi_unified *wmi_handle,
struct get_elna_bypass_request *req);
/**
* wmi_extract_get_elna_bypass_resp() - Extract WMI get eLNA bypass response
* @wmi_handle: wmi handle
* @resp_buf: response buffer
* @resp: get eLNA bypass response
*
* Extract WMI get eLNA bypass response from firmware.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_extract_get_elna_bypass_resp(struct wmi_unified *wmi_handle, void *resp_buf,
struct get_elna_bypass_response *resp);
#endif /* WLAN_FEATURE_ELNA */
#ifdef WLAN_SEND_DSCP_UP_MAP_TO_FW
/**
* wmi_unified_send_dscp_tip_map_cmd() - Send dscp-to-tid map values cmd
* @wmi_handle: wmi handle
* @dscp_to_tid_map: array of dscp_tid map values
*
* Send dscp-to-tid map values to FW.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_unified_send_dscp_tip_map_cmd(struct wmi_unified *wmi_handle,
uint32_t *dscp_to_tid_map);
#else
static inline QDF_STATUS
wmi_unified_send_dscp_tip_map_cmd(struct wmi_unified *wmi_handle,
uint32_t *dscp_to_tid_map)
{
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_SEND_DSCP_UP_MAP_TO_FW */
#ifdef WLAN_FEATURE_MDNS_OFFLOAD
/**
* wmi_unified_send_set_mdns_config_cmd() - Send WMI set mDNS config cmd
* @wmi_handle: wmi handle
* @mdns_info: mdns config info
*
* Send WMI set mDNS config command to firmware.
*
* Return: QDF_STATUS
*/
QDF_STATUS
wmi_unified_send_set_mdns_config_cmd(struct wmi_unified *wmi_handle,
struct mdns_config_info *mdns_info);
#endif /* WLAN_FEATURE_MDNS_OFFLOAD */
/**
* wmi_unified_send_get_thermal_stats_cmd() - Send WMI get thermal stats req
* @wmi_handle: wmi handle
* @req_type: Request type
* @temp_offset: temperature offset for setting the range for thermal stats
*
* Send WMI get thermal stats req command to firmware.
*
* Return: QDF_STATUS
*/
#ifdef THERMAL_STATS_SUPPORT
QDF_STATUS
wmi_unified_send_get_thermal_stats_cmd(struct wmi_unified *wmi_handle,
enum thermal_stats_request_type req_type,
uint8_t temp_offset);
#endif /* THERMAL_STATS_SUPPORT */
#endif /* _WMI_UNIFIED_FWOL_API_H_ */

49
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_gpio_api.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright (c) 2020, The Linux Foundation. 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to gpio component.
*/
#ifndef _WMI_UNIFIED_GPIO_API_H_
#define _WMI_UNIFIED_GPIO_API_H_
#include <wmi_unified_param.h>
/**
* wmi_unified_gpio_config_cmd_send() - WMI gpio config function
* @wmi_handle: handle to WMI.
* @param: pointer to hold gpio config param
*
* Send WMI set gpio configuration to firmware.
*
* Return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_gpio_config_cmd_send(wmi_unified_t wmi_handle,
struct gpio_config_params *param);
/**
* wmi_unified_gpio_output_cmd_send() - WMI gpio output function
* @wmi_handle: handle to WMI.
* @param: pointer to hold gpio output param
*
* Send WMI set gpio output value to firmware.
*
* Return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_gpio_output_cmd_send(wmi_unified_t wmi_handle,
struct gpio_output_params *param);
#endif /* _WMI_UNIFIED_GPIO_API_H_ */

48
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_interop_issues_ap_api.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright (c) 2019 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to interop issues ap component.
*/
#ifndef _WMI_UNIFIED_INTEROP_ISSUES_AP_API_H_
#define _WMI_UNIFIED_INTEROP_ISSUES_AP_API_H_
#include <wmi_unified_param.h>
#include <wlan_interop_issues_ap_public_structs.h>
/**
* wmi_extract_interop_issues_ap_ev_param() - extract info from event
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @param: pointer to interop issues ap event structure
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_interop_issues_ap_ev_param(wmi_unified_t wmi_handle, void *evt_buf,
struct wlan_interop_issues_ap_event *param);
/**
* wmi_unified_set_rap_ps_cmd() - set interop issues ap for ps in fw
* @wmi_handle: wmi handle
* @rap: interop issues ap info
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_rap_ps_cmd(wmi_unified_t wmi_handle,
struct wlan_interop_issues_ap_info *rap);
#endif

206
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_nan_api.h Normal file
View File

@@ -0,0 +1,206 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to NAN component.
*/
#ifndef _WMI_UNIFIED_NAN_API_H_
#define _WMI_UNIFIED_NAN_API_H_
#include <nan_public_structs.h>
/**
* wmi_unified_nan_req_cmd() - to send nan request to target
* @wmi_handle: wmi handle
* @nan_req: request data which will be non-null
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_nan_req_cmd(wmi_unified_t wmi_handle,
struct nan_msg_params *nan_req);
/**
* wmi_unified_nan_disable_req_cmd() - to send nan disable request to target
* @wmi_handle: wmi handle
* @nan_req: pointer to NAN Disable request structure
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_nan_disable_req_cmd(wmi_unified_t wmi_handle,
struct nan_disable_req *nan_req);
/**
* wmi_unified_ndp_initiator_req_cmd_send - api to send initiator request to FW
* @wmi_handle: wmi handle
* @req: pointer to request buffer
*
* Return: status of operation
*/
QDF_STATUS
wmi_unified_ndp_initiator_req_cmd_send(wmi_unified_t wmi_handle,
struct nan_datapath_initiator_req *req);
/**
* wmi_unified_ndp_responder_req_cmd_send - api to send responder request to FW
* @wmi_handle: wmi handle
* @req: pointer to request buffer
*
* Return: status of operation
*/
QDF_STATUS
wmi_unified_ndp_responder_req_cmd_send(wmi_unified_t wmi_handle,
struct nan_datapath_responder_req *req);
/**
* wmi_unified_ndp_end_req_cmd_send - api to send end request to FW
* @wmi_handle: wmi handle
* @req: pointer to request buffer
*
* Return: status of operation
*/
QDF_STATUS wmi_unified_ndp_end_req_cmd_send(wmi_unified_t wmi_handle,
struct nan_datapath_end_req *req);
/**
* wmi_unified_terminate_all_ndps_req_cmd - api to request Firmware for
* termination of all NDP's associated with the given vdev id.
* @wmi_handle: wmi handle
* @vdev_id: vdev id
*
* Return: status of operation
*/
QDF_STATUS wmi_unified_terminate_all_ndps_req_cmd(wmi_unified_t wmi_handle,
uint32_t vdev_id);
/**
* wmi_extract_ndp_initiator_rsp - api to extract initiator rsp from even buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @rsp: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS
wmi_extract_ndp_initiator_rsp(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_initiator_rsp *rsp);
/**
* wmi_extract_ndp_ind - api to extract ndp indication struct from even buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @ind: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS wmi_extract_ndp_ind(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_indication_event *ind);
/**
* wmi_extract_nan_msg - api to extract ndp dmesg buffer to print logs
* @wmi_handle: wmi handle
* @data: event buffer
* @msg: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS wmi_extract_nan_msg(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_dump_msg *msg);
/**
* wmi_extract_ndp_confirm - api to extract ndp confim struct from even buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @ev: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS wmi_extract_ndp_confirm(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_confirm_event *ev);
/**
* wmi_extract_ndp_responder_rsp - api to extract responder rsp from even buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @rsp: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS
wmi_extract_ndp_responder_rsp(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_responder_rsp *rsp);
/**
* wmi_extract_ndp_end_rsp - api to extract ndp end rsp from even buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @rsp: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS wmi_extract_ndp_end_rsp(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_end_rsp_event *rsp);
/**
* wmi_extract_ndp_end_ind - api to extract ndp end indication from even buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @ind: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS
wmi_extract_ndp_end_ind(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_end_indication_event **ind);
/**
* wmi_extract_ndp_sch_update - api to extract ndp sch update from event buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @ind: buffer to populate
*
* Return: status of operation
*/
QDF_STATUS
wmi_extract_ndp_sch_update(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_sch_update_event *ind);
/**
* wmi_extract_nan_event_rsp - api to extract nan event into event parameters
* @wmi_handle: wmi handle
* @evt_buf: pointer to the event buffer
* @temp_evt_params: Pointer to a temporary parameters structure to populate
* @nan_msg_buf: Pointer to the NAN Message buffer encapsulated in the event
*
* Return: status of operation
*/
QDF_STATUS wmi_extract_nan_event_rsp(wmi_unified_t wmi_handle, void *evt_buf,
struct nan_event_params *temp_evt_params,
uint8_t **nan_msg_buf);
/**
* wmi_extract_ndp_host_event - api to extract ndp event from event buffer
* @wmi_handle: wmi handle
* @data: event buffer
* @evt: event buffer to populate
*
* Return: status of operation
*/
QDF_STATUS wmi_extract_ndp_host_event(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_host_event *evt);
#endif /* _WMI_UNIFIED_NAN_API_H_ */

160
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_ocb_api.h Normal file
View File

@@ -0,0 +1,160 @@
/*
* Copyright (c) 2013-2018 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to OCB component.
*/
#ifndef _WMI_UNIFIED_DSRC_API_H_
#define _WMI_UNIFIED_DSRC_API_H_
#include <wlan_ocb_public_structs.h>
/**
* wmi_unified_ocb_start_timing_advert() - start sending the timing
* advertisement frames on a channel
* @wmi_handle: pointer to the wmi handle
* @timing_advert: pointer to the timing advertisement struct
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_ocb_start_timing_advert(struct wmi_unified *wmi_handle,
struct ocb_timing_advert_param *timing_advert);
/**
* wmi_unified_ocb_stop_timing_advert() - stop sending the timing
* advertisement frames on a channel
* @wmi_handle: pointer to the wmi handle
* @timing_advert: pointer to the timing advertisement struct
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_ocb_stop_timing_advert(struct wmi_unified *wmi_handle,
struct ocb_timing_advert_param *timing_advert);
/**
* wmi_unified_ocb_set_config() - send the OCB config to the FW
* @wmi_handle: pointer to the wmi handle
* @config: the OCB configuration
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures
*/
QDF_STATUS wmi_unified_ocb_set_config(struct wmi_unified *wmi_handle,
struct ocb_config *config);
/**
* wmi_unified_ocb_get_tsf_timer() - get ocb tsf timer val
* @wmi_handle: pointer to the wmi handle
* @req: request for tsf timer
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_ocb_get_tsf_timer(struct wmi_unified *wmi_handle,
struct ocb_get_tsf_timer_param *req);
/**
* wmi_unified_ocb_set_utc_time_cmd() - set OCB UTC time
* @wmi_handle: pointer to the wmi handle
* @utc: UTC time
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_ocb_set_utc_time_cmd(struct wmi_unified *wmi_handle,
struct ocb_utc_param *utc);
/**
* wmi_unified_dcc_get_stats_cmd() - get the DCC channel stats
* @wmi_handle: pointer to the wmi handle
* @get_stats_param: pointer to the dcc stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_dcc_get_stats_cmd(struct wmi_unified *wmi_handle,
struct ocb_dcc_get_stats_param *get_stats_param);
/**
* wmi_unified_dcc_clear_stats() - command to clear the DCC stats
* @wmi_handle: pointer to the wmi handle
* @clear_stats_param: parameters to the command
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_dcc_clear_stats(struct wmi_unified *wmi_handle,
struct ocb_dcc_clear_stats_param *clear_stats_param);
/**
* wmi_unified_dcc_update_ndl() - command to update the NDL data
* @wmi_handle: pointer to the wmi handle
* @update_ndl_param: pointer to the request parameters
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures
*/
QDF_STATUS wmi_unified_dcc_update_ndl(struct wmi_unified *wmi_handle,
struct ocb_dcc_update_ndl_param *update_ndl_param);
/**
* wmi_extract_ocb_set_channel_config_resp() - extract status from wmi event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @status: status buffer
*
* Return: QDF_STATUS_SUCCESS on success
*/
QDF_STATUS
wmi_extract_ocb_set_channel_config_resp(struct wmi_unified *wmi_handle,
void *evt_buf,
uint32_t *status);
/**
* wmi_extract_ocb_tsf_timer() - extract tsf timer from wmi event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @resp: tsf timer
*
* Return: QDF_STATUS_SUCCESS on success
*/
QDF_STATUS wmi_extract_ocb_tsf_timer(struct wmi_unified *wmi_handle,
void *evt_buf,
struct ocb_get_tsf_timer_response *resp);
/**
* wmi_extract_dcc_update_ndl_resp() - extract NDL update from wmi event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @resp: ndl update status
*
* Return: QDF_STATUS_SUCCESS on success
*/
QDF_STATUS wmi_extract_dcc_update_ndl_resp(struct wmi_unified *wmi_handle,
void *evt_buf, struct ocb_dcc_update_ndl_response *resp);
/**
* wmi_extract_dcc_stats() - extract DCC stats from wmi event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @response: DCC stats
*
* Since length of the response is variable, response buffer will be allocated.
* The caller must free the response buffer.
*
* Return: QDF_STATUS_SUCCESS on success
*/
QDF_STATUS wmi_extract_dcc_stats(struct wmi_unified *wmi_handle,
void *evt_buf,
struct ocb_dcc_get_stats_response **response);
#endif /* _WMI_UNIFIED_DSRC_API_H_ */

107
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_p2p_api.h Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright (c) 2013-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to P2P component.
*/
#ifndef _WMI_UNIFIED_P2P_API_H_
#define _WMI_UNIFIED_P2P_API_H_
#include <wlan_p2p_public_struct.h>
/**
* wmi_unified_set_p2pgo_oppps_req() - send p2p go opp power save request to fw
* @wmi_handle: wmi handle
* @oppps: p2p opp power save parameters
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_p2pgo_oppps_req(wmi_unified_t wmi_handle,
struct p2p_ps_params *oppps);
/**
* wmi_unified_set_p2pgo_noa_req_cmd() - send p2p go noa request to fw
* @wmi_handle: wmi handle
* @noa: p2p power save parameters
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_p2pgo_noa_req_cmd(wmi_unified_t wmi_handle,
struct p2p_ps_params *noa);
/**
* wmi_extract_p2p_noa_ev_param() - extract p2p noa param from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold p2p noa param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_p2p_noa_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct p2p_noa_info *param);
/**
* wmi_extract_mac_addr_rx_filter_evt_param() - extract mac addr rx filter evt
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to extracted evt info
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_mac_addr_rx_filter_evt_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct p2p_set_mac_filter_evt *param);
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
/**
* wmi_unified_p2p_lo_start_cmd() - send p2p lo start request to fw
* @wmi_handle: wmi handle
* @param: p2p listen offload start parameters
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_p2p_lo_start_cmd(wmi_unified_t wmi_handle,
struct p2p_lo_start *param);
/**
* wmi_unified_p2p_lo_stop_cmd() - send p2p lo stop request to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_p2p_lo_stop_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id);
/**
* wmi_extract_p2p_lo_stop_ev_param() - extract p2p lo stop param from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold listen offload stop param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_p2p_lo_stop_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct p2p_lo_event *param);
#endif /* FEATURE_P2P_LISTEN_OFFLOAD */
#endif /* _WMI_UNIFIED_P2P_API_H_ */

10178
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_param.h Normal file
View File

File diff suppressed because it is too large Load Diff

421
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_pmo_api.h Normal file
View File

@@ -0,0 +1,421 @@
/*
* Copyright (c) 2017-2019, 2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) which are specific to Power management offloads (PMO).
*/
#ifndef _WMI_UNIFIED_PMO_API_H_
#define _WMI_UNIFIED_PMO_API_H_
#include "wlan_pmo_tgt_api.h"
#include "wlan_pmo_arp_public_struct.h"
#include "wlan_pmo_ns_public_struct.h"
#include "wlan_pmo_gtk_public_struct.h"
#include "wlan_pmo_wow_public_struct.h"
#include "wlan_pmo_pkt_filter_public_struct.h"
#ifdef FEATURE_WLAN_D0WOW
/**
* wmi_unified_d0wow_enable_send() - WMI d0 wow enable function
* @wmi_handle: handle to WMI.
* @mac_id: radio context
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_d0wow_enable_send(wmi_unified_t wmi_handle,
uint8_t mac_id);
/**
* wmi_unified_d0wow_disable_send() - WMI d0 wow disable function
* @wmi_handle: handle to WMI.
* @mac_id: radio context
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_d0wow_disable_send(wmi_unified_t wmi_handle,
uint8_t mac_id);
#endif /* FEATURE_WLAN_D0WOW */
/**
* wmi_unified_add_wow_wakeup_event_cmd() - Configures wow wakeup events.
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @bitmap: Event bitmap
* @enable: enable/disable
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_add_wow_wakeup_event_cmd(wmi_unified_t wmi_handle,
uint32_t vdev_id,
uint32_t *bitmap,
bool enable);
/**
* wmi_unified_wow_patterns_to_fw_cmd() - Sends WOW patterns to FW.
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @ptrn_id: pattern id
* @ptrn: pattern
* @ptrn_len: pattern length
* @ptrn_offset: pattern offset
* @mask: mask
* @mask_len: mask length
* @user: true for user configured pattern and false for default pattern
* @default_patterns: default patterns
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_wow_patterns_to_fw_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id, uint8_t ptrn_id,
const uint8_t *ptrn, uint8_t ptrn_len,
uint8_t ptrn_offset, const uint8_t *mask,
uint8_t mask_len, bool user,
uint8_t default_patterns);
/**
* wmi_unified_add_clear_mcbc_filter_cmd() - set mcast filter command to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @multicast_addr: mcast address
* @clear_list: clear list flag
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_add_clear_mcbc_filter_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id,
struct qdf_mac_addr multicast_addr,
bool clear_list);
/**
* wmi_unified_multiple_add_clear_mcbc_filter_cmd() - send multiple mcast
* filter command to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @filter_param: mcast filter params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_multiple_add_clear_mcbc_filter_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id,
struct pmo_mcast_filter_params *filter_param);
#ifdef FEATURE_WLAN_RA_FILTERING
/**
* wmi_unified_wow_sta_ra_filter_cmd() - set RA filter pattern in fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @default_pattern: default pattern id
* @rate_limit_interval: rate limit interval
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_wow_sta_ra_filter_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint8_t default_pattern,
uint16_t rate_limit_interval);
#endif
/**
* wmi_unified_enable_enhance_multicast_offload_cmd() - enhance multicast
* offload
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @action: true for enable else false
*
* To configure enhance multicast offload in to firmware
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_enable_enhance_multicast_offload_cmd(
wmi_unified_t wmi_handle, uint8_t vdev_id, bool action);
/**
* wmi_extract_gtk_rsp_event() - extract gtk rsp params from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @gtk_rsp_param: Pointer to gtk rsp parameters
* @len: len of gtk rsp event
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_gtk_rsp_event(
wmi_unified_t wmi_handle, void *evt_buf,
struct pmo_gtk_rsp_params *gtk_rsp_param, uint32_t len);
/**
* wmi_unified_process_gtk_offload_getinfo_cmd() - send GTK offload cmd to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @offload_req_opcode: gtk offload flag
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_process_gtk_offload_getinfo_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint64_t offload_req_opcode);
/**
* wmi_unified_action_frame_patterns_cmd() - send action filter wmi cmd
* @wmi_handle: wmi handler
* @action_params: pointer to action_params
*
* Return: 0 for success, otherwise appropriate error code
*/
QDF_STATUS wmi_unified_action_frame_patterns_cmd(
wmi_unified_t wmi_handle,
struct pmo_action_wakeup_set_params *action_params);
/**
* wmi_unified_send_gtk_offload_cmd() - send GTK offload command to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @params: GTK offload parameters
* @enable_offload: flag to enable offload
* @gtk_offload_opcode: gtk offload flag
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_send_gtk_offload_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
struct pmo_gtk_req *params,
bool enable_offload,
uint32_t gtk_offload_opcode);
/**
* wmi_unified_enable_arp_ns_offload_cmd() - enable ARP NS offload
* @wmi_handle: wmi handle
* @arp_offload_req: arp offload request
* @ns_offload_req: ns offload request
* @vdev_id: vdev id
*
* To configure ARP NS off load data to firmware
* when target goes to wow mode.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_enable_arp_ns_offload_cmd(
wmi_unified_t wmi_handle,
struct pmo_arp_offload_params *arp_offload_req,
struct pmo_ns_offload_params *ns_offload_req,
uint8_t vdev_id);
/**
* wmi_unified_conf_hw_filter_cmd() - Configure hardware filter in DTIM mode
* @wmi_handle: wmi handle
* @req: request parameters to configure to firmware
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_unified_conf_hw_filter_cmd(wmi_unified_t wmi_handle,
struct pmo_hw_filter_params *req);
#ifdef FEATURE_WLAN_LPHB
/**
* wmi_unified_lphb_config_hbenable_cmd() - enable command of LPHB configuration
* @wmi_handle: wmi handle
* @params: configuration info
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_lphb_config_hbenable_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_enable_cmd_fixed_param *params);
/**
* wmi_unified_lphb_config_tcp_params_cmd() - set tcp params of LPHB config req
* @wmi_handle: wmi handle
* @lphb_conf_req: lphb config request
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_lphb_config_tcp_params_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_tcp_params_cmd_fixed_param *lphb_conf_req);
/**
* wmi_unified_lphb_config_tcp_pkt_filter_cmd() - config LPHB tcp packet filter
* @wmi_handle: wmi handle
* @g_hb_tcp_filter_fp: lphb config request
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_lphb_config_tcp_pkt_filter_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *g_hb_tcp_filter_fp);
/**
* wmi_unified_lphb_config_udp_params_cmd() - configure LPHB udp param command
* @wmi_handle: wmi handle
* @lphb_conf_req: lphb config request
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_lphb_config_udp_params_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_udp_params_cmd_fixed_param *lphb_conf_req);
/**
* wmi_unified_lphb_config_udp_pkt_filter_cmd() - configure LPHB udp pkt filter
* @wmi_handle: wmi handle
* @lphb_conf_req: lphb config request
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_lphb_config_udp_pkt_filter_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req);
#endif /* FEATURE_WLAN_LPHB */
#ifdef WLAN_FEATURE_PACKET_FILTERING
/**
* wmi_unified_enable_disable_packet_filter_cmd() - enable/disable packet filter
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @enable: Flag to enable/disable packet filter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_enable_disable_packet_filter_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
bool enable);
/**
* wmi_unified_config_packet_filter_cmd() - configure packet filter in target
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @rcv_filter_param: Packet filter parameters
* @filter_id: Filter id
* @enable: Flag to add/delete packet filter configuration
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_config_packet_filter_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id, struct pmo_rcv_pkt_fltr_cfg *rcv_filter_param,
uint8_t filter_id, bool enable);
#endif /* WLAN_FEATURE_PACKET_FILTERING */
/**
* wmi_unified_wow_delete_pattern_cmd() - delete wow pattern in target
* @wmi_handle: wmi handle
* @ptrn_id: pattern id
* @vdev_id: vdev id
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_wow_delete_pattern_cmd(wmi_unified_t wmi_handle,
uint8_t ptrn_id,
uint8_t vdev_id);
/**
* wmi_unified_host_wakeup_ind_to_fw_cmd() - send wakeup ind to fw
* @wmi_handle: wmi handle
* @tx_pending_ind: flag of TX has pending frames
*
* Sends host wakeup indication to FW. On receiving this indication,
* FW will come out of WOW.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_host_wakeup_ind_to_fw_cmd(wmi_unified_t wmi_handle,
bool tx_pending_ind);
/**
* wmi_unified_wow_timer_pattern_cmd() - set timer pattern tlv, so that
* firmware will wake up host after
* specified time is elapsed
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @cookie: value to identify reason why host set up wake call.
* @time: time in ms
*
* Return: QDF status
*/
QDF_STATUS wmi_unified_wow_timer_pattern_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint32_t cookie, uint32_t time);
#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
/**
* wmi_unified_enable_ext_wow_cmd() - enable ext wow in fw
* @wmi_handle: wmi handle
* @params: ext wow params
*
* Return:QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_enable_ext_wow_cmd(wmi_unified_t wmi_handle,
struct ext_wow_params *params);
/**
* wmi_unified_set_app_type2_params_in_fw_cmd() - set app type2 params in fw
* @wmi_handle: wmi handle
* @appType2Params: app type2 params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_app_type2_params_in_fw_cmd(
wmi_unified_t wmi_handle,
struct app_type2_params *appType2Params);
/**
* wmi_unified_app_type1_params_in_fw_cmd() - set app type1 params in fw
* @wmi_handle: wmi handle
* @app_type1_params: app type1 params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_app_type1_params_in_fw_cmd(
wmi_unified_t wmi_handle,
struct app_type1_params *app_type1_params);
#endif /* WLAN_FEATURE_EXTWOW_SUPPORT */
#ifdef WLAN_FEATURE_IGMP_OFFLOAD
/**
* wmi_unified_send_igmp_offload_cmd() - send igmp offload cmd to fw
* @wmi_handle: wmi handle
* @pmo_igmp_req: igmp params
*
* Return: Success or failure
*/
QDF_STATUS
wmi_unified_send_igmp_offload_cmd(wmi_unified_t wmi_handle,
struct pmo_igmp_offload_req *pmo_igmp_req);
#endif
#ifdef WLAN_FEATURE_ICMP_OFFLOAD
/**
* wmi_unified_config_icmp_offload_cmd() - enable ICMP offload
* @wmi_handle: wmi handle
* @pmo_icmp_req: icmp offload request
*
* To configure ICMP offload data to firmware
* when target goes to wow mode.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_config_icmp_offload_cmd(wmi_unified_t wmi_handle,
struct pmo_icmp_offload *pmo_icmp_req);
#endif
#endif /* _WMI_UNIFIED_PMO_API_H_ */

4087
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_priv.h Normal file
View File

File diff suppressed because it is too large Load Diff

153
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_reg_api.h Normal file
View File

@@ -0,0 +1,153 @@
/*
* Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: This file contains the API definitions for the Unified Wireless Module
* Interface (WMI) which are specific to Regulatory module.
*/
#ifndef _WMI_UNIFIED_REG_API_H_
#define _WMI_UNIFIED_REG_API_H_
#include "reg_services_public_struct.h"
/**
* wmi_extract_reg_chan_list_update_event() - function to update channel list
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @reg_info: regulatory info
* @len: length of buffer
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_extract_reg_chan_list_update_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct cur_regulatory_info *reg_info,
uint32_t len);
#ifdef CONFIG_BAND_6GHZ
/**
* wmi_extract_reg_chan_list_ext_update_event() - function to update the
* extended channel list
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @reg_info: regulatory info
* @len: length of buffer
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_extract_reg_chan_list_ext_update_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct cur_regulatory_info *reg_info,
uint32_t len);
#ifdef CONFIG_AFC_SUPPORT
/**
* wmi_extract_afc_event() - function to read the contents of the AFC event
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @afc_info: AFC regulatory info
* @len: length of buffer
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_extract_afc_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct afc_regulatory_info *afc_info,
uint32_t len);
#endif
#endif
/*
* wmi_unified_send_stop_11d_scan_cmd() - stop 11d scan
* @wmi_handle: wmi handle
* @stop_11d_scan: pointer to 11d scan stop req.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_stop_11d_scan_cmd(wmi_unified_t wmi_handle,
struct reg_stop_11d_scan_req *stop_11d_scan);
/*
* wmi_unified_send_start_11d_scan_cmd() - start 11d scan
* @wmi_handle: wmi handle
* @start_11d_scan: pointer to 11d scan start req.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_start_11d_scan_cmd(wmi_unified_t wmi_handle,
struct reg_start_11d_scan_req *start_11d_scan);
/**
* wmi_extract_reg_11d_new_cc_event() - function to extract the 11d new country
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @reg_11d_new_cc: pointer to new 11d country info
* @len: length of buffer
*
* Return: 0 for success or error code
*/
QDF_STATUS wmi_extract_reg_11d_new_cc_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct reg_11d_new_country *reg_11d_new_cc,
uint32_t len);
/**
* wmi_unified_set_user_country_code_cmd_send() - WMI set country function
* @wmi_handle: wmi handle.
* @pdev_id: Pdev id
* @rd: User country code or regdomain
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_user_country_code_cmd_send(
wmi_unified_t wmi_handle,
uint8_t pdev_id, struct cc_regdmn_s *rd);
/**
* wmi_extract_reg_ch_avoid_event() - process freq avoid event
* @wmi_handle: wmi handle.
* @evt_buf: event buffer
* @ch_avoid_ind: buffer pointer to save the event processed data
* @len: length of buffer
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_reg_ch_avoid_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct ch_avoid_ind_type *ch_avoid_ind,
uint32_t len);
/**
* wmi_extract_tgtr2p_table_event() - function to read the contents of the
* rate2power update response event
* @wmi_handle: wmi handle
* @evt_buf: event buffer
* @update_status: Status object
* @len: length of buffer
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE on error
*/
QDF_STATUS wmi_extract_tgtr2p_table_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct r2p_table_update_status_obj *update_status,
uint32_t len);
#endif /* _WMI_UNIFIED_REG_API_H_ */

457
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_sta_api.h Normal file
View File

@@ -0,0 +1,457 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to STA component.
*/
#ifndef _WMI_UNIFIED_STA_API_H_
#define _WMI_UNIFIED_STA_API_H_
#include "wlan_disa_public_struct.h"
#include "wlan_tdls_public_structs.h"
#include "wlan_policy_mgr_public_struct.h"
#include "wmi_unified_sta_param.h"
struct policy_mgr_dual_mac_config;
/**
* wmi_unified_set_sta_sa_query_param_cmd() - set sta sa query parameters
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @max_retries: max retries
* @retry_interval: retry interval
* This function sets sta query related parameters in fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_sta_sa_query_param_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint32_t max_retries,
uint32_t retry_interval);
/**
* wmi_unified_set_sta_keep_alive_cmd() - set sta keep alive parameters
* @wmi_handle: wmi handle
* @params: sta keep alive parameter
*
* This function sets keep alive related parameters in fw.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_set_sta_keep_alive_cmd(wmi_unified_t wmi_handle,
struct sta_keep_alive_params *params);
/**
* wmi_unified_vdev_set_gtx_cfg_cmd() - set GTX params
* @wmi_handle: wmi handle
* @if_id: vdev id
* @gtx_info: GTX config params
*
* This function set GTX related params in firmware.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_vdev_set_gtx_cfg_cmd(wmi_unified_t wmi_handle, uint32_t if_id,
struct wmi_gtx_config *gtx_info);
#if defined(WLAN_FEATURE_ROAM_OFFLOAD) && defined(FEATURE_DENYLIST_MGR)
/**
* wmi_unified_send_reject_ap_list() - send the reject ap list maintained by
* DLM to FW for roaming cases.
* @wmi_handle: wmi handle
* @reject_params: This contains the reject ap list, and the num of BSSIDs.
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS
wmi_unified_send_reject_ap_list(struct wmi_unified *wmi_handle,
struct reject_ap_params *reject_params);
#endif
/**
* wmi_unified_process_dhcp_ind() - process dhcp indication from SME
* @wmi_handle: wmi handle
* @ta_dhcp_ind: DHCP indication parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_process_dhcp_ind(
wmi_unified_t wmi_handle,
wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind);
/**
* wmi_unified_get_link_speed_cmd() -send command to get linkspeed
* @wmi_handle: wmi handle
* @peer_macaddr: peer MAC address
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_get_link_speed_cmd(wmi_unified_t wmi_handle,
wmi_mac_addr peer_macaddr);
/**
* wmi_unified_fw_profiling_data_cmd() - send FW profiling cmd to WLAN FW
* @wmi_handle: wmi handle
* @cmd: Profiling command index
* @value1: parameter1 value
* @value2: parameter2 value
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_fw_profiling_data_cmd(wmi_unified_t wmi_handle,
uint32_t cmd,
uint32_t value1,
uint32_t value2);
/**
* wmi_unified_nat_keepalive_en_cmd() - enable NAT keepalive filter
* @wmi_handle: wmi handle
* @vdev_id: vdev id
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_nat_keepalive_en_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id);
/**
* wmi_unified_wlm_latency_level_cmd() - set latency level
* @wmi_handle: wmi handle
* @param: WLM parameters
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_wlm_latency_level_cmd(wmi_unified_t wmi_handle,
struct wlm_latency_level_param *param);
/**
* wmi_unified_process_set_ie_info_cmd() - Function to send IE info to firmware
* @wmi_handle: Pointer to WMI handle
* @ie_info: Pointer for IE information
*
* This function sends IE information to firmware
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_process_set_ie_info_cmd(wmi_unified_t wmi_handle,
struct vdev_ie_info_param *ie_info);
/**
* wmi_unified_set_base_macaddr_indicate_cmd() - set base mac address in fw
* @wmi_handle: wmi handle
* @custom_addr: base mac address
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_base_macaddr_indicate_cmd(wmi_unified_t wmi_handle,
uint8_t *custom_addr);
#ifdef FEATURE_WLAN_TDLS
/**
* wmi_unified_set_tdls_offchan_mode_cmd() - set tdls off channel mode
* @wmi_handle: wmi handle
* @chan_switch_params: Pointer to tdls channel switch parameter structure
*
* This function sets tdls off channel mode
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures;
* Negative errno otherwise
*/
QDF_STATUS wmi_unified_set_tdls_offchan_mode_cmd(
wmi_unified_t wmi_handle,
struct tdls_channel_switch_params *chan_switch_params);
/**
* wmi_unified_update_fw_tdls_state_cmd() - send enable/disable tdls for a vdev
* @wmi_handle: wmi handle
* @tdls_param: TDLS params
* @tdls_state: TDLS state
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_update_fw_tdls_state_cmd(wmi_unified_t wmi_handle,
struct tdls_info *tdls_param,
enum wmi_tdls_state tdls_state);
/**
* wmi_unified_update_tdls_peer_state_cmd() - update TDLS peer state
* @wmi_handle: wmi handle
* @peer_state: TDLS peer state params
* @ch_mhz: peer channel list
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_update_tdls_peer_state_cmd(wmi_unified_t wmi_handle,
struct tdls_peer_update_state *peer_state,
uint32_t *ch_mhz);
/**
* wmi_extract_vdev_tdls_ev_param - extract vdev tdls param from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold vdev tdls param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_vdev_tdls_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct tdls_event_info *param);
#endif /* FEATURE_WLAN_TDLS */
/**
* wmi_unified_send_sar_limit_cmd() - send sar limit cmd to fw
* @wmi_handle: wmi handle
* @params: sar limit command params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_send_sar_limit_cmd(wmi_unified_t wmi_handle,
struct sar_limit_cmd_params *params);
/**
* wmi_unified_get_sar_limit_cmd() - request current SAR limits from FW
* @wmi_handle: wmi handle
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS wmi_unified_get_sar_limit_cmd(wmi_unified_t wmi_handle);
/**
* wmi_unified_extract_sar_limit_event() - extract SAR limits from FW event
* @wmi_handle: wmi handle
* @evt_buf: event buffer received from firmware
* @event: SAR limit event which is to be populated by data extracted from
* the @evt_buf buffer
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS wmi_unified_extract_sar_limit_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct sar_limit_event *event);
/**
* wmi_unified_extract_sar2_result_event() - extract SAR limits from FW event
* @handle: wmi handle
* @event: event buffer received from firmware
* @len: length of the event buffer
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS wmi_unified_extract_sar2_result_event(void *handle,
uint8_t *event, uint32_t len);
/**
* wmi_unified_set_del_pmkid_cache() - set delete PMKID
* @wmi_handle: wmi handle
* @pmksa: pointer to pmk cache entry
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_set_del_pmkid_cache(wmi_unified_t wmi_handle,
struct wmi_unified_pmk_cache *pmksa);
/**
* wmi_unified_del_ts_cmd() - send DELTS request to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @ac: ac param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_del_ts_cmd(wmi_unified_t wmi_handle, uint8_t vdev_id,
uint8_t ac);
/**
* wmi_unified_aggr_qos_cmd() - send aggr qos request to fw
* @wmi_handle: handle to wmi
* @aggr_qos_rsp_msg: combined struct for all ADD_TS requests.
*
* A function to handle WMI_AGGR_QOS_REQ. This will send out
* ADD_TS requests to firmware in loop for all the ACs with
* active flow.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_aggr_qos_cmd(
wmi_unified_t wmi_handle,
struct aggr_add_ts_param *aggr_qos_rsp_msg);
/**
* wmi_unified_add_ts_cmd() - send ADDTS request to fw
* @wmi_handle: wmi handle
* @msg: ADDTS params
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_add_ts_cmd(wmi_unified_t wmi_handle,
struct add_ts_param *msg);
/**
* wmi_unified_process_add_periodic_tx_ptrn_cmd() - add periodic tx pattern
* @wmi_handle: wmi handle
* @pattern: tx pattern parameters
* @vdev_id: vdev id
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_process_add_periodic_tx_ptrn_cmd(
wmi_unified_t wmi_handle,
struct periodic_tx_pattern *pattern,
uint8_t vdev_id);
/**
* wmi_unified_process_del_periodic_tx_ptrn_cmd() - del periodic tx ptrn
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @pattern_id: pattern id
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_process_del_periodic_tx_ptrn_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint8_t pattern_id);
/**
* wmi_unified_set_auto_shutdown_timer_cmd() - sets auto shutdown
* timer in firmware
* @wmi_handle: wmi handle
* @timer_val: auto shutdown timer value
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_auto_shutdown_timer_cmd(wmi_unified_t wmi_handle,
uint32_t timer_val);
/**
* wmi_unified_set_led_flashing_cmd() - set led flashing in fw
* @wmi_handle: wmi handle
* @flashing: flashing request
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_set_led_flashing_cmd(wmi_unified_t wmi_handle,
struct flashing_req_params *flashing);
/**
* wmi_unified_process_ch_avoid_update_cmd() - handles channel avoid
* update request
* @wmi_handle: wmi handle
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_process_ch_avoid_update_cmd(wmi_unified_t wmi_handle);
/**
* wmi_unified_pdev_set_pcl_cmd() - Send WMI_SOC_SET_PCL_CMDID to FW
* @wmi_handle: wmi handle
* @msg: PCL structure containing the PCL and the number of channels
*
* WMI_SOC_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN
* firmware. The DBS Manager is the consumer of this information in the WLAN
* firmware. The channel list will be used when a Virtual DEVice (VDEV) needs
* to migrate to a new channel without host driver involvement. An example of
* this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will
* manage the channel selection without firmware involvement.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_pdev_set_pcl_cmd(wmi_unified_t wmi_handle,
struct wmi_pcl_chan_weights *msg);
#ifdef WLAN_POLICY_MGR_ENABLE
/**
* wmi_unified_pdev_set_dual_mac_config_cmd() - Set dual mac config to FW
* @wmi_handle: wmi handle
* @msg: Dual MAC config parameters
*
* Configures WLAN firmware with the dual MAC features
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures.
*/
QDF_STATUS wmi_unified_pdev_set_dual_mac_config_cmd(
wmi_unified_t wmi_handle,
struct policy_mgr_dual_mac_config *msg);
#endif /* WLAN_POLICY_MGR_ENABLE */
/**
* wmi_unified_send_adapt_dwelltime_params_cmd() - send wmi cmd of
* adaptive dwelltime configuration params
* @wmi_handle: wmi handler
* @wmi_param: pointer to dwelltime_params
*
* Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure
*/
QDF_STATUS wmi_unified_send_adapt_dwelltime_params_cmd(
wmi_unified_t wmi_handle,
struct wmi_adaptive_dwelltime_params *wmi_param);
/**
* wmi_unified_send_dbs_scan_sel_params_cmd() - send wmi cmd of
* DBS scan selection configuration params
* @wmi_handle: wmi handler
* @wmi_param: pointer to wmi_dbs_scan_sel_params
*
* Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure
*/
QDF_STATUS wmi_unified_send_dbs_scan_sel_params_cmd(
wmi_unified_t wmi_handle,
struct wmi_dbs_scan_sel_params *wmi_param);
/**
* wmi_unified_set_arp_stats_req() - set arp stats request
* @wmi_handle: wmi handle
* @req_buf: pointer to set_arp_stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_set_arp_stats_req(wmi_unified_t wmi_handle,
struct set_arp_stats *req_buf);
/**
* wmi_unified_get_arp_stats_req() - get arp stats request
* @wmi_handle: wmi handle
* @req_buf: pointer to get_arp_stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_get_arp_stats_req(wmi_unified_t wmi_handle,
struct get_arp_stats *req_buf);
/**
* wmi_unified_peer_unmap_conf_send() - send PEER unmap conf command to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev id
* @peer_id_cnt: number of peer id
* @peer_id_list: list of peer ids
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_peer_unmap_conf_send(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint32_t peer_id_cnt,
uint16_t *peer_id_list);
#endif /* _WMI_UNIFIED_STA_API_H_ */

376
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_sta_param.h Normal file
View File

@@ -0,0 +1,376 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API definitions for the STA WMI APIs.
*/
#ifndef _WMI_UNIFIED_STA_PARAM_H_
#define _WMI_UNIFIED_STA_PARAM_H_
/**
* struct sta_keep_alive_params - sta keep alive parameters
* @vdev_id: vdev id
* @method: keep alive method
* @timeperiod: time to keep alive
* @hostv4addr: host ipv4 address
* @destv4addr: destination ipv4 address
* @destmac: destination mac address
*/
struct sta_keep_alive_params {
uint8_t vdev_id;
uint32_t method;
uint32_t timeperiod;
uint8_t hostv4addr[QDF_IPV4_ADDR_SIZE];
uint8_t destv4addr[QDF_IPV4_ADDR_SIZE];
uint8_t destmac[QDF_MAC_ADDR_SIZE];
};
/**
* struct wmi_gtx_config - GTX config
* @gtx_rt_mask: for HT and VHT rate masks
* @gtx_usrcfg: host request for GTX mask
* @gtx_threshold: PER Threshold (default: 10%)
* @gtx_margin: PER margin (default: 2%)
* @gtx_tpcstep: TPC step (default: 1)
* @gtx_tpcmin: TPC min (default: 5)
* @gtx_bwmask: BW mask (20/40/80/160 Mhz)
*/
struct wmi_gtx_config {
uint32_t gtx_rt_mask[2];
uint32_t gtx_usrcfg;
uint32_t gtx_threshold;
uint32_t gtx_margin;
uint32_t gtx_tpcstep;
uint32_t gtx_tpcmin;
uint32_t gtx_bwmask;
};
/**
* struct wlm_latency_level_param - WLM parameters
* @wlm_latency_level: wlm latency level to set
* 0 - normal, 1 - moderate, 2 - low, 3 - ultralow
* @wlm_latency_flags: wlm latency flags to set
* |31 12| 11 | 10 |9 8|7 6|5 4|3 2| 1 | 0 |
* +------+------+------+------+------+------+------+-----+-----+
* | RSVD | SSLP | CSLP | RSVD | Roam | RSVD | DWLT | DFS | SUP |
* +------+-------------+-------------+-------------------------+
* | WAL | PS | Roam | Scan |
*
* bit 0: Avoid scan request from HLOS if setting
* bit 1: Skip DFS channel SCAN if setting
* bit 2-3: Define policy of dwell time/duration for each foreign channel
* (b2 b3)
* (0 0 ): Default scan dwell time
* (0 1 ): Reserve
* (1 0 ): Shrink off channel dwell time
* (1 1 ): Reserve
* bit 4-5: Reserve for scan
* bit 6-7: Define roaming policy
* (b6 b7)
* (0 0 ): Default roaming behavior, allow roaming in all scenarios
* (0 1 ): Disallow all roaming
* (1 0 ): Allow roaming when final bmissed
* (1 1 ): Reserve
* bit 8-9: Reserve for roaming
* bit 10: Disable css power collapse if setting
* bit 11: Disable sys sleep if setting
* bit 12-31: Reserve for future usage
* @vdev_id: vdev id
* @force_reset: bit 0 used as force reset to override the latency level as
* default for all the wlm clients
* @client_id_bitmask: clients of WLM Arbiter
*/
struct wlm_latency_level_param {
uint16_t wlm_latency_level;
uint32_t wlm_latency_flags;
uint16_t vdev_id;
#ifdef MULTI_CLIENT_LL_SUPPORT
uint32_t force_reset;
uint32_t client_id_bitmask;
#endif
};
#define WMI_2_4_GHZ_MAX_FREQ 3000
/**
* struct vdev_ie_info_param - IE info
* @vdev_id: vdev for which the IE is being sent
* @ie_id: ID of the IE
* @length: length of the IE data
* @ie_source:
* @band:
* @data: IE data
*
* This structure is used to store the IE information.
*/
struct vdev_ie_info_param {
uint32_t vdev_id;
uint32_t ie_id;
uint32_t length;
uint32_t ie_source;
uint32_t band;
uint8_t *data;
};
#define MAX_SAR_LIMIT_ROWS_SUPPORTED 64
/**
* struct sar_limit_cmd_row - sar limits row
* @band_id: Optional param for frequency band
* See %enum wmi_sar_band_id_flags for possible values
* @chain_id: Optional param for antenna chain id
* @mod_id: Optional param for modulation scheme
* See %enum wmi_sar_mod_id_flags for possible values
* @limit_value: Mandatory param providing power limits in steps of 0.5 dbm
* @validity_bitmap: bitmap of valid optional params in sar_limit_cmd_row struct
* See WMI_SAR_*_VALID_MASK for possible values
*/
struct sar_limit_cmd_row {
uint32_t band_id;
uint32_t chain_id;
uint32_t mod_id;
uint32_t limit_value;
uint32_t validity_bitmap;
};
/**
* struct sar_limit_cmd_params - sar limits params
* @sar_enable: flag to enable SAR
* See %enum wmi_sar_feature_state_flags for possible values
* @num_limit_rows: number of items in sar_limits
* @commit_limits: indicates firmware to start apply new SAR values
* @sar_limit_row_list: pointer to array of sar limit rows
*/
struct sar_limit_cmd_params {
uint32_t sar_enable;
uint32_t num_limit_rows;
uint32_t commit_limits;
struct sar_limit_cmd_row *sar_limit_row_list;
};
/**
* struct sar_limit_event_row - sar limits row
* @band_id: Frequency band.
* See %enum wmi_sar_band_id_flags for possible values
* @chain_id: Chain id
* @mod_id: Modulation scheme
* See %enum wmi_sar_mod_id_flags for possible values
* @limit_value: Power limits in steps of 0.5 dbm that is currently active for
* the given @band_id, @chain_id, and @mod_id
*/
struct sar_limit_event_row {
uint32_t band_id;
uint32_t chain_id;
uint32_t mod_id;
uint32_t limit_value;
};
/**
* struct sar_limit_event - sar limits params
* @sar_enable: Current status of SAR enablement.
* See %enum wmi_sar_feature_state_flags for possible values
* @num_limit_rows: number of items in sar_limits
* @sar_limit_row: array of sar limit rows. Only @num_limit_rows
* should be considered valid.
*/
struct sar_limit_event {
uint32_t sar_enable;
uint32_t num_limit_rows;
struct sar_limit_event_row
sar_limit_row[MAX_SAR_LIMIT_ROWS_SUPPORTED];
};
#define WMI_UNIFIED_MAX_PMKID_LEN 16
#define WMI_UNIFIED_MAX_PMK_LEN 64
/**
* struct wmi_unified_pmk_cache - used to set del pmkid cache
* @vdev_id: ID of the vdev being configured
* @pmk_len: PMK len
* for big-endian hosts, manual endian conversion will be needed to keep
* the array values in their original order in spite of the automatic
* byte-swap applied to WMI messages during download
* @pmk: PMK array
* @pmkid_len: PMK ID Len
* @pmkid: PMK ID Array
* @bssid: BSSID
* @ssid: SSID
* @cache_id: PMK Cache ID
* @cat_flag: whether (bssid) or (ssid,cache_id) is valid
* @action_flag: add/delete the entry
* @is_flush_all: FLAG to indicate PMKSA flush. True if PMKSA cache flush is
* needed.
*/
struct wmi_unified_pmk_cache {
uint8_t vdev_id;
uint32_t pmk_len;
uint8_t pmk[WMI_UNIFIED_MAX_PMK_LEN];
uint32_t pmkid_len;
uint8_t pmkid[WMI_UNIFIED_MAX_PMKID_LEN];
wmi_host_mac_addr bssid;
struct wlan_ssid ssid;
uint32_t cache_id;
uint32_t cat_flag;
uint32_t action_flag;
bool is_flush_all;
};
#define WMI_QOS_NUM_AC_MAX 4
/**
* struct aggr_add_ts_param - ADDTS parameters
* @tspecIdx: TSPEC handler uniquely identifying a TSPEC for a STA in a BSS
* @tspec: tspec value
* @status: QDF status
* @sessionId: session id
* @vdev_id: vdev id
*/
struct aggr_add_ts_param {
uint16_t tspecIdx;
struct mac_tspec_ie tspec[WMI_QOS_NUM_AC_MAX];
QDF_STATUS status[WMI_QOS_NUM_AC_MAX];
uint8_t sessionId;
uint8_t vdev_id;
};
#define WMI_PERIODIC_TX_PTRN_MAX_SIZE 1536
/**
* struct periodic_tx_pattern - periodic tx pattern
* @mac_address: MAC Address for the adapter
* @ucPtrnId: Pattern ID
* @ucPtrnSize: Pattern size
* @usPtrnIntervalMs: in ms
* @ucPattern: Pattern buffer
*/
struct periodic_tx_pattern {
struct qdf_mac_addr mac_address;
uint8_t ucPtrnId;
uint16_t ucPtrnSize;
uint32_t usPtrnIntervalMs;
uint8_t ucPattern[WMI_PERIODIC_TX_PTRN_MAX_SIZE];
};
/**
* struct flashing_req_params - led flashing parameter
* @req_id: request id
* @pattern_id: pattern identifier. 0: disconnected 1: connected
* @led_x0: led flashing parameter0
* @led_x1: led flashing parameter1
*/
struct flashing_req_params {
uint32_t req_id;
uint32_t pattern_id;
uint32_t led_x0;
uint32_t led_x1;
};
/**
* struct wmi_pcl_chan_weights - Params to get the valid weighed list
* @pcl_list: channel freq list sorted in preferred order
* @pcl_len: Length of the PCL
* @saved_chan_list: Valid channel freq list updated as part of
* WMA_UPDATE_CHAN_LIST_REQ
* @saved_num_chan: Length of the valid channel list
* @weighed_valid_list: Weights of the valid channel list. This will have one
* to one mapping with valid_chan_list. FW expects channel order and size to be
* as per the list provided in WMI_SCAN_CHAN_LIST_CMDID.
* @weight_list: Weights assigned by policy manager
*/
struct wmi_pcl_chan_weights {
uint32_t pcl_list[NUM_CHANNELS];
uint32_t pcl_len;
uint32_t saved_chan_list[NUM_CHANNELS];
uint32_t saved_num_chan;
uint8_t weighed_valid_list[NUM_CHANNELS];
uint8_t weight_list[NUM_CHANNELS];
};
/**
* struct wmi_adaptive_dwelltime_params - the adaptive dwelltime params
* @vdev_id: vdev id
* @is_enabled: Adaptive dwell time is enabled/disabled
* @dwelltime_mode: global default adaptive dwell mode
* @lpf_weight: weight to calculate the average low pass
* filter for channel congestion
* @passive_mon_intval: intval to monitor wifi activity in passive scan in msec
* @wifi_act_threshold: % of wifi activity used in passive scan 0-100
*
*/
struct wmi_adaptive_dwelltime_params {
uint32_t vdev_id;
bool is_enabled;
enum scan_dwelltime_adaptive_mode dwelltime_mode;
uint8_t lpf_weight;
uint8_t passive_mon_intval;
uint8_t wifi_act_threshold;
};
#define WMI_SCAN_CLIENT_MAX 7
/**
* struct wmi_dbs_scan_sel_params - DBS scan selection params
* @num_clients: Number of scan clients dutycycle
* @pdev_id: pdev_id for identifying the MAC
* @module_id: scan client module id
* @num_dbs_scans: number of DBS scans
* @num_non_dbs_scans: number of non-DBS scans
*/
struct wmi_dbs_scan_sel_params {
uint32_t num_clients;
uint32_t pdev_id;
uint32_t module_id[WMI_SCAN_CLIENT_MAX];
uint32_t num_dbs_scans[WMI_SCAN_CLIENT_MAX];
uint32_t num_non_dbs_scans[WMI_SCAN_CLIENT_MAX];
};
/**
* struct set_arp_stats - set/reset arp stats
* @vdev_id: session id
* @flag: enable/disable stats
* @pkt_type: type of packet(1 - arp)
* @ip_addr: subnet ipv4 address in case of encrypted packets
* @pkt_type_bitmap: pkt bitmap
* @tcp_src_port: tcp src port for pkt tracking
* @tcp_dst_port: tcp dst port for pkt tracking
* @icmp_ipv4: target ipv4 address to track ping packets
* @reserved: reserved
*/
struct set_arp_stats {
uint32_t vdev_id;
uint8_t flag;
uint8_t pkt_type;
uint32_t ip_addr;
uint32_t pkt_type_bitmap;
uint32_t tcp_src_port;
uint32_t tcp_dst_port;
uint32_t icmp_ipv4;
uint32_t reserved;
};
/**
* struct get_arp_stats - get arp stats from firmware
* @pkt_type: packet type(1 - ARP)
* @vdev_id: session id
*/
struct get_arp_stats {
uint8_t pkt_type;
uint32_t vdev_id;
};
#endif /* _WMI_UNIFIED_STA_PARAM_H_ */

679
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_twt_api.h Normal file
View File

@@ -0,0 +1,679 @@
/*
* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to TWT component.
*/
#ifndef _WMI_UNIFIED_TWT_API_H_
#define _WMI_UNIFIED_TWT_API_H_
#include "wmi_unified_twt_param.h"
#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED)
#include <wlan_twt_public_structs.h>
/**
* 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_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_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_handle: 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_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_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
* @params: 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
* @param: 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
* @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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_twt_disable_complete_event *params);
/**
* wmi_extract_twt_add_dialog_comp_event() - Extract WMI event params for TWT
* add 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_add_dialog_comp_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct wmi_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_handle: 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 wmi_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_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_del_dialog_comp_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_twt_session_stats_event_param *params,
struct wmi_host_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
* @params: 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
* @param: 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 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_ */

834
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_twt_param.h Normal file
View File

@@ -0,0 +1,834 @@
/*
* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API definitions for the TWT WMI APIs.
*/
#ifndef _WMI_UNIFIED_TWT_PARAM_H_
#define _WMI_UNIFIED_TWT_PARAM_H_
/**
* enum WMI_TWT_ROLE - role specified in ext conf in wmi_twt_enable/disable_cmd
* @WMI_TWT_ROLE_REQUESTOR: TWT role is requestor
* @WMI_TWT_ROLE_RESPONDER: TWT role is responder
*/
enum WMI_TWT_ROLE {
WMI_TWT_ROLE_REQUESTOR,
WMI_TWT_ROLE_RESPONDER,
};
/**
* enum WMI_TWT_OPERATION - specified in ext conf in wmi_twt_enable/disable_cmd
* @WMI_TWT_OPERATION_INDIVIDUAL: Individual TWT operation
* @WMI_TWT_OPERATION_BROADCAST: Broadcast TWT operation
*/
enum WMI_TWT_OPERATION {
WMI_TWT_OPERATION_INDIVIDUAL,
WMI_TWT_OPERATION_BROADCAST,
};
/**
* struct wmi_twt_enable_param - TWT Enable parameters
* @pdev_id: pdev_id for identifying the MAC.
* @sta_cong_timer_ms: STA TWT congestion timer TO value in terms of ms
* @mbss_support: Flag indicating if AP TWT feature supported in
* MBSS mode or not.
* @default_slot_size: This is the default value for the TWT slot setup
* by AP (units = microseconds)
* @congestion_thresh_setup: Minimum congestion required to start setting
* up TWT sessions
* @congestion_thresh_teardown: Minimum congestion below which TWT will be
* torn down (in percent of occupied airtime)
* @congestion_thresh_critical: Threshold above which TWT will not be active
* (in percent of occupied airtime)
* @interference_thresh_teardown: Minimum interference above that TWT
* will not be active. The interference parameters use an
* abstract method of evaluating interference.
* The parameters are in percent, ranging from 0 for no
* interference, to 100 for interference extreme enough
* to completely block the signal of interest.
* @interference_thresh_setup: Minimum interference below that TWT session
* can be setup. The interference parameters use an
* abstract method of evaluating interference.
* The parameters are in percent, ranging from 0 for no
* interference, to 100 for interference extreme enough
* to completely block the signal of interest.
* @min_no_sta_setup: Minimum no of STA required to start TWT setup
* @min_no_sta_teardown: Minimum no of STA below which TWT will be torn down
* @no_of_bcast_mcast_slots: Number of default slot sizes reserved for
* BCAST/MCAST delivery
* @min_no_twt_slots: Minimum no of available slots for TWT to be operational
* @max_no_sta_twt: Max no of STA with which TWT is possible
* (must be <= the wmi_resource_config's twt_ap_sta_count value)
* * The below interval parameters have units of milliseconds.
* @mode_check_interval: Interval between two successive check to decide the
* mode of TWT. (units = milliseconds)
* @add_sta_slot_interval: Interval between decisions making to create
* TWT slots for STAs. (units = milliseconds)
* @remove_sta_slot_interval: Inrerval between decisions making to remove TWT
* slot of STAs. (units = milliseconds)
* @twt_role: values from enum WMI_TWT_ROLE.
* @twt_oper: values from enum WMI_TWT_OPERATION.
* @ext_conf_present: If requestor/responder extend config is present.
* @b_twt_enable: Enable or disable broadcast TWT.
* @b_twt_legacy_mbss_enable: Enable or disable legacy MBSSID TWT.
* @b_twt_ax_mbss_enable: Enable or disable 11AX MBSSID TWT.
* @r_twt_enable: Enable or disable restricted TWT.
*/
struct wmi_twt_enable_param {
uint32_t pdev_id;
uint32_t sta_cong_timer_ms;
uint32_t mbss_support;
uint32_t default_slot_size;
uint32_t congestion_thresh_setup;
uint32_t congestion_thresh_teardown;
uint32_t congestion_thresh_critical;
uint32_t interference_thresh_teardown;
uint32_t interference_thresh_setup;
uint32_t min_no_sta_setup;
uint32_t min_no_sta_teardown;
uint32_t no_of_bcast_mcast_slots;
uint32_t min_no_twt_slots;
uint32_t max_no_sta_twt;
uint32_t mode_check_interval;
uint32_t add_sta_slot_interval;
uint32_t remove_sta_slot_interval;
enum WMI_TWT_ROLE twt_role;
enum WMI_TWT_OPERATION twt_oper;
bool ext_conf_present;
uint32_t b_twt_enable:1,
b_twt_legacy_mbss_enable:1,
b_twt_ax_mbss_enable:1;
bool r_twt_enable;
};
/* status code of enabling TWT
* WMI_ENABLE_TWT_STATUS_OK: enabling TWT successfully completed
* WMI_ENABLE_TWT_STATUS_ALREADY_ENABLED: TWT already enabled
* WMI_ENABLE_TWT_STATUS_NOT_READY: FW not ready for enabling TWT
* WMI_ENABLE_TWT_INVALID_PARAM: invalid parameters
* WMI_ENABLE_TWT_STATUS_UNKNOWN_ERROR: enabling TWT failed with an
* unknown reason
*/
enum WMI_HOST_ENABLE_TWT_STATUS {
WMI_HOST_ENABLE_TWT_STATUS_OK,
WMI_HOST_ENABLE_TWT_STATUS_ALREADY_ENABLED,
WMI_HOST_ENABLE_TWT_STATUS_NOT_READY,
WMI_HOST_ENABLE_TWT_INVALID_PARAM,
WMI_HOST_ENABLE_TWT_STATUS_UNKNOWN_ERROR,
};
/**
* struct wmi_twt_enable_complete_event_param:
* @pdev_id: pdev_id for identifying the MAC.
* @status: From enum WMI_HOST_ENABLE_TWT_STATUS
*/
struct wmi_twt_enable_complete_event_param {
uint32_t pdev_id;
uint32_t status;
};
/**
* struct wmi_twt_disable_param:
* @pdev_id: pdev_id for identifying the MAC.
* @ext_conf_present: If requestor/responder extend config is present.
* @twt_role: values from enum WMI_TWT_ROLE.
* @twt_oper: values from enum WMI_TWT_OPERATION.
*/
struct wmi_twt_disable_param {
uint32_t pdev_id;
bool ext_conf_present;
enum WMI_TWT_ROLE twt_role;
enum WMI_TWT_OPERATION twt_oper;
};
/**
* struct wmi_twt_disable_complete_event:
* @pdev_id: pdev_id for identifying the MAC.
*/
struct wmi_twt_disable_complete_event {
uint32_t pdev_id;
};
/**
* struct wmi_twt_ack_complete_event_param -
* @vdev_id: vdev id
* @peer_macaddr: peer mac address
* @dialog_id: dialog id
* @twt_cmd_ack: ack event to the corresponding twt command
* @status: twt command status
*/
struct wmi_twt_ack_complete_event_param {
uint32_t vdev_id;
struct qdf_mac_addr peer_macaddr;
uint32_t dialog_id;
uint32_t twt_cmd_ack;
uint32_t status;
};
/* TWT event types
* refer to wmi_unified.h enum wmi_twt_session_stats_type
*/
enum host_twt_session_stats_type {
HOST_TWT_SESSION_SETUP = 1,
HOST_TWT_SESSION_TEARDOWN = 2,
HOST_TWT_SESSION_UPDATE = 3,
};
/**
* struct wmi_host_twt_session_stats_info:
* @vdev_id: id of VDEV for twt session
* @peer_mac: MAC address of node
* @event_type: Indicates TWT session type (SETUP/TEARDOWN/UPDATE)
* @flow_id: TWT flow identifier established with TWT peer
* @bcast: If this is a broadcast TWT session
* @trig: If the TWT session is trigger enabled
* @announ: If the flow type is announced/unannounced
* @protection: If the TWT protection field is set
* @info_frame_disabled: If the TWT Information frame is disabled
* @pm_responder_bit_valid: pm responder bit is valid or not
* @pm_responder_bit: pm responder value
* @dialog_id: Dialog_id of current session
* @wake_dura_us: wake duration in us
* @wake_intvl_us: wake time interval in us
* @sp_offset_us: Time until initial TWT SP occurs
* @sp_tsf_us_lo: TWT wake time TSF in usecs lower bits - 31:0
* @sp_tsf_us_hi: TWT wake time TSF in usecs higher bits - 63:32
*/
struct wmi_host_twt_session_stats_info {
uint32_t vdev_id;
uint8_t peer_mac[QDF_MAC_ADDR_SIZE];
uint32_t event_type;
uint32_t flow_id:16,
bcast:1,
trig:1,
announ:1,
protection:1,
info_frame_disabled:1,
pm_responder_bit_valid:1,
pm_responder_bit:1;
uint32_t dialog_id;
uint32_t wake_dura_us;
uint32_t wake_intvl_us;
uint32_t sp_offset_us;
uint32_t sp_tsf_us_lo;
uint32_t sp_tsf_us_hi;
};
/**
* struct wmi_twt_session_stats_event_param -
* @pdev_id: pdev_id for identifying the MAC.
* @num_sessions: number of TWT sessions
* @twt_sessions: received TWT sessions
*/
struct wmi_twt_session_stats_event_param {
uint32_t pdev_id;
uint32_t num_sessions;
};
/* from IEEE 802.11ah section 9.4.2.200 */
enum WMI_HOST_TWT_COMMAND {
WMI_HOST_TWT_COMMAND_REQUEST_TWT = 0,
WMI_HOST_TWT_COMMAND_SUGGEST_TWT = 1,
WMI_HOST_TWT_COMMAND_DEMAND_TWT = 2,
WMI_HOST_TWT_COMMAND_TWT_GROUPING = 3,
WMI_HOST_TWT_COMMAND_ACCEPT_TWT = 4,
WMI_HOST_TWT_COMMAND_ALTERNATE_TWT = 5,
WMI_HOST_TWT_COMMAND_DICTATE_TWT = 6,
WMI_HOST_TWT_COMMAND_REJECT_TWT = 7,
};
/**
* struct wmi_twt_add_dialog_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: peer MAC address when vdev is AP VDEV
* @dialog_id: diaglog_id (TWT dialog ID)
* This dialog ID must be unique within its vdev.
* @wake_intvl_us: TWT Wake Interval in units of us
* @wake_intvl_mantis: TWT Wake Interval Mantissa
* - wake_intvl_mantis must be <= 0xFFFF
* - wake_intvl_us must be divided evenly by wake_intvl_mantis,
* i.e., wake_intvl_us % wake_intvl_mantis == 0
* - the quotient of wake_intvl_us/wake_intvl_mantis must be
* 2 to N-th(0<=N<=31) power,
* i.e., wake_intvl_us/wake_intvl_mantis == 2^N, 0<=N<=31
* @min_wake_intvl_us: Min tolerance limit of TWT wake interval
* @max_wake_intvl_us: Max tolerance limit of TWT wake interval
* @wake_dura_us: TWT Wake Duration in units of us, must be <= 0xFFFF
* wake_dura_us must be divided evenly by 256,
* i.e., wake_dura_us % 256 == 0
* @min_wake_dura_us: Min tolerance limit of TWT wake duration.
* @max_wake_dura_us: Max tolerance limit of TWT wake duration.
* @sp_offset_us: this long time after TWT setup the 1st SP will start.
* @twt_cmd: cmd from enum WMI_HOST_TWT_COMMAND
* @flag_bcast: 0 means Individual TWT,
* 1 means Broadcast TWT
* @flag_trigger: 0 means non-Trigger-enabled TWT,
* 1 means means Trigger-enabled TWT
* @flag_flow_type: 0 means announced TWT,
* 1 means un-announced TWT
* @flag_protection: 0 means TWT protection is required,
* 1 means TWT protection is not required
* @b_twt_id0: 0 means BTWT recommendation will not be used
* 1 means BTWT recommendation will be used
* @flag_reserved: unused bits
* @b_twt_recommendation: defines types of frames tx during bTWT SP
* @b_twt_persistence: Countdown VAL frames to param update/teardown
* @wake_time_tsf: Absolute TSF value to start first TWT service period
* @announce_timeout_us: Timeout value before sending QoS NULL frame.
* @link_id_bitmap: MLD links to which R-TWT element applies
* @r_twt_dl_tid_bitmap: DL TIDs for R-TWT scheduling
* @r_twt_ul_tid_bitmap: UL TIDs for R-TWT scheduling
*
*/
struct wmi_twt_add_dialog_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t wake_intvl_us;
uint32_t wake_intvl_mantis;
uint32_t min_wake_intvl_us;
uint32_t max_wake_intvl_us;
uint32_t wake_dura_us;
uint32_t min_wake_dura_us;
uint32_t max_wake_dura_us;
uint32_t sp_offset_us;
enum WMI_HOST_TWT_COMMAND twt_cmd;
uint32_t
flag_bcast:1,
flag_trigger:1,
flag_flow_type:1,
flag_protection:1,
flag_b_twt_id0:1,
flag_reserved:11,
b_twt_persistence:8,
b_twt_recommendation:3;
uint64_t wake_time_tsf;
uint32_t announce_timeout_us;
uint32_t link_id_bitmap;
uint32_t r_twt_dl_tid_bitmap;
uint32_t r_twt_ul_tid_bitmap;
};
/* enum - status code of Get stats TWT dialog
* @WMI_HOST_GET_STATS_TWT_STATUS_OK: Get status TWT dialog successfully completed
* @WMI_HOST_GET_STATS_TWT_STATUS_DIALOG_ID_NOT_EXIST: TWT dialog ID does not exist
* @WMI_HOST_GET_STATS_TWT_STATUS_INVALID_PARAM: Invalid parameters
* @WMI_HOST_GET_STATS_TWT_STATUS_UNKNOWN_ERROR: Unknown error
*/
enum WMI_HOST_GET_STATS_TWT_STATUS {
WMI_HOST_GET_STATS_TWT_STATUS_OK,
WMI_HOST_GET_STATS_TWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_GET_STATS_TWT_STATUS_INVALID_PARAM,
WMI_HOST_GET_STATS_TWT_STATUS_UNKNOWN_ERROR,
};
/* enum - status code of adding TWT dialog
* @WMI_HOST_ADD_TWT_STATUS_OK: adding TWT dialog successfully completed
* @WMI_HOST_ADD_TWT_STATUS_TWT_NOT_ENABLED: TWT not enabled
* @WMI_HOST_ADD_TWT_STATUS_USED_DIALOG_ID: TWT dialog ID is already used
* @WMI_HOST_ADD_TWT_STATUS_INVALID_PARAM: invalid parameters
* @WMI_HOST_ADD_TWT_STATUS_NOT_READY: FW not ready
* @WMI_HOST_ADD_TWT_STATUS_NO_RESOURCE: FW resource exhausted
* @WMI_HOST_ADD_TWT_STATUS_NO_ACK: peer AP/STA did not ACK the
* request/response frame
* @WMI_HOST_ADD_TWT_STATUS_NO_RESPONSE: peer AP did not send the response frame
* @WMI_HOST_ADD_TWT_STATUS_DENIED: AP did not accept the request
* @WMI_HOST_ADD_TWT_STATUS_UNKNOWN_ERROR: adding TWT dialog failed with
* an unknown reason
* @WMI_HOST_ADD_TWT_STATUS_AP_PARAMS_NOT_IN_RANGE: peer AP wake interval,
* duration not in range
* @WMI_HOST_ADD_TWT_STATUS_AP_IE_VALIDATION_FAILED: peer AP IE Validation
* Failed
* @WMI_HOST_ADD_TWT_STATUS_ROAM_IN_PROGRESS: Roaming in progress
* @WMI_HOST_ADD_TWT_STATUS_CHAN_SW_IN_PROGRESS: Channel switch in progress
* @WMI_HOST_ADD_TWT_STATUS_SCAN_IN_PROGRESS: Scan is in progress
* @WMI_HOST_ADD_TWT_STATUS_LINK_SWITCH_IN_PROGRESS: link switch is in progress
* @WMI_HOST_ADD_TWT_STATUS_UNSUPPORTED_MODE_MLMR: MLMR mode not supported
*/
enum WMI_HOST_ADD_TWT_STATUS {
WMI_HOST_ADD_TWT_STATUS_OK,
WMI_HOST_ADD_TWT_STATUS_TWT_NOT_ENABLED,
WMI_HOST_ADD_TWT_STATUS_USED_DIALOG_ID,
WMI_HOST_ADD_TWT_STATUS_INVALID_PARAM,
WMI_HOST_ADD_TWT_STATUS_NOT_READY,
WMI_HOST_ADD_TWT_STATUS_NO_RESOURCE,
WMI_HOST_ADD_TWT_STATUS_NO_ACK,
WMI_HOST_ADD_TWT_STATUS_NO_RESPONSE,
WMI_HOST_ADD_TWT_STATUS_DENIED,
WMI_HOST_ADD_TWT_STATUS_UNKNOWN_ERROR,
WMI_HOST_ADD_TWT_STATUS_AP_PARAMS_NOT_IN_RANGE,
WMI_HOST_ADD_TWT_STATUS_AP_IE_VALIDATION_FAILED,
WMI_HOST_ADD_TWT_STATUS_ROAM_IN_PROGRESS,
WMI_HOST_ADD_TWT_STATUS_CHAN_SW_IN_PROGRESS,
WMI_HOST_ADD_TWT_STATUS_SCAN_IN_PROGRESS,
WMI_HOST_ADD_TWT_STATUS_LINK_SWITCH_IN_PROGRESS,
WMI_HOST_ADD_TWT_STATUS_UNSUPPORTED_MODE_MLMR,
};
/**
* struct wmi_twt_add_dialog_additional_params -
* @twt_cmd: TWT command
* @bcast: 0 means Individual TWT
* 1 means Broadcast TWT
* @trig_en: 0 means non-Trigger-enabled TWT
* 1 means Trigger-enabled TWT
* @announce: 0 means announced TWT
* 1 means un-announced TWT
* @protection: 0 means TWT protection is required
* 1 means TWT protection is not required
* @b_twt_id0: 0 means non-0 B-TWT ID or I-TWT
* 1 means B-TWT ID 0
* @info_frame_disabled: 0 means TWT Information frame is enabled
* 1 means TWT Information frame is disabled
* @pm_responder_bit_valid: 1 means responder pm mode field is valid
* 0 means responder pm mode field is not valid
* @pm_responder_bit: 1 means that responder set responder pm mode to 1
* 0 means that responder set responder pm mode to 0
* @wake_dur_us: wake duration in us
* @wake_intvl_us: wake time interval in us
* @sp_offset_us: Time until initial TWT SP occurs
* @sp_tsf_us_lo: TWT service period tsf in usecs lower bits - 31:0
* @sp_tsf_us_hi: TWT service period tsf in usecs higher bits - 63:32
*/
struct wmi_twt_add_dialog_additional_params {
uint32_t twt_cmd:8,
bcast:1,
trig_en:1,
announce:1,
protection:1,
b_twt_id0:1,
info_frame_disabled:1,
pm_responder_bit_valid:1,
pm_responder_bit:1;
uint32_t wake_dur_us;
uint32_t wake_intvl_us;
uint32_t sp_offset_us;
uint32_t sp_tsf_us_lo;
uint32_t sp_tsf_us_hi;
};
/**
* struct wmi_twt_add_dialog_complete_event_param - parameters from TWT
* Add Dialog Complete event
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @status: refer to WMI_HOST_ADD_TWT_STATUS enum
* @num_additional_twt_params: no of additional_twt_params available
*/
struct wmi_twt_add_dialog_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t status;
uint32_t num_additional_twt_params;
};
/**
* struct wmi_twt_cap_bitmap_params - TWT capabilities bitmap
* @twt_ack_support_cap: TWT ACK supported
*
*/
struct wmi_twt_cap_bitmap_params {
uint32_t twt_ack_support_cap:1;
};
/**
* struct wmi_twt_del_dialog_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @b_twt_persistence: persistence val for b-twt
*/
struct wmi_twt_del_dialog_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
#ifdef WLAN_SUPPORT_BCAST_TWT
uint32_t b_twt_persistence;
#endif
};
/**
* enum WMI_HOST_DEL_TWT_STATUS - status code of deleting TWT dialog
* @WMI_HOST_DEL_TWT_STATUS_OK: deleting TWT dialog successfully completed
* @WMI_HOST_DEL_TWT_STATUS_DIALOG_ID_NOT_EXIST: TWT dialog ID not exists
* @WMI_HOST_DEL_TWT_STATUS_INVALID_PARAM: invalid parameters
* @WMI_HOST_DEL_TWT_STATUS_DIALOG_ID_BUSY: FW is in the process of handling
* this dialog
* @WMI_HOST_DEL_TWT_STATUS_NO_RESOURCE: FW resource exhausted
* @WMI_HOST_DEL_TWT_STATUS_NO_ACK: peer AP/STA did not ACK the request/response
* frame
* @WMI_HOST_DEL_TWT_STATUS_UNKNOWN_ERROR: deleting TWT dialog failed with an
* unknown reason
* @WMI_HOST_DEL_TWT_STATUS_PEER_INIT_TEARDOWN: Peer initiated TWT teardown
* @WMI_HOST_DEL_TWT_STATUS_ROAMING: TWT teardown due to roaming.
* @WMI_HOST_DEL_TWT_STATUS_CONCURRENCY: TWT session teardown due to
* concurrent session coming up.
* @WMI_HOST_DEL_TWT_STATUS_CHAN_SW_IN_PROGRESS: Channel switch in progress
* @WMI_HOST_DEL_TWT_STATUS_SCAN_IN_PROGRESS: Scan is in progress
* @WMI_HOST_DEL_TWT_STATUS_PS_DISABLE_TEARDOWN: PS disable TWT teardown
*/
enum WMI_HOST_DEL_TWT_STATUS {
WMI_HOST_DEL_TWT_STATUS_OK,
WMI_HOST_DEL_TWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_DEL_TWT_STATUS_INVALID_PARAM,
WMI_HOST_DEL_TWT_STATUS_DIALOG_ID_BUSY,
WMI_HOST_DEL_TWT_STATUS_NO_RESOURCE,
WMI_HOST_DEL_TWT_STATUS_NO_ACK,
WMI_HOST_DEL_TWT_STATUS_UNKNOWN_ERROR,
WMI_HOST_DEL_TWT_STATUS_PEER_INIT_TEARDOWN,
WMI_HOST_DEL_TWT_STATUS_ROAMING,
WMI_HOST_DEL_TWT_STATUS_CONCURRENCY,
WMI_HOST_DEL_TWT_STATUS_CHAN_SW_IN_PROGRESS,
WMI_HOST_DEL_TWT_STATUS_SCAN_IN_PROGRESS,
WMI_HOST_DEL_TWT_STATUS_PS_DISABLE_TEARDOWN,
};
/**
* struct wmi_twt_del_dialog_complete_event_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @b_twt_persistence: persistence val for b-twt
* @status: refer to WMI_HOST_DEL_TWT_STATUS enum
*/
struct wmi_twt_del_dialog_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
#ifdef WLAN_SUPPORT_BCAST_TWT
uint32_t b_twt_persistence;
#endif
uint32_t status;
};
/**
* struct wmi_twt_pause_dialog_cmd_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
*/
struct wmi_twt_pause_dialog_cmd_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
};
/**
* struct wmi_twt_nudge_dialog_cmd_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @suspend_duration: TWT suspend duration in microseconds
* @next_twt_size: next TWT size
*/
struct wmi_twt_nudge_dialog_cmd_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t suspend_duration;
uint32_t next_twt_size;
};
/* enum WMI_HOST_PAUSE_TWT_STATUS - status code of pausing TWT dialog
* @WMI_HOST_PAUSE_TWT_STATUS_OK: pausing TWT dialog successfully completed
* @WMI_HOST_PAUSE_TWT_STATUS_DIALOG_ID_NOT_EXIST: TWT dialog ID not exists
* @WMI_HOST_PAUSE_TWT_STATUS_INVALID_PARAM: invalid parameters
* @WMI_HOST_PAUSE_TWT_STATUS_DIALOG_ID_BUSY: FW is in the process of handling
* this dialog
* @WMI_HOST_PAUSE_TWT_STATUS_NO_RESOURCE: FW resource exhausted
* @WMI_HOST_PAUSE_TWT_STATUS_NO_ACK: peer AP/STA did not ACK the
* request/response frame
* @WMI_HOST_PAUSE_TWT_STATUS_UNKNOWN_ERROR: pausing TWT dialog failed with an
* unknown reason
* @WMI_HOST_PAUSE_TWT_STATUS_ALREADY_PAUSED: TWT dialog already in paused state
* @WMI_HOST_PAUSE_TWT_STATUS_CHAN_SW_IN_PROGRESS: Channel switch in progress
* @WMI_HOST_PAUSE_TWT_STATUS_ROAM_IN_PROGRESS: Roaming is in progress
* @WMI_HOST_PAUSE_TWT_STATUS_SCAN_IN_PROGRESS: Scan is in progress
*/
enum WMI_HOST_PAUSE_TWT_STATUS {
WMI_HOST_PAUSE_TWT_STATUS_OK,
WMI_HOST_PAUSE_TWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_PAUSE_TWT_STATUS_INVALID_PARAM,
WMI_HOST_PAUSE_TWT_STATUS_DIALOG_ID_BUSY,
WMI_HOST_PAUSE_TWT_STATUS_NO_RESOURCE,
WMI_HOST_PAUSE_TWT_STATUS_NO_ACK,
WMI_HOST_PAUSE_TWT_STATUS_UNKNOWN_ERROR,
WMI_HOST_PAUSE_TWT_STATUS_ALREADY_PAUSED,
WMI_HOST_PAUSE_TWT_STATUS_CHAN_SW_IN_PROGRESS,
WMI_HOST_PAUSE_TWT_STATUS_ROAM_IN_PROGRESS,
WMI_HOST_PAUSE_TWT_STATUS_SCAN_IN_PROGRESS,
};
/**
* struct wmi_twt_pause_dialog_complete_event_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @status: refer to WMI_HOST_PAUSE_TWT_STATUS
*/
struct wmi_twt_pause_dialog_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
enum WMI_HOST_PAUSE_TWT_STATUS status;
};
/* enum WMI_HOST_NUDGE_TWT_STATUS - status code of nudge TWT dialog
* @WMI_HOST_NUDGE_TWT_STATUS_OK: nudge TWT dialog successfully completed
* @WMI_HOST_NUDGE_TWT_STATUS_DIALOG_ID_NOT_EXIST: TWT dialog ID not exists
* @WMI_HOST_NUDGE_TWT_STATUS_INVALID_PARAM: invalid parameters
* @WMI_HOST_NUDGE_TWT_STATUS_DIALOG_ID_BUSY: FW is in the process of handling
* this dialog
* @WMI_HOST_NUDGE_TWT_STATUS_NO_RESOURCE: FW resource exhausted
* @WMI_HOST_NUDGE_TWT_STATUS_NO_ACK: peer AP/STA did not ACK the
* request/response frame
* @WMI_HOST_NUDGE_TWT_STATUS_UNKNOWN_ERROR: nudge TWT dialog failed with an
* unknown reason
* @WMI_HOST_NUDGE_TWT_STATUS_ALREADY_PAUSED: TWT dialog already in paused state
* @WMI_HOST_NUDGE_TWT_STATUS_CHAN_SW_IN_PROGRESS: Channel switch in progress
* @WMI_HOST_NUDGE_TWT_STATUS_ROAM_IN_PROGRESS: Roaming in progress
* @WMI_HOST_NUDGE_TWT_STATUS_SCAN_IN_PROGRESS: Scan is in progress
*/
enum WMI_HOST_NUDGE_TWT_STATUS {
WMI_HOST_NUDGE_TWT_STATUS_OK,
WMI_HOST_NUDGE_TWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_NUDGE_TWT_STATUS_INVALID_PARAM,
WMI_HOST_NUDGE_TWT_STATUS_DIALOG_ID_BUSY,
WMI_HOST_NUDGE_TWT_STATUS_NO_RESOURCE,
WMI_HOST_NUDGE_TWT_STATUS_NO_ACK,
WMI_HOST_NUDGE_TWT_STATUS_UNKNOWN_ERROR,
WMI_HOST_NUDGE_TWT_STATUS_ALREADY_PAUSED,
WMI_HOST_NUDGE_TWT_STATUS_CHAN_SW_IN_PROGRESS,
WMI_HOST_NUDGE_TWT_STATUS_ROAM_IN_PROGRESS,
WMI_HOST_NUDGE_TWT_STATUS_SCAN_IN_PROGRESS,
};
/**
* struct wmi_twt_nudge_dialog_complete_event_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @status: refer to WMI_HOST_PAUSE_TWT_STATUS
* @next_twt_tsf_us_lo: TSF lower bits (31:0) of next wake time
* @next_twt_tsf_us_hi: TSF higher bits (32:63) of next wake time
*/
struct wmi_twt_nudge_dialog_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
enum WMI_HOST_NUDGE_TWT_STATUS status;
uint32_t next_twt_tsf_us_lo;
uint32_t next_twt_tsf_us_hi;
};
/**
* struct wmi_twt_resume_dialog_cmd_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @sp_offset_us: this long time after TWT resumed the 1st SP will start
* @next_twt_size: Next TWT subfield Size.
* Refer IEEE 802.11ax section "9.4.1.60 TWT Information field"
*/
struct wmi_twt_resume_dialog_cmd_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t sp_offset_us;
uint32_t next_twt_size;
};
/* enum WMI_HOST_RESUME_TWT_STATUS - status code of resuming TWT dialog
* @WMI_HOST_RESUME_TWT_STATUS_OK: resuming TWT dialog successfully completed
* @WMI_HOST_RESUME_TWT_STATUS_DIALOG_ID_NOT_EXIST: TWT dialog ID not exists
* @WMI_HOST_RESUME_TWT_STATUS_INVALID_PARAM: invalid parameters
* @WMI_HOST_RESUME_TWT_STATUS_DIALOG_ID_BUSY: FW is in the process of handling
* this dialog
* @WMI_HOST_RESUME_TWT_STATUS_NOT_PAUSED: dialog not paused currently
* @WMI_HOST_RESUME_TWT_STATUS_NO_RESOURCE: FW resource exhausted
* @WMI_HOST_RESUME_TWT_STATUS_NO_ACK: peer AP/STA did not ACK the
* request/response frame
* @WMI_HOST_RESUME_TWT_STATUS_UNKNOWN_ERROR: resuming TWT dialog failed with an
* unknown reason
* @WMI_HOST_RESUME_TWT_STATUS_CHAN_SW_IN_PROGRESS: Channel switch in progress
* @WMI_HOST_RESUME_TWT_STATUS_ROAM_IN_PROGRESS: Roaming in progress
* @WMI_HOST_RESUME_TWT_STATUS_SCAN_IN_PROGRESS: Scan is in progress
*/
enum WMI_HOST_RESUME_TWT_STATUS {
WMI_HOST_RESUME_TWT_STATUS_OK,
WMI_HOST_RESUME_TWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_RESUME_TWT_STATUS_INVALID_PARAM,
WMI_HOST_RESUME_TWT_STATUS_DIALOG_ID_BUSY,
WMI_HOST_RESUME_TWT_STATUS_NOT_PAUSED,
WMI_HOST_RESUME_TWT_STATUS_NO_RESOURCE,
WMI_HOST_RESUME_TWT_STATUS_NO_ACK,
WMI_HOST_RESUME_TWT_STATUS_UNKNOWN_ERROR,
WMI_HOST_RESUME_TWT_STATUS_CHAN_SW_IN_PROGRESS,
WMI_HOST_RESUME_TWT_STATUS_ROAM_IN_PROGRESS,
WMI_HOST_RESUME_TWT_STATUS_SCAN_IN_PROGRESS,
};
/**
* struct wmi_twt_resume_dialog_complete_event_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
* @status: refer to WMI_HOST_RESUME_TWT_STATUS
*/
struct wmi_twt_resume_dialog_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t status;
};
/**
* struct wmi_twt_notify_event_param -
* @vdev_id: VDEV identifier
*/
struct wmi_twt_notify_event_param {
uint32_t vdev_id;
};
#ifdef WLAN_SUPPORT_BCAST_TWT
/**
* struct wmi_twt_btwt_invite_sta_cmd_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: TWT dialog ID
*/
struct wmi_twt_btwt_invite_sta_cmd_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
};
/* enum WMI_HOST_INVITATION_TWT_BTWT_STATUS - status code of TWT Invitation
* dialog
* WMI_HOST_INVITATION_TWT_BTWT_STATUS_OK: BTWT invitation successfully
* completed
* WMI_HOST_INVITATION_TWT_TWT_STATUS_DIALOG_ID_NOT_EXIST: BTWT dialog ID not
* exists
* WMI_HOST_INVITATION_TWT_BTWT_STATUS_INVALID_PARAM: invalid parameters
* WMI_HOST_INVITATION_TWT_BTWT_STATUS_DIALOG_ID_BUSY: FW is in the process of
* handling this dialog
* WMI_HOST_INVITATION_TWT_BTWT_STATUS_NO_RESOURCE: FW resource exhausted
* WMI_HOST_INVITATION_TWT_BTWT_STATUS_NO_ACK: peer AP/STA did not ACK the
* request/response frame
* WMI_HOST_INVITATION_TWT_BTWT_STATUS_UNKNOWN_ERROR: BTWT invitation failed
* with an unknown reason
*/
enum WMI_HOST_INVITATION_TWT_BTWT_STATUS {
WMI_HOST_INVITATION_TWT_BTWT_STATUS_OK,
WMI_HOST_INVITATION_TWT_BTWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_INVITATION_TWT_BTWT_STATUS_INVALID_PARAM,
WMI_HOST_INVITATION_TWT_BTWT_STATUS_DIALOG_ID_BUSY,
WMI_HOST_INVITATION_TWT_BTWT_STATUS_NO_RESOURCE,
WMI_HOST_INVITATION_TWT_BTWT_STATUS_NO_ACK,
WMI_HOST_INVITATION_TWT_BTWT_STATUS_UNKNOWN_ERROR,
};
/**
* struct wmi_twt_btwt_invite_sta_complete_event_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: BTWT dialog ID
* @status: refer to WMI_HOST_INVITATION_TWT_BTWT_STATUS
*/
struct wmi_twt_btwt_invite_sta_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t status;
};
/**
* struct wmi_twt_btwt_remove_sta_cmd_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: BTWT dialog ID
*/
struct wmi_twt_btwt_remove_sta_cmd_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
};
/* enum WMI_HOST_KICKOFF_TWT_BTWT_STATUS - status code of resuming TWT dialog
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_OK: TWT kickoff successfully completed
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_DIALOG_ID_NOT_EXIST: BTWT dialog ID not
* exists
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_INVALID_PARAM: invalid parameters
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_DIALOG_ID_BUSY: FW is in the process of
* handling this dialog
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_NOT_PAUSED: Dialog not currently paused
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_NO_RESOURCE: FW resource exhausted
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_NO_ACK: peer AP/STA did not ACK the
* request/response frame
* WMI_HOST_KICKOFF_TWT_BTWT_STATUS_UNKNOWN_ERROR: BTWT kickoff failed with an
* unknown reason
*/
enum WMI_HOST_KICKOFF_TWT_BTWT_STATUS {
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_OK,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_DIALOG_ID_NOT_EXIST,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_INVALID_PARAM,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_DIALOG_ID_BUSY,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_NOT_PAUSED,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_NO_RESOURCE,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_NO_ACK,
WMI_HOST_KICKOFF_TWT_BTWT_STATUS_UNKNOWN_ERROR,
};
/**
* struct wmi_twt_btwt_remove_sta_complete_event_param -
* @vdev_id: VDEV identifier
* @peer_macaddr: Peer mac address
* @dialog_id: BTWT dialog ID
* @status: refer to WMI_HOST_KICKOFF_TWT_BTWT_STATUS
*/
struct wmi_twt_btwt_remove_sta_complete_event_param {
uint32_t vdev_id;
uint8_t peer_macaddr[QDF_MAC_ADDR_SIZE];
uint32_t dialog_id;
uint32_t status;
};
#endif
/**
* enum WMI_HOST_TWT_CMD_FOR_ACK_EVENT - Ack event for different TWT command
* @WMI_HOST_TWT_ADD_DIALOG_CMDID: Ack event for add dialog command
* @WMI_HOST_TWT_DEL_DIALOG_CMDID: Ack event for delete dialog command
* @WMI_HOST_TWT_PAUSE_DIALOG_CMDID: Ack event for pause command
* @WMI_HOST_TWT_RESUME_DIALOG_CMDID: Ack event for resume command
* @WMI_HOST_TWT_NUDGE_DIALOG_CMDID: Ack event for nudge command
* @WMI_HOST_TWT_UNKNOWN_CMDID: Ack event for unknown TWT command
*/
enum WMI_HOST_TWT_CMD_FOR_ACK_EVENT {
WMI_HOST_TWT_ADD_DIALOG_CMDID = 0,
WMI_HOST_TWT_DEL_DIALOG_CMDID,
WMI_HOST_TWT_PAUSE_DIALOG_CMDID,
WMI_HOST_TWT_RESUME_DIALOG_CMDID,
WMI_HOST_TWT_NUDGE_DIALOG_CMDID,
WMI_HOST_TWT_UNKNOWN_CMDID,
};
#endif /* _WMI_UNIFIED_TWT_PARAM_H_ */

233
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_vdev_api.h Normal file
View File

@@ -0,0 +1,233 @@
/*
* Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API declarations for the Unified Wireless Module
* Interface (WMI).
*/
#ifndef _WMI_UNIFIED_VDEV_API_H_
#define _WMI_UNIFIED_VDEV_API_H_
#include <wmi_unified_api.h>
/**
* wmi_unified_peer_filter_set_tx_cmd_send() - WMI set tx peer filter function
* @wmi_handle: handle to WMI.
* @macaddr: MAC address
* @param: pointer to hold peer filter parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_peer_filter_set_tx_cmd_send(struct wmi_unified *wmi_handle,
uint8_t macaddr[],
struct set_tx_peer_filter *param);
/**
* wmi_unified_vdev_set_neighbour_rx_cmd_send() - WMI set neighbour rx function
* @wmi_handle: handle to WMI.
* @macaddr: MAC address
* @param: pointer to hold neighbour rx parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_vdev_set_neighbour_rx_cmd_send(
struct wmi_unified *wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct set_neighbour_rx_params *param);
/**
* wmi_unified_vdev_config_ratemask_cmd_send() - WMI config ratemask function
* @wmi_handle: handle to WMI.
* @param: pointer to hold config ratemask param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_vdev_config_ratemask_cmd_send(struct wmi_unified *wmi_handle,
struct config_ratemask_params *param);
/**
* wmi_unified_send_multiple_vdev_restart_req_cmd() - send multiple vdev restart
* @wmi_handle: wmi handle
* @param: multiple vdev restart parameter
*
* Send WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID parameters to fw.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_multiple_vdev_restart_req_cmd(
struct wmi_unified *wmi_handle,
struct multiple_vdev_restart_params *param);
/**
* wmi_unified_send_multiple_vdev_set_param_cmd() - Send multiple vdev set param
* command
* @wmi_handle: wmi handle
* @param: multiple vdev restart parameter
*
* Send WMI_PDEV_MULTIPLE_VDEV_SET_PARAM_CMDID parameters to fw.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_multiple_vdev_set_param_cmd(
struct wmi_unified *wmi_handle,
struct multiple_vdev_set_param *param);
/**
* wmi_unified_beacon_send_cmd() - WMI beacon send function
* @wmi_handle: handle to WMI.
* @param: pointer to hold beacon send cmd parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_beacon_send_cmd(struct wmi_unified *wmi_handle,
struct beacon_params *param);
/**
* wmi_extract_vdev_start_resp() - extract vdev start response
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @vdev_rsp: Pointer to hold vdev response
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_vdev_start_resp(struct wmi_unified *wmi_handle, void *evt_buf,
struct vdev_start_response *vdev_rsp);
/**
* wmi_extract_vdev_stopped_param() - extract vdev stop param from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @vdev_id: Pointer to hold vdev identifier
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_vdev_stopped_param(struct wmi_unified *wmi_handle, void *evt_buf,
uint32_t *vdev_id);
/**
* wmi_send_peer_vlan_config() - send peer vlan configuration
* @wmi_handle: wmi handle
* @mac_addr: mac address of the peer
* @param: vlan parameter
*/
QDF_STATUS
wmi_send_peer_vlan_config(struct wmi_unified *wmi_handle,
uint8_t *mac_addr,
struct peer_vlan_config_param param);
/**
* wmi_extract_vdev_delete_resp() - extract vdev delete response
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @vdev_del_resp: Pointer to hold vdev delete response
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_vdev_delete_resp(struct wmi_unified *wmi_handle, void *evt_buf,
struct vdev_delete_response *vdev_del_resp);
/**
* wmi_extract_vdev_peer_delete_all_response_event() - extract peer delete all
* response
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @delete_rsp: Pointer to hold peer delete all response
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_vdev_peer_delete_all_response_event(
struct wmi_unified *wmi_handle,
void *evt_buf,
struct peer_delete_all_response *delete_rsp);
/**
* wmi_extract_ext_tbttoffset_num_vdevs() - extract ext tbtt offset num vdev
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @num_vdevs: Pointer to hold num vdev
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_ext_tbttoffset_num_vdevs(struct wmi_unified *wmi_handle,
void *evt_buf, uint32_t *num_vdevs);
/**
* wmi_extract_tbttoffset_num_vdevs() - extract tbtt offset num vdev
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @num_vdevs: Pointer to hold num vdev
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_tbttoffset_num_vdevs(struct wmi_unified *wmi_handle, void *evt_buf,
uint32_t *num_vdevs);
/**
* wmi_extract_multi_vdev_restart_resp_event() - extract multi vdev restart
* response
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @restart_rsp: Pointer to hold multi vdev restart response
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_multi_vdev_restart_resp_event(
struct wmi_unified *wmi_handle,
void *evt_buf,
struct multi_vdev_restart_resp *restart_rsp);
/**
* wmi_unified_multisoc_tbtt_sync_cmd() - Send cmd to sync tbtt in multisoc case
* @wmi_handle: wmi handle
* @param: params received in rnr_tbtt_multisoc_sync_param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_multisoc_tbtt_sync_cmd(wmi_unified_t wmi_handle,
struct rnr_tbtt_multisoc_sync_param *param);
#ifdef WLAN_FEATURE_SR
/**
* wmi_unified_vdev_param_sr_prohibit_send() - send vdev SR prohibit command
* @wmi_hdl: wmi handle
* @srp_param: SR Prohibit parameters
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
QDF_STATUS
wmi_unified_vdev_param_sr_prohibit_send(wmi_unified_t wmi_hdl,
struct sr_prohibit_param *srp_param);
#else
static inline QDF_STATUS
wmi_unified_vdev_param_sr_prohibit_send(wmi_unified_t wmi_hdl,
struct sr_prohibit_param *srp_param)
{
return QDF_STATUS_SUCCESS;
}
#endif
#endif

51
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_vdev_tlv.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright (c) 2016-2020 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains TLV API declarations for the VDEV Unified Wireless Module
* Interface (WMI).
*/
#ifndef __WMI_UNIFIED_VDEV_TLV_H__
#define __WMI_UNIFIED_VDEV_TLV_H__
#include <wmi.h>
#include <wmi_unified_priv.h>
#include "wmi_unified.h"
/**
* wmi_vdev_attach_tlv: API to init vdev tlv ops
*
* @wmi_handle: pointer to wmi_unified structure.
*
* Return: none
*/
void wmi_vdev_attach_tlv(struct wmi_unified *wmi_handle);
#ifdef WLAN_BCN_RATECODE_ENABLE
static inline void wmi_enable_bcn_ratecode(uint32_t *cmd_flag)
{
*cmd_flag |= WMI_UNIFIED_VDEV_START_BCN_TX_RATE_PRESENT;
}
#else
static inline void wmi_enable_bcn_ratecode(uint32_t *cmd_flag)
{
}
#endif
#endif /* __WMI_UNIFIED_VDEV_TLV_H__ */

84
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_wds_api.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright (c) 2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API declaration for the WDS WMI APIs.
*/
#ifndef _WMI_UNIFIED_WDS_API_H_
#define _WMI_UNIFIED_WDS_API_H_
#ifdef WDS_CONV_TARGET_IF_OPS_ENABLE
#include <wmi_unified_api.h>
#include <wmi_unified_wds_param.h>
/**
* wmi_unified_peer_add_wds_entry_cmd() - WMI add wds entry cmd function
* @wmi_handle: handle to WMI
* @param: pointer to hold wds entry param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_peer_add_wds_entry_cmd(wmi_unified_t wmi_handle,
struct peer_add_wds_entry_params *param);
/**
* wmi_unified_peer_del_wds_entry_cmd() - WMI del wds entry cmd function
* @wmi_handle: handle to WMI
* @param: pointer to hold wds entry param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_peer_del_wds_entry_cmd(wmi_unified_t wmi_handle,
struct peer_del_wds_entry_params *param);
/**
* wmi_unified_update_wds_entry_cmd() - WMI update wds entry
* cmd function
* @wmi_handle: handle to WMI
* @param: pointer to hold wds entry param
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_unified_update_wds_entry_cmd(wmi_unified_t wmi_handle,
struct peer_update_wds_entry_params *param);
/**
* wmi_wds_attach_tlv() - attach wds tlv handlers
* @wmi_handle: wmi handle
*
* Return: void
*/
void wmi_wds_attach_tlv(wmi_unified_t wmi_handle);
#else
/**
* wmi_wds_attach_tlv() - attach wds tlv handlers
* @wmi_handle: wmi handle
*
* Return: void
*/
static inline void
wmi_wds_attach_tlv(struct wmi_unified *wmi_handle)
{
}
#endif /*WDS_CONV_TARGET_IF_OPS*/
#endif /*_WMI_UNIFIED_WDS_API_H_*/

63
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_unified_wds_param.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright (c) 2021 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the parameter definitions for the WDS WMI APIs.
*/
#ifndef _WMI_UNIFIED_WDS_PARAM_H_
#define _WMI_UNIFIED_WDS_PARAM_H_
/**
* struct peer_add_wds_entry_params - WDS peer entry add params
* @dest_addr: destination macaddr
* @peer_addr: peer mac addr
* @flags: WMI_HOST_WDS_FLAG_STATIC
* @vdev_id: Vdev id
*/
struct peer_add_wds_entry_params {
uint8_t dest_addr[QDF_MAC_ADDR_SIZE];
uint8_t peer_addr[QDF_MAC_ADDR_SIZE];
uint32_t flags;
uint32_t vdev_id;
};
/**
* struct peer_del_wds_entry_params - WDS peer entry del params
* @dest_addr: destination macaddr
* @vdev_id: Vdev id
*/
struct peer_del_wds_entry_params {
uint8_t dest_addr[QDF_MAC_ADDR_SIZE];
uint32_t vdev_id;
};
/**
* struct peer_update_wds_entry_params - WDS peer entry update params
* @dest_addr: destination macaddr
* @peer_addr: peer mac addr
* @flags: WMI_HOST_WDS_FLAG_STATIC
* @vdev_id: Vdev id
*/
struct peer_update_wds_entry_params {
uint8_t dest_addr[QDF_MAC_ADDR_SIZE];
uint8_t peer_addr[QDF_MAC_ADDR_SIZE];
uint32_t flags;
uint32_t vdev_id;
};
#endif /* _WMI_UNIFIED_WDS_PARAM_H_ */

33
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/inc/wmi_version_allowlist.h Normal file
View File

@@ -0,0 +1,33 @@
/*
* Copyright (c) 2013-2014, 2016 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Every Product Line or chipset or team can have its own Whitelist table.
* The following is a list of versions that the present software can support
* even though its versions are incompatible. Any entry here means that the
* indicated version does not break WMI compatibility even though it has
* a minor version change.
*/
#ifndef _WMI_VERSION_ALLOWLIST_H_
#define _WMI_VERSION_ALLOWLIST_H_
static wmi_whitelist_version_info version_whitelist[] = {
{0, 0, 0x5F414351, 0x00004C4D, 0, 0}
/* Placeholder: Major=0, Minor=0, Namespace="QCA_ML" (Dummy entry) */
};
#endif /* _WMI_VERSION_ALLOWLIST_H_ */

513
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_filtered_logging.c Normal file
View File

@@ -0,0 +1,513 @@
/*
* Copyright (c) 2015-2020 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_filtered_logging.h"
static struct wmi_log_buf_t *wmi_log_buf_allocate(void)
{
struct wmi_log_buf_t *cmd_log_buf;
int buf_size = WMI_FILTERED_CMD_EVT_MAX_NUM_ENTRY *
sizeof(struct wmi_command_debug);
cmd_log_buf = qdf_mem_malloc(sizeof(struct wmi_log_buf_t));
if (!cmd_log_buf)
return NULL;
cmd_log_buf->buf = qdf_mem_malloc(buf_size);
if (!cmd_log_buf->buf) {
qdf_mem_free(cmd_log_buf);
return NULL;
}
cmd_log_buf->length = 0;
cmd_log_buf->buf_tail_idx = 0;
cmd_log_buf->size = WMI_FILTERED_CMD_EVT_MAX_NUM_ENTRY;
cmd_log_buf->p_buf_tail_idx = &cmd_log_buf->buf_tail_idx;
return cmd_log_buf;
}
void wmi_filtered_logging_init(wmi_unified_t wmi_handle)
{
int buf_size = WMI_FILTERED_CMD_EVT_SUPPORTED * sizeof(int);
/* alloc buffer to save user inputs, for WMI_CMD */
wmi_handle->log_info.filtered_wmi_cmds =
qdf_mem_malloc(buf_size);
if (!wmi_handle->log_info.filtered_wmi_cmds)
return;
wmi_handle->log_info.filtered_wmi_cmds_idx = 0;
/* alloc buffer to save user interested WMI commands */
wmi_handle->log_info.wmi_filtered_command_log = wmi_log_buf_allocate();
if (!wmi_handle->log_info.wmi_filtered_command_log)
goto fail1;
/* alloc buffer to save user inputs, for WMI_EVT */
wmi_handle->log_info.filtered_wmi_evts =
qdf_mem_malloc(buf_size);
if (!wmi_handle->log_info.filtered_wmi_evts)
goto fail2;
wmi_handle->log_info.filtered_wmi_evts_idx = 0;
/* alloc buffer to save user interested WMI events */
wmi_handle->log_info.wmi_filtered_event_log = wmi_log_buf_allocate();
if (!wmi_handle->log_info.wmi_filtered_event_log)
goto fail3;
return;
fail3:
qdf_mem_free(wmi_handle->log_info.filtered_wmi_evts);
wmi_handle->log_info.filtered_wmi_evts = NULL;
fail2:
qdf_mem_free(wmi_handle->log_info.wmi_filtered_command_log);
wmi_handle->log_info.wmi_filtered_command_log = NULL;
fail1:
qdf_mem_free(wmi_handle->log_info.filtered_wmi_cmds);
wmi_handle->log_info.filtered_wmi_cmds = NULL;
}
void wmi_filtered_logging_free(wmi_unified_t wmi_handle)
{
if (!wmi_handle)
return;
qdf_mem_free(wmi_handle->log_info.filtered_wmi_cmds);
wmi_handle->log_info.filtered_wmi_cmds = NULL;
qdf_mem_free(wmi_handle->log_info.filtered_wmi_evts);
wmi_handle->log_info.filtered_wmi_evts = NULL;
if (wmi_handle->log_info.wmi_filtered_command_log) {
qdf_mem_free(wmi_handle->log_info.
wmi_filtered_command_log->buf);
wmi_handle->log_info.wmi_filtered_command_log->buf = NULL;
qdf_mem_free(wmi_handle->log_info.wmi_filtered_command_log);
wmi_handle->log_info.wmi_filtered_command_log = NULL;
}
if (wmi_handle->log_info.wmi_filtered_event_log) {
qdf_mem_free(wmi_handle->log_info.
wmi_filtered_event_log->buf);
wmi_handle->log_info.wmi_filtered_event_log->buf = NULL;
qdf_mem_free(wmi_handle->log_info.wmi_filtered_event_log);
wmi_handle->log_info.wmi_filtered_event_log = NULL;
}
}
/*
* Reset the buffer which saves user interested cmds/evts
*/
static int wmi_reset_filtered_buffers(wmi_unified_t wmi_handle,
struct wmi_log_buf_t *cmd_log_buf)
{
int buf_size = WMI_FILTERED_CMD_EVT_MAX_NUM_ENTRY *
sizeof(struct wmi_command_debug);
if (!cmd_log_buf)
return 0;
cmd_log_buf->length = 0;
cmd_log_buf->buf_tail_idx = 0;
cmd_log_buf->size = WMI_FILTERED_CMD_EVT_MAX_NUM_ENTRY;
cmd_log_buf->p_buf_tail_idx = &cmd_log_buf->buf_tail_idx;
qdf_mem_zero(cmd_log_buf->buf, buf_size);
return 0;
}
/*
* Check if id is in id list,
* return true if found.
*/
static bool wmi_id_in_list(uint32_t *id_list, uint32_t id)
{
int i;
if (!id_list)
return false;
for (i = 0; i < WMI_FILTERED_CMD_EVT_SUPPORTED; i++) {
if (id == id_list[i]) {
/* id already in target list */
return true;
}
}
return false;
}
/*
* Add command or event ids to list to be recorded
*/
static int wmi_add_to_record_list(wmi_unified_t wmi_handle,
uint32_t id,
enum WMI_RECORD_TYPE record_type)
{
uint32_t *target_list;
if (record_type == WMI_CMD) {
target_list = wmi_handle->log_info.filtered_wmi_cmds;
/* check if id already in target list */
if (wmi_id_in_list(target_list, id))
return 0;
if (wmi_handle->log_info.filtered_wmi_cmds_idx >=
WMI_FILTERED_CMD_EVT_SUPPORTED) {
wmi_handle->log_info.filtered_wmi_cmds_idx = 0;
}
target_list[wmi_handle->log_info.filtered_wmi_cmds_idx] = id;
wmi_handle->log_info.filtered_wmi_cmds_idx++;
} else if (record_type == WMI_EVT) {
target_list = wmi_handle->log_info.filtered_wmi_evts;
/* check if id already in target list */
if (wmi_id_in_list(target_list, id))
return 0;
if (wmi_handle->log_info.filtered_wmi_evts_idx >=
WMI_FILTERED_CMD_EVT_SUPPORTED) {
wmi_handle->log_info.filtered_wmi_evts_idx = 0;
}
target_list[wmi_handle->log_info.filtered_wmi_evts_idx] = id;
wmi_handle->log_info.filtered_wmi_evts_idx++;
} else {
return -EINVAL;
}
return 0;
}
static void wmi_specific_cmd_evt_record(uint32_t id, uint8_t *buf,
struct wmi_log_buf_t *log_buffer)
{
int idx;
struct wmi_command_debug *tmpbuf =
(struct wmi_command_debug *)log_buffer->buf;
if (*log_buffer->p_buf_tail_idx >= WMI_FILTERED_CMD_EVT_MAX_NUM_ENTRY)
*log_buffer->p_buf_tail_idx = 0;
idx = *log_buffer->p_buf_tail_idx;
tmpbuf[idx].command = id;
qdf_mem_copy(tmpbuf[idx].data, buf,
WMI_DEBUG_ENTRY_MAX_LENGTH);
tmpbuf[idx].time = qdf_get_log_timestamp();
(*log_buffer->p_buf_tail_idx)++;
log_buffer->length++;
}
void wmi_specific_cmd_record(wmi_unified_t wmi_handle,
uint32_t id, uint8_t *buf)
{
uint32_t *target_list;
struct wmi_log_buf_t *log_buffer;
target_list = wmi_handle->log_info.filtered_wmi_cmds;
if (!target_list)
return;
log_buffer = wmi_handle->log_info.wmi_filtered_command_log;
if (!log_buffer)
return;
if (wmi_id_in_list(target_list, id)) {
/* id in target list, need to be recorded */
wmi_specific_cmd_evt_record(id, buf, log_buffer);
}
}
void wmi_specific_evt_record(wmi_unified_t wmi_handle,
uint32_t id, uint8_t *buf)
{
uint32_t *target_list;
struct wmi_log_buf_t *log_buffer;
target_list = wmi_handle->log_info.filtered_wmi_evts;
if (!target_list)
return;
log_buffer = wmi_handle->log_info.wmi_filtered_event_log;
if (!log_buffer)
return;
if (wmi_id_in_list(target_list, id)) {
/* id in target list, need to be recorded */
wmi_specific_cmd_evt_record(id, buf, log_buffer);
}
}
/*
* Debugfs read/write functions
*/
static int wmi_filtered_seq_printf(qdf_debugfs_file_t m, const char *f, ...)
{
va_list args;
va_start(args, f);
seq_vprintf(m, f, args);
va_end(args);
return 0;
}
/*
* debugfs show/read for filtered_wmi_cmds
*/
int debug_filtered_wmi_cmds_show(qdf_debugfs_file_t m, void *v)
{
wmi_unified_t wmi_handle = (wmi_unified_t)m->private;
int i;
int *target_list;
target_list = wmi_handle->log_info.filtered_wmi_cmds;
if (!target_list)
return 0;
for (i = 0; i < WMI_FILTERED_CMD_EVT_SUPPORTED; i++) {
if (target_list[i] != 0) {
wmi_filtered_seq_printf(m, "0x%x ",
target_list[i]);
}
}
wmi_filtered_seq_printf(m, "\n");
return 0;
}
int debug_filtered_wmi_evts_show(qdf_debugfs_file_t m, void *v)
{
wmi_unified_t wmi_handle = (wmi_unified_t)m->private;
int i;
int *target_list;
target_list = wmi_handle->log_info.filtered_wmi_evts;
if (!target_list)
return 0;
for (i = 0; i < WMI_FILTERED_CMD_EVT_SUPPORTED; i++) {
if (target_list[i] != 0) {
wmi_filtered_seq_printf(m, "0x%x ",
target_list[i]);
}
}
wmi_filtered_seq_printf(m, "\n");
return 0;
}
static int wmi_log_show(wmi_unified_t wmi_handle, void *buf,
qdf_debugfs_file_t m)
{
struct wmi_log_buf_t *wmi_log = (struct wmi_log_buf_t *)buf;
int pos, nread, outlen;
int i;
uint64_t secs, usecs;
int wmi_ring_size = 100;
qdf_spin_lock_bh(&wmi_handle->log_info.wmi_record_lock);
if (!wmi_log->length) {
qdf_spin_unlock_bh(&wmi_handle->log_info.wmi_record_lock);
return wmi_filtered_seq_printf(m,
"Nothing to read!\n");
}
if (wmi_log->length <= wmi_ring_size)
nread = wmi_log->length;
else
nread = wmi_ring_size;
if (*wmi_log->p_buf_tail_idx == 0)
/* tail can be 0 after wrap-around */
pos = wmi_ring_size - 1;
else
pos = *wmi_log->p_buf_tail_idx - 1;
outlen = wmi_filtered_seq_printf(m, "Length = %d\n", wmi_log->length);
qdf_spin_unlock_bh(&wmi_handle->log_info.wmi_record_lock);
while (nread--) {
struct wmi_event_debug *wmi_record;
wmi_record = &(((struct wmi_event_debug *)wmi_log->buf)[pos]);
qdf_log_timestamp_to_secs(wmi_record->time, &secs,
&usecs);
outlen += wmi_filtered_seq_printf(m, "Event ID = %x\n",
(wmi_record->event));
outlen +=
wmi_filtered_seq_printf(m,
"Event TIME = [%llu.%06llu]\n",
secs, usecs);
outlen += wmi_filtered_seq_printf(m, "CMD = ");
for (i = 0; i < (WMI_DEBUG_ENTRY_MAX_LENGTH /
sizeof(uint32_t)); i++)
outlen += wmi_filtered_seq_printf(m, "%x ",
wmi_record->data[i]);
outlen += wmi_filtered_seq_printf(m, "\n");
if (pos == 0)
pos = wmi_ring_size - 1;
else
pos--;
}
return outlen;
}
int debug_wmi_filtered_command_log_show(qdf_debugfs_file_t m, void *v)
{
wmi_unified_t wmi_handle = (wmi_unified_t)m->private;
struct wmi_log_buf_t *wmi_log =
wmi_handle->log_info.wmi_filtered_command_log;
if (!wmi_log)
return 0;
return wmi_log_show(wmi_handle, wmi_log, m);
}
int debug_wmi_filtered_event_log_show(qdf_debugfs_file_t m, void *v)
{
wmi_unified_t wmi_handle = (wmi_unified_t)m->private;
struct wmi_log_buf_t *wmi_log =
wmi_handle->log_info.wmi_filtered_event_log;
if (!wmi_log)
return 0;
return wmi_log_show(wmi_handle, wmi_log, m);
}
ssize_t debug_filtered_wmi_cmds_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos)
{
wmi_unified_t wmi_handle =
((struct seq_file *)file->private_data)->private;
int k, ret;
char locbuf[12] = {0};
int buf_size = WMI_FILTERED_CMD_EVT_SUPPORTED * sizeof(int);
if ((!buf) || (count > 8 || count <= 0))
return -EFAULT;
if (!wmi_handle->log_info.filtered_wmi_cmds)
return -EFAULT;
if (copy_from_user(locbuf, buf, count))
return -EFAULT;
ret = qdf_kstrtoint(locbuf, 16, &k);
if (ret)
return -EINVAL;
if (k == 0xffff) {
qdf_mem_zero(wmi_handle->log_info.filtered_wmi_cmds, buf_size);
wmi_handle->log_info.filtered_wmi_cmds_idx = 0;
return count;
}
if (wmi_add_to_record_list(wmi_handle, k, WMI_CMD)) {
wmi_err("Add cmd %d to WMI_CMD list failed", k);
return 0;
}
return count;
}
ssize_t debug_filtered_wmi_evts_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos)
{
wmi_unified_t wmi_handle =
((struct seq_file *)file->private_data)->private;
int k, ret;
char locbuf[12] = {0};
int buf_size = WMI_FILTERED_CMD_EVT_SUPPORTED * sizeof(int);
if ((!buf) || (count > 8 || count <= 0))
return -EFAULT;
if (!wmi_handle->log_info.filtered_wmi_evts)
return -EFAULT;
if (copy_from_user(locbuf, buf, count))
return -EFAULT;
ret = qdf_kstrtoint(locbuf, 16, &k);
if (ret)
return -EINVAL;
if (k == 0xffff) {
qdf_mem_zero(wmi_handle->log_info.filtered_wmi_evts, buf_size);
wmi_handle->log_info.filtered_wmi_evts_idx = 0;
return count;
}
if (wmi_add_to_record_list(wmi_handle, k, WMI_EVT)) {
wmi_err("Add cmd %d to WMI_EVT list failed", k);
return 0;
}
return count;
}
ssize_t debug_wmi_filtered_command_log_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos)
{
wmi_unified_t wmi_handle =
((struct seq_file *)file->private_data)->private;
int k, ret;
char locbuf[12] = {0};
struct wmi_log_buf_t *cmd_log_buf;
if ((!buf) || (count > 8 || count <= 0))
return -EFAULT;
if (copy_from_user(locbuf, buf, count))
return -EFAULT;
ret = qdf_kstrtoint(locbuf, 16, &k);
if (ret)
return -EINVAL;
if (k != 0xffff)
return -EINVAL;
cmd_log_buf = wmi_handle->log_info.wmi_filtered_command_log;
if (wmi_reset_filtered_buffers(wmi_handle, cmd_log_buf))
wmi_err("reset WMI CMD filtered_buffers failed");
return count;
}
ssize_t debug_wmi_filtered_event_log_write(struct file *file,
const char __user *buf,
size_t count, loff_t *ppos)
{
wmi_unified_t wmi_handle =
((struct seq_file *)file->private_data)->private;
int k, ret;
char locbuf[12] = {0};
struct wmi_log_buf_t *cmd_log_buf;
if ((!buf) || (count > 8 || count <= 0))
return -EFAULT;
if (copy_from_user(locbuf, buf, count))
return -EFAULT;
ret = qdf_kstrtoint(locbuf, 16, &k);
if (ret)
return -EINVAL;
if (k != 0xffff)
return -EINVAL;
cmd_log_buf = wmi_handle->log_info.wmi_filtered_event_log;
if (wmi_reset_filtered_buffers(wmi_handle, cmd_log_buf))
wmi_err("reset WMI EVT filtered_buffers failed");
return count;
}

137
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_hang_event.c Normal file
View File

@@ -0,0 +1,137 @@
/*
* Copyright (c) 2020-2021, The Linux Foundation. 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <qdf_hang_event_notifier.h>
#include <qdf_notifier.h>
#include <wmi_hang_event.h>
#include <wmi_unified_priv.h>
#include <qdf_trace.h>
struct wmi_hang_data_fixed_param {
uint16_t tlv_header; /* tlv tag and length */
uint32_t event;
uint32_t data;
uint64_t time;
} qdf_packed;
#define WMI_EVT_HIST 0
#define WMI_CMD_HIST 1
#define NUM_HANG_WMI_HISTORY 1
static void wmi_log_history(struct notifier_block *block, void *data,
uint8_t wmi_history)
{
qdf_notif_block *notif_block = qdf_container_of(block, qdf_notif_block,
notif_block);
struct qdf_notifer_data *wmi_hang_data = data;
int nread, pos, total_len;
unsigned int wmi_ring_size = NUM_HANG_WMI_HISTORY;
uint64_t secs, usecs;
struct wmi_event_debug *wmi_evt;
struct wmi_unified *wmi_handle;
struct wmi_log_buf_t *wmi_log;
struct wmi_hang_data_fixed_param *cmd;
struct wmi_command_debug *wmi_cmd;
uint8_t *wmi_buf_ptr;
if (!wmi_hang_data)
return;
wmi_handle = notif_block->priv_data;
if (!wmi_handle)
return;
if (wmi_history == WMI_EVT_HIST)
wmi_log = &wmi_handle->log_info.wmi_event_log_buf_info;
else
wmi_log = &wmi_handle->log_info.wmi_command_log_buf_info;
total_len = sizeof(struct wmi_hang_data_fixed_param);
if (wmi_log->length <= wmi_ring_size)
nread = wmi_log->length;
else
nread = wmi_ring_size;
if (*wmi_log->p_buf_tail_idx == 0)
/* tail can be 0 after wrap-around */
pos = wmi_ring_size - 1;
else
pos = *wmi_log->p_buf_tail_idx - 1;
while (nread--) {
if (wmi_hang_data->offset + total_len > QDF_WLAN_HANG_FW_OFFSET)
return;
switch (wmi_history) {
case WMI_EVT_HIST:
wmi_buf_ptr = (wmi_hang_data->hang_data +
wmi_hang_data->offset);
cmd = ((struct wmi_hang_data_fixed_param *)wmi_buf_ptr);
QDF_HANG_EVT_SET_HDR(&cmd->tlv_header,
HANG_EVT_TAG_WMI_EVT_HIST,
QDF_HANG_GET_STRUCT_TLVLEN(struct wmi_hang_data_fixed_param));
wmi_evt = &(((struct wmi_event_debug *)wmi_log->buf)[pos]);
cmd->event = wmi_evt->event;
qdf_log_timestamp_to_secs(wmi_evt->time, &secs, &usecs);
cmd->time = secs;
cmd->data = wmi_evt->data[0];
break;
case WMI_CMD_HIST:
wmi_buf_ptr = (wmi_hang_data->hang_data +
wmi_hang_data->offset);
cmd = ((struct wmi_hang_data_fixed_param *)wmi_buf_ptr);
QDF_HANG_EVT_SET_HDR(&cmd->tlv_header,
HANG_EVT_TAG_WMI_CMD_HIST,
QDF_HANG_GET_STRUCT_TLVLEN(struct wmi_hang_data_fixed_param));
wmi_cmd = &(((struct wmi_command_debug *)wmi_log->buf)[pos]);
cmd->event = wmi_cmd->command;
qdf_log_timestamp_to_secs(wmi_cmd->time, &secs, &usecs);
cmd->time = secs;
cmd->data = wmi_cmd->data[0];
break;
}
if (pos == 0)
pos = wmi_ring_size - 1;
else
pos--;
wmi_hang_data->offset += total_len;
}
}
static int wmi_recovery_notifier_call(struct notifier_block *block,
unsigned long state,
void *data)
{
wmi_log_history(block, data, WMI_EVT_HIST);
wmi_log_history(block, data, WMI_CMD_HIST);
return NOTIFY_OK;
}
static qdf_notif_block wmi_recovery_notifier = {
.notif_block.notifier_call = wmi_recovery_notifier_call,
};
QDF_STATUS wmi_hang_event_notifier_register(struct wmi_unified *wmi_hdl)
{
wmi_recovery_notifier.priv_data = wmi_hdl;
return qdf_hang_event_register_notifier(&wmi_recovery_notifier);
}
QDF_STATUS wmi_hang_event_notifier_unregister(void)
{
return qdf_hang_event_unregister_notifier(&wmi_recovery_notifier);
}

1364
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_tlv_helper.c Normal file
View File

File diff suppressed because it is too large Load Diff

43
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_tlv_platform.c Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (c) 2013-2014, 2016-2017 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* LMAC offload interface functions for WMI TLV Interface
*/
#include <qdf_mem.h> /* qdf_mem_malloc,free, etc. */
#include <osdep.h>
#include "htc_api.h"
#include "wmi.h"
/* Following macro definitions use OS or platform specific functions */
#define dummy_print(fmt, ...) {}
#define wmi_tlv_print_verbose dummy_print
#define wmi_tlv_print_error qdf_print
#define wmi_tlv_OS_MEMCPY OS_MEMCPY
#define wmi_tlv_OS_MEMZERO OS_MEMZERO
#define wmi_tlv_OS_MEMMOVE OS_MEMMOVE
#ifndef NO_DYNAMIC_MEM_ALLOC
#define wmi_tlv_os_mem_alloc(scn, ptr, numBytes) \
{ \
(ptr) = qdf_mem_malloc(numBytes); \
}
#define wmi_tlv_os_mem_free qdf_mem_free
#endif

3888
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified.c Normal file
View File

File diff suppressed because it is too large Load Diff

297
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_11be_api.c Normal file
View File

@@ -0,0 +1,297 @@
/*
* Copyright (c) 2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to 11be.
*/
#include "wmi_unified_11be_api.h"
/**
* wmi_extract_mlo_link_set_active_resp() - extract mlo link set active resp
* from event
* @wmi: WMI handle for this pdev
* @evt_buf: pointer to event buffer
* @resp: Pointer to hold mlo link set active resp
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_extract_mlo_link_set_active_resp(wmi_unified_t wmi,
void *evt_buf,
struct mlo_link_set_active_resp *resp)
{
if (wmi->ops->extract_mlo_link_set_active_resp) {
return wmi->ops->extract_mlo_link_set_active_resp(wmi,
evt_buf,
resp);
}
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_send_mlo_link_set_active_cmd() - send mlo link set active command
* @wmi: WMI handle for this pdev
* @param: Pointer to mlo link set active param
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_send_mlo_link_set_active_cmd(wmi_unified_t wmi,
struct mlo_link_set_active_param *param)
{
if (wmi->ops->send_mlo_link_set_active_cmd)
return wmi->ops->send_mlo_link_set_active_cmd(wmi, param);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_11BE
QDF_STATUS wmi_send_mlo_peer_tid_to_link_map_cmd(
wmi_unified_t wmi,
struct wmi_host_tid_to_link_map_params *params,
bool t2lm_info)
{
if (wmi->ops->send_mlo_peer_tid_to_link_map)
return wmi->ops->send_mlo_peer_tid_to_link_map(wmi, params, t2lm_info);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_send_mlo_vdev_tid_to_link_map_cmd(
wmi_unified_t wmi,
struct wmi_host_tid_to_link_map_ap_params *params)
{
if (wmi->ops->send_mlo_vdev_tid_to_link_map)
return wmi->ops->send_mlo_vdev_tid_to_link_map(wmi, params);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_11BE_MLO_ADV_FEATURE
QDF_STATUS
wmi_send_mlo_link_switch_req_cnf_cmd(wmi_unified_t wmi,
struct wlan_mlo_link_switch_cnf *params)
{
if (wmi->ops->send_mlo_link_switch_req_cnf_cmd)
return wmi->ops->send_mlo_link_switch_req_cnf_cmd(wmi, params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_mlo_link_switch_request_evt(struct wmi_unified *wmi,
void *buf,
struct wlan_mlo_link_switch_req *req)
{
if (wmi->ops->extract_mlo_link_switch_request_event)
return wmi->ops->extract_mlo_link_switch_request_event(wmi,
buf,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_mlo_link_state_switch_evt(struct wmi_unified *wmi,
void *buf, uint8_t len,
struct mlo_link_switch_state_info *info)
{
if (wmi->ops->extract_mlo_link_state_switch_evt)
return wmi->ops->extract_mlo_link_state_switch_evt(
wmi, buf, len, info);
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_FEATURE_11BE_MLO_ADV_FEATURE */
QDF_STATUS wmi_send_mlo_link_state_request_cmd(
wmi_unified_t wmi,
struct wmi_host_link_state_params *params)
{
if (wmi->ops->send_mlo_link_state_request)
return wmi->ops->send_mlo_link_state_request(wmi, params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_send_link_set_bss_params_cmd(
wmi_unified_t wmi,
struct wmi_host_link_bss_params *params)
{
if (wmi->ops->send_link_set_bss_params_cmd)
return wmi->ops->send_link_set_bss_params_cmd(wmi, params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_mlo_vdev_tid_to_link_map_event(
wmi_unified_t wmi, void *evt_buf,
struct mlo_vdev_host_tid_to_link_map_resp *resp)
{
if (wmi->ops->extract_mlo_vdev_tid_to_link_map_event) {
return wmi->ops->extract_mlo_vdev_tid_to_link_map_event(wmi,
evt_buf,
resp);
}
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_mlo_vdev_bcast_tid_to_link_map_event(
wmi_unified_t wmi,
void *evt_buf,
struct mlo_bcast_t2lm_info *bcast)
{
if (wmi->ops->extract_mlo_vdev_bcast_tid_to_link_map_event) {
return wmi->ops->extract_mlo_vdev_bcast_tid_to_link_map_event(
wmi,
evt_buf,
bcast);
}
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_mlo_link_state_info_event(
wmi_unified_t wmi,
void *evt_buf,
struct ml_link_state_info_event *params)
{
if (wmi->ops->extract_mlo_link_state_event)
return wmi->ops->extract_mlo_link_state_event(
wmi, evt_buf, params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_mlo_link_disable_request_evt(
struct wmi_unified *wmi,
void *buf,
struct mlo_link_disable_request_evt_params *params)
{
if (wmi->ops->extract_mlo_link_disable_request_evt_param)
return wmi->ops->extract_mlo_link_disable_request_evt_param(
wmi, buf, params);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_FEATURE_11BE */
QDF_STATUS
wmi_extract_mgmt_rx_ml_cu_params(wmi_unified_t wmi, void *evt_buf,
struct mlo_mgmt_ml_info *cu_params)
{
if (wmi->ops->extract_mgmt_rx_ml_cu_params)
return wmi->ops->extract_mgmt_rx_ml_cu_params(
wmi, evt_buf, cu_params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_send_mlo_link_removal_cmd(
wmi_unified_t wmi,
const struct mlo_link_removal_cmd_params *param)
{
if (wmi->ops->send_mlo_link_removal_cmd)
return wmi->ops->send_mlo_link_removal_cmd(wmi, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_send_mlo_vdev_pause(wmi_unified_t wmi,
struct mlo_vdev_pause *info)
{
if (wmi->ops->send_mlo_vdev_pause)
return wmi->ops->send_mlo_vdev_pause(wmi, info);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_mlo_link_removal_evt_fixed_param(
struct wmi_unified *wmi,
void *buf,
struct mlo_link_removal_evt_params *params)
{
if (wmi->ops->extract_mlo_link_removal_evt_fixed_param)
return wmi->ops->extract_mlo_link_removal_evt_fixed_param(
wmi, buf, params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_mlo_link_removal_tbtt_update(
struct wmi_unified *wmi,
void *buf,
struct mlo_link_removal_tbtt_info *tbtt_info)
{
if (wmi->ops->extract_mlo_link_removal_tbtt_update)
return wmi->ops->extract_mlo_link_removal_tbtt_update(
wmi, buf, tbtt_info);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_mgmt_rx_mlo_link_removal_info(
struct wmi_unified *wmi,
void *buf,
struct mgmt_rx_mlo_link_removal_info *link_removal_info,
int num_link_removal_info)
{
if (wmi->ops->extract_mgmt_rx_mlo_link_removal_info)
return wmi->ops->extract_mgmt_rx_mlo_link_removal_info(
wmi, buf,
link_removal_info,
num_link_removal_info);
return QDF_STATUS_E_FAILURE;
}
#ifdef QCA_SUPPORT_PRIMARY_LINK_MIGRATE
QDF_STATUS wmi_unified_peer_ptqm_migrate_send(
wmi_unified_t wmi_hdl,
struct peer_ptqm_migrate_params *param)
{
if (wmi_hdl->ops->send_peer_ptqm_migrate_cmd)
return wmi_hdl->ops->send_peer_ptqm_migrate_cmd(wmi_hdl, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_peer_ptqm_migrate_event(
wmi_unified_t wmi, void *evt_buf,
struct peer_ptqm_migrate_event_params *resp)
{
if (wmi->ops->extract_peer_ptqm_migrate_event) {
return wmi->ops->extract_peer_ptqm_migrate_event(wmi,
evt_buf,
resp);
}
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_peer_ptqm_entry_param(
wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
struct peer_entry_ptqm_migrate_event_params *entry)
{
if (wmi_handle->ops->extract_peer_entry_ptqm_migrate_event)
return wmi_handle->ops->extract_peer_entry_ptqm_migrate_event(
wmi_handle, evt_buf,
index, entry);
return QDF_STATUS_E_FAILURE;
}
#endif /* QCA_SUPPORT_PRIMARY_LINK_MIGRATE */

111
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_11be_setup_api.c Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright (c) 2021, The Linux Foundation. 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_unified_priv.h"
#ifdef WLAN_MLO_MULTI_CHIP
#include "wmi_unified_11be_setup_api.h"
#endif
#include "wmi_unified_11be_tlv.h"
/**
* wmi_mlo_setup_cmd_send() - Send MLO setup command
* @wmi_handle: WMI handle for this pdev
* @params: MLO setup params
*
* Return: QDF_STATUS code
*/
QDF_STATUS wmi_mlo_setup_cmd_send(wmi_unified_t wmi_handle,
struct wmi_mlo_setup_params *params)
{
if (wmi_handle->ops->mlo_setup_cmd_send)
return wmi_handle->ops->mlo_setup_cmd_send(
wmi_handle, params);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_mlo_teardown_cmd_send() - Send MLO teardown command
* @wmi_handle: WMI handle for this pdev
* @params: MLO teardown params
*
* Return: QDF_STATUS code
*/
QDF_STATUS wmi_mlo_teardown_cmd_send(wmi_unified_t wmi_handle,
struct wmi_mlo_teardown_params *params)
{
if (wmi_handle->ops->mlo_teardown_cmd_send)
return wmi_handle->ops->mlo_teardown_cmd_send(
wmi_handle, params);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_mlo_ready_cmd_send() - Send MLO ready command
* @wmi_handle: WMI handle for this pdev
* @params: MLO ready params
*
* Return: QDF_STATUS code
*/
QDF_STATUS wmi_mlo_ready_cmd_send(wmi_unified_t wmi_handle,
struct wmi_mlo_ready_params *params)
{
if (wmi_handle->ops->mlo_ready_cmd_send)
return wmi_handle->ops->mlo_ready_cmd_send(
wmi_handle, params);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_extract_mlo_setup_cmpl_event() - Extract MLO setup completion event
* @wmi_handle: WMI handle for this pdev
* @buf: Event buffer
* @params: MLO setup event params
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_extract_mlo_setup_cmpl_event(wmi_unified_t wmi_handle,
uint8_t *buf,
struct wmi_mlo_setup_complete_params *params)
{
if (wmi_handle->ops->extract_mlo_setup_cmpl_event)
return wmi_handle->ops->extract_mlo_setup_cmpl_event(
wmi_handle, buf, params);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_extract_mlo_teardown_cmpl_event() - Extract MLO teardown completion
* @wmi_handle: WMI handle for this pdev
* @buf: Event buffer
* @param: MLO teardown event params
*
* Return: QDF_STATUS code
*/
QDF_STATUS
wmi_extract_mlo_teardown_cmpl_event(wmi_unified_t wmi_handle,
uint8_t *buf,
struct wmi_mlo_teardown_cmpl_params *param)
{
if (wmi_handle->ops->extract_mlo_teardown_cmpl_event)
return wmi_handle->ops->extract_mlo_teardown_cmpl_event(
wmi_handle, buf, param);
return QDF_STATUS_E_FAILURE;
}

2702
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_11be_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

314
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_action_oui_tlv.c Normal file
View File

@@ -0,0 +1,314 @@
/*
* Copyright (c) 2016-2018, 2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_unified_action_oui_tlv.h"
#include "wmi_unified_priv.h"
bool wmi_get_action_oui_id(enum action_oui_id action_id,
wmi_vendor_oui_action_id *id)
{
switch (action_id) {
case ACTION_OUI_CONNECT_1X1:
*id = WMI_VENDOR_OUI_ACTION_CONNECTION_1X1;
return true;
case ACTION_OUI_ITO_EXTENSION:
*id = WMI_VENDOR_OUI_ACTION_ITO_EXTENSION;
return true;
case ACTION_OUI_CCKM_1X1:
*id = WMI_VENDOR_OUI_ACTION_CCKM_1X1;
return true;
case ACTION_OUI_ITO_ALTERNATE:
*id = WMI_VENDOR_OUI_ACTION_ALT_ITO;
return true;
case ACTION_OUI_SWITCH_TO_11N_MODE:
*id = WMI_VENDOR_OUI_ACTION_SWITCH_TO_11N_MODE;
return true;
case ACTION_OUI_CONNECT_1X1_WITH_1_CHAIN:
*id = WMI_VENDOR_OUI_ACTION_CONNECTION_1X1_NUM_TX_RX_CHAINS_1;
return true;
case ACTION_OUI_DISABLE_AGGRESSIVE_TX:
*id = WMI_VENDOR_OUI_ACTION_DISABLE_AGGRESSIVE_TX;
return true;
case ACTION_OUI_DISABLE_TWT:
*id = WMI_VENDOR_OUI_ACTION_DISABLE_FW_TRIGGERED_TWT;
return true;
case ACTION_OUI_EXTEND_WOW_ITO:
*id = WMI_VENDOR_OUI_ACTION_EXTEND_WOW_ITO;
return true;
case ACTION_OUI_11BE_OUI_ALLOW:
*id = WMI_VENDOR_OUI_ACTION_ALLOW_11BE;
return true;
case ACTION_OUI_DISABLE_DYNAMIC_QOS_NULL_TX_RATE:
*id = WMI_VENDOR_OUI_ACTION_DISABLE_DYNAMIC_QOS_NULL_TX_RATE;
return true;
case ACTION_OUI_ENABLE_CTS2SELF_WITH_QOS_NULL:
*id = WMI_VENDOR_OUI_ACTION_ENABLE_CTS2SELF_WITH_QOS_NULL;
return true;
case ACTION_OUI_SEND_SMPS_FRAME_WITH_OMN:
*id = WMI_VENDOR_OUI_ACTION_SEND_SMPS_FRAME_WITH_OMN;
return true;
default:
return false;
}
}
uint32_t wmi_get_action_oui_info_mask(uint32_t info_mask)
{
uint32_t info_presence = 0;
if (info_mask & ACTION_OUI_INFO_OUI)
info_presence |= WMI_BEACON_INFO_PRESENCE_OUI_EXT;
if (info_mask & ACTION_OUI_INFO_MAC_ADDRESS)
info_presence |= WMI_BEACON_INFO_PRESENCE_MAC_ADDRESS;
if (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_NSS)
info_presence |= WMI_BEACON_INFO_PRESENCE_AP_CAPABILITY_NSS;
if (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_HT)
info_presence |= WMI_BEACON_INFO_PRESENCE_AP_CAPABILITY_HT;
if (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_VHT)
info_presence |= WMI_BEACON_INFO_PRESENCE_AP_CAPABILITY_VHT;
if (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_BAND)
info_presence |= WMI_BEACON_INFO_PRESENCE_AP_CAPABILITY_BAND;
return info_presence;
}
void wmi_fill_oui_extensions(struct action_oui_extension *extension,
uint32_t no_oui_extns,
wmi_vendor_oui_ext *cmd_ext)
{
uint32_t i;
uint32_t buffer_length;
for (i = 0; i < no_oui_extns; i++) {
WMITLV_SET_HDR(&cmd_ext->tlv_header,
WMITLV_TAG_STRUC_wmi_vendor_oui_ext,
WMITLV_GET_STRUCT_TLVLEN(wmi_vendor_oui_ext));
cmd_ext->info_presence_bit_mask =
wmi_get_action_oui_info_mask(extension->info_mask);
cmd_ext->oui_header_length = extension->oui_length;
cmd_ext->oui_data_length = extension->data_length;
cmd_ext->mac_address_length = extension->mac_addr_length;
cmd_ext->capability_data_length =
extension->capability_length;
buffer_length = extension->oui_length +
extension->data_length +
extension->data_mask_length +
extension->mac_addr_length +
extension->mac_mask_length +
extension->capability_length;
cmd_ext->buf_data_length = buffer_length + 1;
cmd_ext++;
extension++;
}
}
QDF_STATUS
wmi_fill_oui_extensions_buffer(struct action_oui_extension *extension,
wmi_vendor_oui_ext *cmd_ext,
uint32_t no_oui_extns, uint32_t rem_var_buf_len,
uint8_t *var_buf)
{
uint8_t i;
for (i = 0; i < (uint8_t)no_oui_extns; i++) {
if ((rem_var_buf_len - cmd_ext->buf_data_length) < 0) {
wmi_err("Invalid action oui command length");
return QDF_STATUS_E_INVAL;
}
var_buf[0] = i;
var_buf++;
if (extension->oui_length) {
qdf_mem_copy(var_buf, extension->oui,
extension->oui_length);
var_buf += extension->oui_length;
}
if (extension->data_length) {
qdf_mem_copy(var_buf, extension->data,
extension->data_length);
var_buf += extension->data_length;
}
if (extension->data_mask_length) {
qdf_mem_copy(var_buf, extension->data_mask,
extension->data_mask_length);
var_buf += extension->data_mask_length;
}
if (extension->mac_addr_length) {
qdf_mem_copy(var_buf, extension->mac_addr,
extension->mac_addr_length);
var_buf += extension->mac_addr_length;
}
if (extension->mac_mask_length) {
qdf_mem_copy(var_buf, extension->mac_mask,
extension->mac_mask_length);
var_buf += extension->mac_mask_length;
}
if (extension->capability_length) {
qdf_mem_copy(var_buf, extension->capability,
extension->capability_length);
var_buf += extension->capability_length;
}
rem_var_buf_len -= cmd_ext->buf_data_length;
cmd_ext++;
extension++;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
send_action_oui_cmd_tlv(wmi_unified_t wmi_handle,
struct action_oui_request *req)
{
wmi_pdev_config_vendor_oui_action_fixed_param *cmd;
wmi_vendor_oui_ext *cmd_ext;
wmi_buf_t wmi_buf;
struct action_oui_extension *extension;
uint32_t len;
uint32_t i;
uint8_t *buf_ptr;
uint32_t no_oui_extns;
uint32_t total_no_oui_extns;
uint32_t var_buf_len = 0;
wmi_vendor_oui_action_id action_id;
bool valid;
uint32_t rem_var_buf_len;
QDF_STATUS status;
if (!req) {
wmi_err("action oui is empty");
return QDF_STATUS_E_INVAL;
}
no_oui_extns = req->no_oui_extensions;
total_no_oui_extns = req->total_no_oui_extensions;
len = sizeof(*cmd);
len += WMI_TLV_HDR_SIZE; /* Array of wmi_vendor_oui_ext structures */
if (no_oui_extns > WMI_MAX_VENDOR_OUI_ACTION_SUPPORTED_PER_ACTION ||
(total_no_oui_extns > WMI_VENDOR_OUI_ACTION_MAX_ACTION_ID *
WMI_MAX_VENDOR_OUI_ACTION_SUPPORTED_PER_ACTION)) {
wmi_err("Invalid number of action oui extensions");
return QDF_STATUS_E_INVAL;
}
valid = wmi_get_action_oui_id(req->action_id, &action_id);
if (!valid) {
wmi_err("Invalid action id");
return QDF_STATUS_E_INVAL;
}
wmi_debug("wmi action_id %d num %d total_num %d", action_id,
no_oui_extns, total_no_oui_extns);
len += no_oui_extns * sizeof(*cmd_ext);
len += WMI_TLV_HDR_SIZE; /* Variable length buffer */
extension = req->extension;
for (i = 0; i < no_oui_extns; i++) {
var_buf_len += extension->oui_length +
extension->data_length +
extension->data_mask_length +
extension->mac_addr_length +
extension->mac_mask_length +
extension->capability_length;
extension++;
}
var_buf_len += no_oui_extns; /* to store indexes */
rem_var_buf_len = var_buf_len;
var_buf_len = (var_buf_len + 3) & ~0x3;
len += var_buf_len;
wmi_buf = wmi_buf_alloc(wmi_handle, len);
if (!wmi_buf) {
wmi_err("Failed to allocate wmi buffer");
return QDF_STATUS_E_FAILURE;
}
buf_ptr = (uint8_t *)wmi_buf_data(wmi_buf);
cmd = (wmi_pdev_config_vendor_oui_action_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_config_vendor_oui_action_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_pdev_config_vendor_oui_action_fixed_param));
cmd->action_id = action_id;
cmd->total_num_vendor_oui = total_no_oui_extns;
cmd->num_vendor_oui_ext = no_oui_extns;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
no_oui_extns * sizeof(*cmd_ext));
buf_ptr += WMI_TLV_HDR_SIZE;
cmd_ext = (wmi_vendor_oui_ext *)buf_ptr;
wmi_fill_oui_extensions(req->extension, no_oui_extns, cmd_ext);
buf_ptr += no_oui_extns * sizeof(*cmd_ext);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, var_buf_len);
buf_ptr += WMI_TLV_HDR_SIZE;
status = wmi_fill_oui_extensions_buffer(req->extension,
cmd_ext, no_oui_extns,
rem_var_buf_len, buf_ptr);
if (!QDF_IS_STATUS_SUCCESS(status)) {
wmi_buf_free(wmi_buf);
wmi_buf = NULL;
wmi_err("failed to fill oui ext status %d", status);
return QDF_STATUS_E_INVAL;
}
buf_ptr += var_buf_len;
if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
WMI_PDEV_CONFIG_VENDOR_OUI_ACTION_CMDID)) {
wmi_err("WMI_PDEV_CONFIG_VENDOR_OUI_ACTION send fail");
wmi_buf_free(wmi_buf);
wmi_buf = NULL;
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}

227
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_apf_tlv.c Normal file
View File

@@ -0,0 +1,227 @@
/*
* Copyright (c) 2016-2020 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <wmi_unified_priv.h>
#include "wmi_unified_apf_tlv.h"
#include "wmi.h"
QDF_STATUS wmi_send_set_active_apf_mode_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t vdev_id,
enum wmi_host_active_apf_mode
ucast_mode,
enum wmi_host_active_apf_mode
mcast_bcast_mode)
{
const WMITLV_TAG_ID tag_id =
WMITLV_TAG_STRUC_wmi_bpf_set_vdev_active_mode_cmd_fixed_param;
const uint32_t tlv_len = WMITLV_GET_STRUCT_TLVLEN(
wmi_bpf_set_vdev_active_mode_cmd_fixed_param);
QDF_STATUS status;
wmi_bpf_set_vdev_active_mode_cmd_fixed_param *cmd;
wmi_buf_t buf;
wmi_debug("Sending WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID(%u, %d, %d)",
vdev_id, ucast_mode, mcast_bcast_mode);
/* allocate command buffer */
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_NOMEM;
}
/* set TLV header */
cmd = (wmi_bpf_set_vdev_active_mode_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header, tag_id, tlv_len);
/* populate data */
cmd->vdev_id = vdev_id;
cmd->uc_mode = ucast_mode;
cmd->mcbc_mode = mcast_bcast_mode;
/* send to FW */
status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID);
if (QDF_IS_STATUS_ERROR(status)) {
wmi_err("Failed to send WMI_BPF_SET_VDEV_ACTIVE_MODE_CMDID:%d",
status);
wmi_buf_free(buf);
return status;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS wmi_send_apf_enable_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t vdev_id,
bool enable)
{
wmi_bpf_set_vdev_enable_cmd_fixed_param *cmd;
wmi_buf_t buf;
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_bpf_set_vdev_enable_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bpf_set_vdev_enable_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_bpf_set_vdev_enable_cmd_fixed_param));
cmd->vdev_id = vdev_id;
cmd->is_enabled = enable;
if (wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_BPF_SET_VDEV_ENABLE_CMDID)) {
wmi_err("Failed to enable/disable APF interpreter");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
wmi_send_apf_write_work_memory_cmd_tlv(wmi_unified_t wmi_handle,
struct wmi_apf_write_memory_params
*apf_write_params)
{
wmi_bpf_set_vdev_work_memory_cmd_fixed_param *cmd;
uint32_t wmi_buf_len;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint32_t aligned_len = 0;
wmi_buf_len = sizeof(*cmd);
if (apf_write_params->length) {
aligned_len = roundup(apf_write_params->length,
sizeof(A_UINT32));
wmi_buf_len += WMI_TLV_HDR_SIZE + aligned_len;
}
buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
cmd = (wmi_bpf_set_vdev_work_memory_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bpf_set_vdev_work_memory_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_bpf_set_vdev_work_memory_cmd_fixed_param));
cmd->vdev_id = apf_write_params->vdev_id;
cmd->bpf_version = apf_write_params->apf_version;
cmd->program_len = apf_write_params->program_len;
cmd->addr_offset = apf_write_params->addr_offset;
cmd->length = apf_write_params->length;
if (apf_write_params->length) {
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
aligned_len);
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, apf_write_params->buf,
apf_write_params->length);
}
if (wmi_unified_cmd_send(wmi_handle, buf, wmi_buf_len,
WMI_BPF_SET_VDEV_WORK_MEMORY_CMDID)) {
wmi_err("Failed to write APF work memory");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
wmi_send_apf_read_work_memory_cmd_tlv(wmi_unified_t wmi_handle,
struct wmi_apf_read_memory_params
*apf_read_params)
{
wmi_bpf_get_vdev_work_memory_cmd_fixed_param *cmd;
wmi_buf_t buf;
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_bpf_get_vdev_work_memory_cmd_fixed_param *)
wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bpf_get_vdev_work_memory_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_bpf_get_vdev_work_memory_cmd_fixed_param));
cmd->vdev_id = apf_read_params->vdev_id;
cmd->addr_offset = apf_read_params->addr_offset;
cmd->length = apf_read_params->length;
if (wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_BPF_GET_VDEV_WORK_MEMORY_CMDID)) {
wmi_err("Failed to get APF work memory");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
wmi_extract_apf_read_memory_resp_event_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_apf_read_memory_resp_event_params
*resp)
{
WMI_BPF_GET_VDEV_WORK_MEMORY_RESP_EVENTID_param_tlvs *param_buf;
wmi_bpf_get_vdev_work_memory_resp_evt_fixed_param *data_event;
param_buf = evt_buf;
if (!param_buf) {
wmi_err("encrypt decrypt resp evt_buf is NULL");
return QDF_STATUS_E_INVAL;
}
data_event = param_buf->fixed_param;
resp->vdev_id = data_event->vdev_id;
resp->offset = data_event->offset;
resp->more_data = data_event->fragment;
if (data_event->length > param_buf->num_data) {
wmi_err("FW msg data_len %d more than TLV hdr %d",
data_event->length,
param_buf->num_data);
return QDF_STATUS_E_INVAL;
}
if (data_event->length && param_buf->data) {
resp->length = data_event->length;
resp->data = (uint8_t *)param_buf->data;
}
return QDF_STATUS_SUCCESS;
}

4135
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_api.c Normal file
View File

File diff suppressed because it is too large Load Diff

33
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_bcn_api.c Normal file
View File

@@ -0,0 +1,33 @@
/*
* Copyright (c) 2016-2019 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to concurrency component.
*/
#include "wmi_unified_bcn_api.h"
QDF_STATUS
wmi_unified_bcn_buf_ll_cmd(wmi_unified_t wmi_handle,
wmi_bcn_send_from_host_cmd_fixed_param *param)
{
if (wmi_handle->ops->send_bcn_buf_ll_cmd)
return wmi_handle->ops->send_bcn_buf_ll_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}

70
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_bcn_tlv.c Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright (c) 2016-2020 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include "wmi_unified_bcn_api.h"
/**
* send_bcn_buf_ll_cmd_tlv() - prepare and send beacon buffer to fw for LL
* @wmi_handle: wmi handle
* @param: bcn ll cmd parameter
*
* Return: QDF_STATUS_SUCCESS for success otherwise failure
*/
static QDF_STATUS send_bcn_buf_ll_cmd_tlv(
wmi_unified_t wmi_handle,
wmi_bcn_send_from_host_cmd_fixed_param *param)
{
wmi_bcn_send_from_host_cmd_fixed_param *cmd;
wmi_buf_t wmi_buf;
QDF_STATUS ret;
wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!wmi_buf)
return QDF_STATUS_E_FAILURE;
cmd = (wmi_bcn_send_from_host_cmd_fixed_param *)wmi_buf_data(wmi_buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bcn_send_from_host_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_bcn_send_from_host_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->data_len = param->data_len;
cmd->frame_ctrl = param->frame_ctrl;
cmd->frag_ptr = param->frag_ptr;
cmd->dtim_flag = param->dtim_flag;
wmi_mtrace(WMI_PDEV_SEND_BCN_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
WMI_PDEV_SEND_BCN_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send WMI_PDEV_SEND_BCN_CMDID command");
wmi_buf_free(wmi_buf);
}
return ret;
}
void wmi_bcn_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_bcn_buf_ll_cmd = send_bcn_buf_ll_cmd_tlv;
}

94
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_cfr_api.c Normal file
View File

@@ -0,0 +1,94 @@
/*
* Copyright (c) 2019-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_unified_priv.h"
#include "wmi_unified_cfr_api.h"
#ifdef WLAN_CFR_ENABLE
QDF_STATUS wmi_unified_send_peer_cfr_capture_cmd(wmi_unified_t wmi_handle,
struct peer_cfr_params *param)
{
if (wmi_handle->ops->send_peer_cfr_capture_cmd)
return wmi_handle->ops->send_peer_cfr_capture_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_cfr_peer_tx_event_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_cfr_peer_tx_event_param *peer_tx_event)
{
if (wmi_handle->ops->extract_cfr_peer_tx_event_param)
return wmi_handle->ops->extract_cfr_peer_tx_event_param(
wmi_handle,
evt_buf,
peer_tx_event);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_ENH_CFR_ENABLE
QDF_STATUS wmi_unified_send_cfr_rcc_cmd(wmi_unified_t wmi_handle,
struct cfr_rcc_param *cfg)
{
if (wmi_handle->ops->send_cfr_rcc_cmd)
return wmi_handle->ops->send_cfr_rcc_cmd(wmi_handle, cfg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_cfr_pdev_phase_delta_event(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_cfr_phase_delta_param *param)
{
if (wmi_handle->ops->extract_cfr_phase_param)
return wmi_handle->ops->extract_cfr_phase_param(wmi_handle,
evt_buf,
param);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_RCC_ENHANCED_AOA_SUPPORT
QDF_STATUS
wmi_extract_cfr_pdev_enhanced_aoa_phasedelta_event_fixed_param(
wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_cfr_enh_phase_delta_param *param)
{
if (wmi_handle->ops->extract_cfr_enh_phase_fixed_param)
return wmi_handle->ops->extract_cfr_enh_phase_fixed_param
(wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_cfr_pdev_enhanced_aoa_phasedelta_event_data(
wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_cfr_enh_phase_delta_param *param)
{
if (wmi_handle->ops->extract_cfr_enh_phase_data)
return wmi_handle->ops->extract_cfr_enh_phase_data(wmi_handle,
evt_buf,
param);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_RCC_ENHANCED_AOA_SUPPORT */
#endif /* WLAN_ENH_CFR_ENABLE */
#endif /* WLAN_CFR_ENABLE */

481
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_cfr_tlv.c Normal file
View File

@@ -0,0 +1,481 @@
/*
* Copyright (c) 2019-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include "wmi.h"
#include "wmi_unified_priv.h"
#include "wmi_unified_cfr_param.h"
#include "wmi_unified_cfr_api.h"
#ifdef WLAN_CFR_ENABLE
static QDF_STATUS
extract_cfr_peer_tx_event_param_tlv(wmi_unified_t wmi_handle, void *evt_buf,
wmi_cfr_peer_tx_event_param *peer_tx_event)
{
int idx;
WMI_PEER_CFR_CAPTURE_EVENTID_param_tlvs *param_buf;
wmi_peer_cfr_capture_event_fixed_param *peer_tx_event_ev;
wmi_peer_cfr_capture_event_phase_fixed_param *chain_phase_ev;
param_buf = (WMI_PEER_CFR_CAPTURE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid cfr capture buffer");
return QDF_STATUS_E_INVAL;
}
peer_tx_event_ev = param_buf->fixed_param;
if (!peer_tx_event_ev) {
wmi_err("peer cfr capture buffer is null");
return QDF_STATUS_E_NULL_VALUE;
}
peer_tx_event->capture_method = peer_tx_event_ev->capture_method;
peer_tx_event->vdev_id = peer_tx_event_ev->vdev_id;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&peer_tx_event_ev->mac_addr,
&peer_tx_event->peer_mac_addr.bytes[0]);
peer_tx_event->primary_20mhz_chan =
peer_tx_event_ev->chan_mhz;
peer_tx_event->bandwidth = peer_tx_event_ev->bandwidth;
peer_tx_event->phy_mode = peer_tx_event_ev->phy_mode;
peer_tx_event->band_center_freq1 = peer_tx_event_ev->band_center_freq1;
peer_tx_event->band_center_freq2 = peer_tx_event_ev->band_center_freq2;
peer_tx_event->spatial_streams = peer_tx_event_ev->sts_count;
peer_tx_event->correlation_info_1 =
peer_tx_event_ev->correlation_info_1;
peer_tx_event->correlation_info_2 =
peer_tx_event_ev->correlation_info_2;
peer_tx_event->status = peer_tx_event_ev->status;
peer_tx_event->timestamp_us = peer_tx_event_ev->timestamp_us;
peer_tx_event->counter = peer_tx_event_ev->counter;
qdf_mem_copy(peer_tx_event->chain_rssi, peer_tx_event_ev->chain_rssi,
sizeof(peer_tx_event->chain_rssi));
if (peer_tx_event_ev->cfo_measurement_valid)
peer_tx_event->cfo_measurement =
peer_tx_event_ev->cfo_measurement;
else
peer_tx_event->cfo_measurement = 0;
peer_tx_event->rx_start_ts = peer_tx_event_ev->rx_start_ts;
peer_tx_event->rx_ts_reset = peer_tx_event_ev->rx_ts_reset;
peer_tx_event->mcs_rate =
WMI_CFR_MCS_GET(peer_tx_event_ev->mcs_gi_info);
peer_tx_event->gi_type =
WMI_CFR_GI_TYPE_GET(peer_tx_event_ev->mcs_gi_info);
chain_phase_ev = param_buf->phase_param;
if (chain_phase_ev) {
for (idx = 0; idx < WMI_HOST_MAX_CHAINS; idx++) {
/* Due to FW's alignment rules, phase information being
* passed is 32-bit, out of which only 16 bits is valid.
* Remaining bits are all zeroed. So direct mem copy
* will not work as it will copy extra zeroes into host
* structures.
*/
peer_tx_event->chain_phase[idx] =
(0xffff & chain_phase_ev->chain_phase[idx]);
peer_tx_event->agc_gain[idx] =
WMI_UNIFIED_AGC_GAIN_GET(chain_phase_ev, idx);
peer_tx_event->agc_gain_tbl_index[idx] =
WMI_UNIFIED_AGC_GAIN_TBL_IDX_GET(chain_phase_ev,
idx);
}
}
return QDF_STATUS_SUCCESS;
}
#ifdef WLAN_ENH_CFR_ENABLE
static void populate_wmi_cfr_param(uint8_t grp_id, struct cfr_rcc_param *rcc,
wmi_cfr_filter_group_config *param)
{
struct ta_ra_cfr_cfg *tgt_cfg = NULL;
WMITLV_SET_HDR(&param->tlv_header,
WMITLV_TAG_STRUC_wmi_cfr_filter_group_config,
WMITLV_GET_STRUCT_TLVLEN
(wmi_cfr_filter_group_config));
tgt_cfg = &rcc->curr[grp_id];
param->filter_group_id = grp_id;
WMI_CFR_GROUP_TA_ADDR_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_ta);
WMI_CFR_GROUP_TA_ADDR_MASK_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_ta_mask);
WMI_CFR_GROUP_RA_ADDR_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_ra);
WMI_CFR_GROUP_RA_ADDR_MASK_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_ra_mask);
WMI_CFR_GROUP_BW_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_bw_mask);
WMI_CFR_GROUP_NSS_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_nss_mask);
WMI_CFR_GROUP_MGMT_SUBTYPE_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_mgmt_subtype);
WMI_CFR_GROUP_CTRL_SUBTYPE_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_ctrl_subtype);
WMI_CFR_GROUP_DATA_SUBTYPE_VALID_SET(param->filter_set_valid_mask,
tgt_cfg->valid_data_subtype);
WMI_CHAR_ARRAY_TO_MAC_ADDR(tgt_cfg->tx_addr,
&param->ta_addr);
WMI_CHAR_ARRAY_TO_MAC_ADDR(tgt_cfg->tx_addr_mask,
&param->ta_addr_mask);
WMI_CHAR_ARRAY_TO_MAC_ADDR(tgt_cfg->rx_addr,
&param->ra_addr);
WMI_CHAR_ARRAY_TO_MAC_ADDR(tgt_cfg->rx_addr_mask,
&param->ra_addr_mask);
WMI_CFR_GROUP_BW_SET(param->bw_nss_filter,
tgt_cfg->bw);
WMI_CFR_GROUP_NSS_SET(param->bw_nss_filter,
tgt_cfg->nss);
param->mgmt_subtype_filter = tgt_cfg->mgmt_subtype_filter;
param->ctrl_subtype_filter = tgt_cfg->ctrl_subtype_filter;
param->data_subtype_filter = tgt_cfg->data_subtype_filter;
}
static QDF_STATUS send_cfr_rcc_cmd_tlv(wmi_unified_t wmi_handle,
struct cfr_rcc_param *rcc)
{
wmi_cfr_capture_filter_cmd_fixed_param *cmd;
wmi_cfr_filter_group_config *param;
uint8_t *buf_ptr, grp_id;
wmi_buf_t buf;
uint32_t len;
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct wmi_ops *ops = wmi_handle->ops;
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
len += rcc->num_grp_tlvs * sizeof(wmi_cfr_filter_group_config);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
cmd = (wmi_cfr_capture_filter_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_cfr_capture_filter_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_cfr_capture_filter_cmd_fixed_param));
cmd->pdev_id = ops->convert_host_pdev_id_to_target(wmi_handle,
rcc->pdev_id);
WMI_CFR_CAPTURE_INTERVAL_SET(cmd->capture_interval,
rcc->capture_interval);
WMI_CFR_CAPTURE_DURATION_SET(cmd->capture_duration,
rcc->capture_duration);
WMI_CFR_CAPTURE_COUNT_SET(cmd->capture_count, rcc->capture_count);
WMI_CFR_CAPTURE_INTERVAL_MODE_SEL_SET(cmd->capture_count,
rcc->capture_intval_mode_sel);
WMI_CFR_FILTER_GROUP_BITMAP_SET(cmd->filter_group_bitmap,
rcc->filter_group_bitmap);
WMI_CFR_UL_MU_USER_UPPER_SET(cmd->ul_mu_user_mask_upper,
rcc->ul_mu_user_mask_upper);
cmd->ul_mu_user_mask_lower = rcc->ul_mu_user_mask_lower;
WMI_CFR_FREEZE_DELAY_CNT_EN_SET(cmd->freeze_tlv_delay_cnt,
rcc->freeze_tlv_delay_cnt_en);
WMI_CFR_FREEZE_DELAY_CNT_THR_SET(cmd->freeze_tlv_delay_cnt,
rcc->freeze_tlv_delay_cnt_thr);
WMI_CFR_DIRECTED_FTM_ACK_EN_SET(cmd->filter_type,
rcc->m_directed_ftm);
WMI_CFR_ALL_FTM_ACK_EN_SET(cmd->filter_type,
rcc->m_all_ftm_ack);
WMI_CFR_NDPA_NDP_DIRECTED_EN_SET(cmd->filter_type,
rcc->m_ndpa_ndp_directed);
WMI_CFR_NDPA_NDP_ALL_EN_SET(cmd->filter_type,
rcc->m_ndpa_ndp_all);
WMI_CFR_TA_RA_TYPE_FILTER_EN_SET(cmd->filter_type,
rcc->m_ta_ra_filter);
WMI_CFR_FILTER_IN_AS_FP_TA_RA_TYPE_SET(cmd->filter_type,
rcc->en_ta_ra_filter_in_as_fp);
WMI_CFR_ALL_PACKET_EN_SET(cmd->filter_type,
rcc->m_all_packet);
/* TLV indicating array of structures to follow */
buf_ptr += sizeof(wmi_cfr_capture_filter_cmd_fixed_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
rcc->num_grp_tlvs * sizeof(wmi_cfr_filter_group_config));
if (rcc->num_grp_tlvs) {
buf_ptr += WMI_TLV_HDR_SIZE;
param = (wmi_cfr_filter_group_config *)buf_ptr;
for (grp_id = 0; grp_id < MAX_TA_RA_ENTRIES; grp_id++) {
if (qdf_test_bit(grp_id,
&rcc->modified_in_curr_session)) {
populate_wmi_cfr_param(grp_id, rcc, param);
param++;
}
}
}
status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_CFR_CAPTURE_FILTER_CMDID);
if (status)
wmi_buf_free(buf);
return status;
}
static QDF_STATUS
extract_cfr_phase_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_cfr_phase_delta_param *param)
{
WMI_PDEV_AOA_PHASEDELTA_EVENTID_param_tlvs *param_buf;
wmi_pdev_aoa_phasedelta_evt_fixed_param *phase_event;
param_buf = (WMI_PDEV_AOA_PHASEDELTA_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid cfr aoa phase delta buffer");
return QDF_STATUS_E_INVAL;
}
phase_event = param_buf->fixed_param;
if (!phase_event) {
wmi_err("CFR phase AoA delta buffer is NULL");
return QDF_STATUS_E_NULL_VALUE;
}
param->freq = phase_event->freq;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host
(wmi_handle, phase_event->pdev_id);
param->max_chains = phase_event->chainInfo & 0xFFFF;
param->chain_phase_mask = (phase_event->chainInfo >> 16) & 0xFFFF;
if ((sizeof(param->ibf_cal_val)) <
(sizeof(phase_event->perChainIbfCalVal))) {
wmi_err("ibf_cal_val can not hold all values from event data");
return QDF_STATUS_E_RANGE;
}
if ((sizeof(param->phase_delta)) <
(sizeof(phase_event->phasedelta))) {
wmi_err("phase_delta can not hold all values from event data");
return QDF_STATUS_E_RANGE;
}
qdf_mem_copy(param->ibf_cal_val,
phase_event->perChainIbfCalVal,
sizeof(param->ibf_cal_val));
qdf_mem_copy(param->phase_delta,
phase_event->phasedelta,
sizeof(param->phase_delta));
return QDF_STATUS_SUCCESS;
}
#ifdef WLAN_RCC_ENHANCED_AOA_SUPPORT
static QDF_STATUS
extract_cfr_enh_phase_fixed_param_tlv
(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_cfr_enh_phase_delta_param *param)
{
WMI_PDEV_ENHANCED_AOA_PHASEDELTA_EVENTID_param_tlvs *ev_buf;
wmi_pdev_enhanced_aoa_phasedelta_evt_fixed_param *fixed_param;
ev_buf = (WMI_PDEV_ENHANCED_AOA_PHASEDELTA_EVENTID_param_tlvs *)evt_buf;
if (!ev_buf) {
wmi_err("Invalid cfr enh aoa phase delta event buffer");
return QDF_STATUS_E_INVAL;
}
fixed_param = ev_buf->fixed_param;
if (!fixed_param) {
wmi_err("cfr enh aoa event fixed_param is NULL");
return QDF_STATUS_E_NULL_VALUE;
}
param->freq = fixed_param->freq;
param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host
(wmi_handle, fixed_param->pdev_id);
param->max_chains =
WMI_AOA_MAX_SUPPORTED_CHAINS_GET(fixed_param->chain_info);
param->data_for_chainmask =
WMI_AOA_SUPPORTED_CHAINMASK_GET(fixed_param->chain_info);
param->xbar_config = fixed_param->xbar_config;
if (sizeof(param->ibf_cal_val) <
sizeof(fixed_param->per_chain_ibf_cal_val)) {
wmi_err("ibf_cal_val can not hold all values from event data");
return QDF_STATUS_E_RANGE;
}
qdf_mem_copy(param->ibf_cal_val, fixed_param->per_chain_ibf_cal_val,
QDF_MIN(sizeof(param->ibf_cal_val),
sizeof(fixed_param->per_chain_ibf_cal_val)));
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
populate_enhanced_aoa_data(uint32_t *dst_array, uint32_t *src_array,
wmi_enhanced_aoa_gain_phase_data_hdr *data_hdr,
uint32_t offset, uint32_t dst_size)
{
uint32_t src_size = WMI_AOA_NUM_ENTIRES_GET(data_hdr->data_info) *
sizeof(uint32_t);
if (src_size > dst_size) {
wmi_err("the amount of data can not fit in the host array");
return QDF_STATUS_E_RANGE;
}
qdf_mem_copy(dst_array, src_array + offset, src_size);
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
extract_cfr_enh_phase_data_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_cfr_enh_phase_delta_param *param)
{
WMI_PDEV_ENHANCED_AOA_PHASEDELTA_EVENTID_param_tlvs *ev_buf;
wmi_enhanced_aoa_gain_phase_data_hdr *data_hdr;
QDF_STATUS status;
uint32_t *dst_array = NULL;
uint32_t i, offset = 0;
uint8_t data_type;
ev_buf = (WMI_PDEV_ENHANCED_AOA_PHASEDELTA_EVENTID_param_tlvs *)evt_buf;
if (!ev_buf) {
wmi_err("Invalid cfr enh aoa phase delta event buffer");
return QDF_STATUS_E_INVAL;
}
if (!ev_buf->aoa_data_hdr) {
wmi_err("data headers NULL.. investigate");
return QDF_STATUS_E_NULL_VALUE;
}
if (!ev_buf->aoa_data_buf) {
wmi_err("data bufs NULL.. investigate");
return QDF_STATUS_E_NULL_VALUE;
}
for (i = 0; i < ev_buf->num_aoa_data_hdr; i++) {
data_hdr = &ev_buf->aoa_data_hdr[i];
data_type = WMI_AOA_DATA_TYPE_GET(data_hdr->data_info);
if (data_type == WMI_PHASE_DELTA_ARRAY) {
dst_array = param->enh_phase_delta_array;
} else if (data_type == WMI_GAIN_GROUP_STOP_ARRAY) {
dst_array = param->gain_stop_index_array;
} else {
wmi_err("invalid aoa data type received");
return QDF_STATUS_E_INVAL;
}
status = populate_enhanced_aoa_data
(dst_array, ev_buf->aoa_data_buf,
data_hdr, offset, param->array_size);
if (status) {
wmi_err("error in populating aoa data");
return status;
}
offset += WMI_AOA_NUM_ENTIRES_GET(data_hdr->data_info);
}
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_RCC_ENHANCED_AOA_SUPPORT */
#endif /* WLAN_ENH_CFR_ENABLE */
static QDF_STATUS send_peer_cfr_capture_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_cfr_params *param)
{
wmi_peer_cfr_capture_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
int ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s:wmi_buf_alloc failed\n", __func__);
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_peer_cfr_capture_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_cfr_capture_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_cfr_capture_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->macaddr, &cmd->mac_addr);
cmd->request = param->request;
cmd->vdev_id = param->vdev_id;
cmd->periodicity = param->periodicity;
cmd->bandwidth = param->bandwidth;
cmd->capture_method = param->capture_method;
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_CFR_CAPTURE_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send WMI_PEER_CFR_CAPTURE_CMDID");
wmi_buf_free(buf);
}
return ret;
}
#ifdef WLAN_ENH_CFR_ENABLE
static inline void wmi_enh_cfr_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_cfr_rcc_cmd = send_cfr_rcc_cmd_tlv;
}
#else
static inline void wmi_enh_cfr_attach_tlv(wmi_unified_t wmi_handle)
{
}
#endif
#ifdef WLAN_RCC_ENHANCED_AOA_SUPPORT
static void wmi_cfr_attach_enh_aoa_tlv(struct wmi_ops *ops)
{
ops->extract_cfr_enh_phase_data = extract_cfr_enh_phase_data_tlv;
ops->extract_cfr_enh_phase_fixed_param =
extract_cfr_enh_phase_fixed_param_tlv;
}
#else
static void wmi_cfr_attach_enh_aoa_tlv(struct wmi_ops *ops)
{
}
#endif /* WLAN_RCC_ENHANCED_AOA_SUPPORT */
void wmi_cfr_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_peer_cfr_capture_cmd = send_peer_cfr_capture_cmd_tlv;
ops->extract_cfr_peer_tx_event_param =
extract_cfr_peer_tx_event_param_tlv;
ops->extract_cfr_phase_param = extract_cfr_phase_param_tlv;
wmi_cfr_attach_enh_aoa_tlv(ops);
wmi_enh_cfr_attach_tlv(wmi_handle);
}
#endif /* WLAN_CFR_ENABLE */

79
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_concurrency_api.c Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright (c) 2013-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to concurrency component.
*/
#include <wmi_unified_priv.h>
#include <wmi_unified_concurrency_api.h>
QDF_STATUS wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd(
wmi_unified_t wmi_handle, uint32_t mcc_adaptive_scheduler,
uint32_t pdev_id)
{
if (wmi_handle->ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd)
return wmi_handle->ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd(wmi_handle,
mcc_adaptive_scheduler, pdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_mcc_channel_time_latency_cmd(
wmi_unified_t wmi_handle,
uint32_t mcc_channel_freq, uint32_t mcc_channel_time_latency)
{
if (wmi_handle->ops->send_set_mcc_channel_time_latency_cmd)
return wmi_handle->ops->send_set_mcc_channel_time_latency_cmd(wmi_handle,
mcc_channel_freq,
mcc_channel_time_latency);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_mcc_channel_time_quota_cmd(
wmi_unified_t wmi_handle,
uint32_t adapter_1_chan_freq,
uint32_t adapter_1_quota, uint32_t adapter_2_chan_freq)
{
if (wmi_handle->ops->send_set_mcc_channel_time_quota_cmd)
return wmi_handle->ops->send_set_mcc_channel_time_quota_cmd(wmi_handle,
adapter_1_chan_freq,
adapter_1_quota,
adapter_2_chan_freq);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_MCC_QUOTA
QDF_STATUS wmi_extract_mcc_quota_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct mcc_quota_info *param)
{
if (!wmi_handle) {
wmi_err("wmi handle is null");
return QDF_STATUS_E_INVAL;
}
if (wmi_handle->ops->extract_mcc_quota_ev_param)
return wmi_handle->ops->extract_mcc_quota_ev_param(
wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
#endif

343
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_concurrency_tlv.c Normal file
View File

@@ -0,0 +1,343 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_concurrency_api.h>
#ifdef WLAN_FEATURE_MCC_QUOTA
#include <wlan_p2p_mcc_quota_public_struct.h>
#endif
/**
* send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv() -enable/disable
* mcc scheduler
* @wmi_handle: wmi handle
* @mcc_adaptive_scheduler: enable/disable
* @pdev_id: pdev identifier
*
* This function enable/disable mcc adaptive scheduler in fw.
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv(
wmi_unified_t wmi_handle, uint32_t mcc_adaptive_scheduler,
uint32_t pdev_id)
{
QDF_STATUS ret;
wmi_buf_t buf = 0;
wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param *cmd = NULL;
uint16_t len =
sizeof(wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param *)
wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param));
cmd->enable = mcc_adaptive_scheduler;
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
pdev_id);
wmi_mtrace(WMI_RESMGR_ADAPTIVE_OCS_ENABLE_DISABLE_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_RESMGR_ADAPTIVE_OCS_ENABLE_DISABLE_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send enable/disable MCC"
" adaptive scheduler command");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_set_mcc_channel_time_latency_cmd_tlv() -set MCC channel time latency
* @wmi_handle: wmi handle
* @mcc_channel_freq: mcc channel frequency in MHz
* @mcc_channel_time_latency: MCC channel time latency.
*
* Currently used to set time latency for an MCC vdev/adapter using operating
* channel of it and channel number. The info is provided run time using
* iwpriv command: iwpriv <wlan0 | p2p0> setMccLatency <latency in ms>.
*
* Return: QDF status
*/
static QDF_STATUS send_set_mcc_channel_time_latency_cmd_tlv(
wmi_unified_t wmi_handle,
uint32_t mcc_channel_freq,
uint32_t mcc_channel_time_latency)
{
QDF_STATUS ret;
wmi_buf_t buf = 0;
wmi_resmgr_set_chan_latency_cmd_fixed_param *cmdTL = NULL;
uint16_t len = 0;
uint8_t *buf_ptr = NULL;
wmi_resmgr_chan_latency chan_latency;
/* Note: we only support MCC time latency for a single channel */
uint32_t num_channels = 1;
uint32_t chan1_freq = mcc_channel_freq;
uint32_t latency_chan1 = mcc_channel_time_latency;
/* If 0ms latency is provided, then FW will set to a default.
* Otherwise, latency must be at least 30ms.
*/
if ((latency_chan1 > 0) &&
(latency_chan1 < WMI_MCC_MIN_NON_ZERO_CHANNEL_LATENCY)) {
wmi_err("Invalid time latency for Channel #1 = %dms "
"Minimum is 30ms (or 0 to use default value by "
"firmware)", latency_chan1);
return QDF_STATUS_E_INVAL;
}
/* Set WMI CMD for channel time latency here */
len = sizeof(wmi_resmgr_set_chan_latency_cmd_fixed_param) +
WMI_TLV_HDR_SIZE + /*Place holder for chan_time_latency array */
num_channels * sizeof(wmi_resmgr_chan_latency);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *) wmi_buf_data(buf);
cmdTL = (wmi_resmgr_set_chan_latency_cmd_fixed_param *)
wmi_buf_data(buf);
WMITLV_SET_HDR(&cmdTL->tlv_header,
WMITLV_TAG_STRUC_wmi_resmgr_set_chan_latency_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_resmgr_set_chan_latency_cmd_fixed_param));
cmdTL->num_chans = num_channels;
/* Update channel time latency information for home channel(s) */
buf_ptr += sizeof(*cmdTL);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
num_channels * sizeof(wmi_resmgr_chan_latency));
buf_ptr += WMI_TLV_HDR_SIZE;
chan_latency.chan_mhz = chan1_freq;
chan_latency.latency = latency_chan1;
qdf_mem_copy(buf_ptr, &chan_latency, sizeof(chan_latency));
wmi_mtrace(WMI_RESMGR_SET_CHAN_LATENCY_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_RESMGR_SET_CHAN_LATENCY_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send MCC Channel Time Latency command");
wmi_buf_free(buf);
QDF_ASSERT(0);
}
return ret;
}
/**
* send_set_mcc_channel_time_quota_cmd_tlv() -set MCC channel time quota
* @wmi_handle: wmi handle
* @adapter_1_chan_freq: adapter 1 channel frequency in MHz
* @adapter_1_quota: adapter 1 quota
* @adapter_2_chan_freq: adapter 2 channel frequency in MHz
*
* Return: QDF status
*/
static QDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(
wmi_unified_t wmi_handle,
uint32_t adapter_1_chan_freq,
uint32_t adapter_1_quota,
uint32_t adapter_2_chan_freq)
{
QDF_STATUS ret;
wmi_buf_t buf = 0;
uint16_t len = 0;
uint8_t *buf_ptr = NULL;
wmi_resmgr_set_chan_time_quota_cmd_fixed_param *cmdTQ = NULL;
wmi_resmgr_chan_time_quota chan_quota;
uint32_t quota_chan1 = adapter_1_quota;
/* Knowing quota of 1st chan., derive quota for 2nd chan. */
uint32_t quota_chan2 = 100 - quota_chan1;
/* Note: setting time quota for MCC requires info for 2 channels */
uint32_t num_channels = 2;
uint32_t chan1_freq = adapter_1_chan_freq;
uint32_t chan2_freq = adapter_2_chan_freq;
wmi_debug("freq1:%dMHz, Quota1:%dms, freq2:%dMHz, Quota2:%dms",
chan1_freq, quota_chan1, chan2_freq, quota_chan2);
/*
* Perform sanity check on time quota values provided.
*/
if (quota_chan1 < WMI_MCC_MIN_CHANNEL_QUOTA ||
quota_chan1 > WMI_MCC_MAX_CHANNEL_QUOTA) {
wmi_err("Invalid time quota for Chan #1=%dms. Min: %dms, Max: %dms",
quota_chan1, WMI_MCC_MIN_CHANNEL_QUOTA,
WMI_MCC_MAX_CHANNEL_QUOTA);
return QDF_STATUS_E_INVAL;
}
/* Set WMI CMD for channel time quota here */
len = sizeof(wmi_resmgr_set_chan_time_quota_cmd_fixed_param) +
WMI_TLV_HDR_SIZE + /* Place holder for chan_time_quota array */
num_channels * sizeof(wmi_resmgr_chan_time_quota);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *) wmi_buf_data(buf);
cmdTQ = (wmi_resmgr_set_chan_time_quota_cmd_fixed_param *)
wmi_buf_data(buf);
WMITLV_SET_HDR(&cmdTQ->tlv_header,
WMITLV_TAG_STRUC_wmi_resmgr_set_chan_time_quota_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_resmgr_set_chan_time_quota_cmd_fixed_param));
cmdTQ->num_chans = num_channels;
/* Update channel time quota information for home channel(s) */
buf_ptr += sizeof(*cmdTQ);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
num_channels * sizeof(wmi_resmgr_chan_time_quota));
buf_ptr += WMI_TLV_HDR_SIZE;
chan_quota.chan_mhz = chan1_freq;
chan_quota.channel_time_quota = quota_chan1;
qdf_mem_copy(buf_ptr, &chan_quota, sizeof(chan_quota));
/* Construct channel and quota record for the 2nd MCC mode. */
buf_ptr += sizeof(chan_quota);
chan_quota.chan_mhz = chan2_freq;
chan_quota.channel_time_quota = quota_chan2;
qdf_mem_copy(buf_ptr, &chan_quota, sizeof(chan_quota));
wmi_mtrace(WMI_RESMGR_SET_CHAN_TIME_QUOTA_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_RESMGR_SET_CHAN_TIME_QUOTA_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send MCC Channel Time Quota command");
wmi_buf_free(buf);
QDF_ASSERT(0);
}
return ret;
}
#ifdef WLAN_FEATURE_MCC_QUOTA
/**
* convert_to_host_quota_type() - convert wmi quota type to host quota type
* @quota_type: wmi target quota type
*
* Return: enum mcc_quota_type
*/
static enum mcc_quota_type convert_to_host_quota_type(uint32_t quota_type)
{
switch (quota_type) {
case WMI_RESMGR_QUOTA_TYPE_CLEAR:
return QUOTA_TYPE_CLEAR;
case WMI_RESMGR_QUOTA_TYPE_FIXED:
return QUOTA_TYPE_FIXED;
case WMI_RESMGR_QUOTA_TYPE_DYNAMIC:
return QUOTA_TYPE_DYNAMIC;
default:
wmi_err("mcc quota unknown quota type %d", quota_type);
return QUOTA_TYPE_UNKNOWN;
}
}
/**
* extract_mcc_quota_ev_param_tlv() - extract mcc quota information from wmi
* event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold mcc quota info
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
extract_mcc_quota_ev_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf, struct mcc_quota_info *param)
{
WMI_RESMGR_CHAN_TIME_QUOTA_CHANGED_EVENTID_param_tlvs *param_tlvs;
wmi_resmgr_chan_time_quota_changed_event_fixed_param *fixed_param;
uint8_t i;
wmi_resmgr_chan_time_quota_tlv *wmi_mcc_quota_info;
if (!param) {
wmi_err("mcc quota information param is null");
return QDF_STATUS_E_INVAL;
}
param_tlvs = evt_buf;
if (!param_tlvs || !param_tlvs->fixed_param) {
wmi_err("Invalid mcc quota event buffer");
return QDF_STATUS_E_INVAL;
}
fixed_param = param_tlvs->fixed_param;
wmi_debug("mcc quota type %d, num %d",
fixed_param->quota_type, param_tlvs->num_chan_quota);
param->type = convert_to_host_quota_type(fixed_param->quota_type);
if (param->type == QUOTA_TYPE_UNKNOWN)
return QDF_STATUS_E_INVAL;
if (!param_tlvs->chan_quota) {
param->num_chan_quota = 0;
return QDF_STATUS_SUCCESS;
}
if (param_tlvs->num_chan_quota > MAX_MCC_QUOTA_CH_NUM)
wmi_warn("mcc quota num %d unexpected",
param_tlvs->num_chan_quota);
param->num_chan_quota = qdf_min(param_tlvs->num_chan_quota,
(uint32_t)MAX_MCC_QUOTA_CH_NUM);
wmi_mcc_quota_info = param_tlvs->chan_quota;
for (i = 0; i < param->num_chan_quota; i++) {
param->chan_quota[i].chan_mhz =
wmi_mcc_quota_info[i].chan_time_quota.chan_mhz;
param->chan_quota[i].channel_time_quota =
wmi_mcc_quota_info[i].chan_time_quota.channel_time_quota;
wmi_debug("mcc quota [%d] chan %d, quota %d",
i, param->chan_quota[i].chan_mhz,
param->chan_quota[i].channel_time_quota);
}
return QDF_STATUS_SUCCESS;
}
static void wmi_mcc_quota_evt_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->extract_mcc_quota_ev_param = extract_mcc_quota_ev_param_tlv;
}
#else
static inline void wmi_mcc_quota_evt_attach_tlv(wmi_unified_t wmi_handle)
{
}
#endif
void wmi_concurrency_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd =
send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv;
ops->send_set_mcc_channel_time_latency_cmd =
send_set_mcc_channel_time_latency_cmd_tlv;
ops->send_set_mcc_channel_time_quota_cmd =
send_set_mcc_channel_time_quota_cmd_tlv;
wmi_mcc_quota_evt_attach_tlv(wmi_handle);
}

147
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_cp_stats_api.c Normal file
View File

@@ -0,0 +1,147 @@
/*
* Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021,2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to cp stats component.
*/
#include "wmi_unified_priv.h"
#include "wmi_unified_param.h"
#include "wmi_unified_cp_stats_api.h"
#if defined(WLAN_SUPPORT_INFRA_CTRL_PATH_STATS) || \
defined(WLAN_CONFIG_TELEMETRY_AGENT)
QDF_STATUS
wmi_unified_infra_cp_stats_request_send(wmi_unified_t wmi_handle,
struct infra_cp_stats_cmd_info *param)
{
if (wmi_handle->ops->send_infra_cp_stats_request_cmd)
return wmi_handle->ops->send_infra_cp_stats_request_cmd(
wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_extract_infra_cp_stats(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t evt_buf_len,
struct infra_cp_stats_event *params)
{
if (wmi_handle->ops->extract_infra_cp_stats)
return wmi_handle->ops->extract_infra_cp_stats(wmi_handle,
evt_buf,
evt_buf_len,
params);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_SUPPORT_INFRA_CTRL_PATH_STATS */
QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param)
{
if (wmi_handle->ops->send_stats_request_cmd)
return wmi_handle->ops->send_stats_request_cmd(wmi_handle,
macaddr, param);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_BIG_DATA_STATS
QDF_STATUS
wmi_unified_big_data_stats_request_send(wmi_unified_t wmi_handle,
struct stats_request_params *param)
{
if (wmi_handle->ops->send_big_data_stats_request_cmd)
return wmi_handle->ops->send_big_data_stats_request_cmd(
wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS
wmi_extract_stats_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param)
{
if (wmi_handle->ops->extract_all_stats_count)
return wmi_handle->ops->extract_all_stats_count(wmi_handle,
evt_buf, stats_param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_pdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_pdev_stats *pdev_stats)
{
if (wmi_handle->ops->extract_pdev_stats)
return wmi_handle->ops->extract_pdev_stats(wmi_handle,
evt_buf, index, pdev_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_vdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats)
{
if (wmi_handle->ops->extract_vdev_stats)
return wmi_handle->ops->extract_vdev_stats(wmi_handle,
evt_buf, index, vdev_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_peer_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats *peer_stats)
{
if (wmi_handle->ops->extract_peer_stats)
return wmi_handle->ops->extract_peer_stats(wmi_handle,
evt_buf, index, peer_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_peer_extd_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats)
{
if (wmi_handle->ops->extract_peer_extd_stats)
return wmi_handle->ops->extract_peer_extd_stats(wmi_handle,
evt_buf, index, peer_extd_stats);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_SON
QDF_STATUS
wmi_extract_inst_rssi_stats_resp(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_inst_rssi_stats_resp *inst_rssi_resp)
{
if (wmi_handle->ops->extract_inst_rssi_stats_resp)
return wmi_handle->ops->extract_inst_rssi_stats_resp(
wmi_handle, evt_buf, inst_rssi_resp);
return QDF_STATUS_E_FAILURE;
}
#endif

1267
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_cp_stats_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

45
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_crypto_api.c Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright (c) 2021, The Linux Foundation. All rights reserved.
* Copyright (c) 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to crypto component.
*/
#include "wmi_unified_priv.h"
#include "wmi_unified_param.h"
#include "wmi_unified_crypto_api.h"
QDF_STATUS
wmi_extract_install_key_comp_event(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t len,
struct wmi_install_key_comp_event *param)
{
if (wmi_handle->ops->extract_install_key_comp_event)
return wmi_handle->ops->extract_install_key_comp_event(
wmi_handle, evt_buf, len, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_send_vdev_set_ltf_key_seed_cmd(wmi_unified_t wmi,
struct wlan_crypto_ltf_keyseed_data *data)
{
if (wmi->ops->send_vdev_set_ltf_key_seed_cmd)
return wmi->ops->send_vdev_set_ltf_key_seed_cmd(wmi, data);
return QDF_STATUS_E_FAILURE;
}

95
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_dbr_api.c Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright (c) 2016-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_unified_priv.h"
#include "qdf_module.h"
QDF_STATUS wmi_unified_dbr_ring_cfg(wmi_unified_t wmi_handle,
struct direct_buf_rx_cfg_req *cfg)
{
if (wmi_handle->ops->send_dbr_cfg_cmd)
return wmi_handle->ops->send_dbr_cfg_cmd(wmi_handle, cfg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dbr_buf_release_fixed(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct direct_buf_rx_rsp *param)
{
if (wmi_handle->ops->extract_dbr_buf_release_fixed)
return wmi_handle->ops->extract_dbr_buf_release_fixed(
wmi_handle,
evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dbr_buf_release_entry(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_entry *param)
{
if (wmi_handle->ops->extract_dbr_buf_release_entry)
return wmi_handle->ops->extract_dbr_buf_release_entry(
wmi_handle,
evt_buf, idx, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dbr_buf_metadata(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_metadata *param)
{
if (wmi_handle->ops->extract_dbr_buf_metadata)
return wmi_handle->ops->extract_dbr_buf_metadata(
wmi_handle,
evt_buf, idx, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dbr_buf_cv_metadata(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_cv_metadata *param)
{
if (wmi_handle->ops->extract_dbr_buf_cv_metadata)
return wmi_handle->ops->extract_dbr_buf_cv_metadata(
wmi_handle,
evt_buf, idx, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dbr_buf_cqi_metadata(
wmi_unified_t wmi_handle,
uint8_t *evt_buf, uint8_t idx,
struct direct_buf_rx_cqi_metadata *param)
{
if (wmi_handle->ops->extract_dbr_buf_cqi_metadata)
return wmi_handle->ops->extract_dbr_buf_cqi_metadata(
wmi_handle,
evt_buf, idx, param);
return QDF_STATUS_E_FAILURE;
}

308
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_dbr_tlv.c Normal file
View File

@@ -0,0 +1,308 @@
/*
* Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include "wmi.h"
#include "wmi_unified_priv.h"
#include "wmi_unified_dbr_param.h"
#include "wmi_unified_dbr_api.h"
/**
* send_dbr_cfg_cmd_tlv() - configure DMA rings for Direct Buf RX
* @wmi_handle: wmi handle
* @cfg: dma cfg req
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
static QDF_STATUS send_dbr_cfg_cmd_tlv(wmi_unified_t wmi_handle,
struct direct_buf_rx_cfg_req *cfg)
{
wmi_buf_t buf;
wmi_dma_ring_cfg_req_fixed_param *cmd;
QDF_STATUS ret;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_dma_ring_cfg_req_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_dma_ring_cfg_req_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_dma_ring_cfg_req_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_host_pdev_id_to_target(
wmi_handle,
cfg->pdev_id);
cmd->mod_id = cfg->mod_id;
cmd->base_paddr_lo = cfg->base_paddr_lo;
cmd->base_paddr_hi = cfg->base_paddr_hi;
cmd->head_idx_paddr_lo = cfg->head_idx_paddr_lo;
cmd->head_idx_paddr_hi = cfg->head_idx_paddr_hi;
cmd->tail_idx_paddr_lo = cfg->tail_idx_paddr_lo;
cmd->tail_idx_paddr_hi = cfg->tail_idx_paddr_hi;
cmd->num_elems = cfg->num_elems;
cmd->buf_size = cfg->buf_size;
cmd->num_resp_per_event = cfg->num_resp_per_event;
cmd->event_timeout_ms = cfg->event_timeout_ms;
wmi_debug("wmi_dma_ring_cfg_req_fixed_param pdev id %d mod id %d"
"base paddr lo %x base paddr hi %x head idx paddr lo %x"
"head idx paddr hi %x tail idx paddr lo %x"
"tail idx addr hi %x num elems %d buf size %d num resp %d"
"event timeout %d", cmd->pdev_id,
cmd->mod_id, cmd->base_paddr_lo, cmd->base_paddr_hi,
cmd->head_idx_paddr_lo, cmd->head_idx_paddr_hi,
cmd->tail_idx_paddr_lo, cmd->tail_idx_paddr_hi,
cmd->num_elems, cmd->buf_size, cmd->num_resp_per_event,
cmd->event_timeout_ms);
wmi_mtrace(WMI_PDEV_DMA_RING_CFG_REQ_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_DMA_RING_CFG_REQ_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err(":wmi cmd send failed");
wmi_buf_free(buf);
}
return ret;
}
static QDF_STATUS extract_scaling_params_service_ready_ext_tlv(
wmi_unified_t wmi_handle,
uint8_t *event, uint8_t idx,
struct wlan_psoc_host_spectral_scaling_params *param)
{
WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf;
wmi_spectral_bin_scaling_params *spectral_bin_scaling_params;
param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *)event;
if (!param_buf)
return QDF_STATUS_E_INVAL;
spectral_bin_scaling_params = &param_buf->wmi_bin_scaling_params[idx];
param->pdev_id = wmi_handle->ops->convert_target_pdev_id_to_host(
wmi_handle,
spectral_bin_scaling_params->pdev_id);
param->low_level_offset = spectral_bin_scaling_params->low_level_offset;
param->formula_id = spectral_bin_scaling_params->formula_id;
param->high_level_offset =
spectral_bin_scaling_params->high_level_offset;
param->rssi_thr = spectral_bin_scaling_params->rssi_thr;
param->default_agc_max_gain =
spectral_bin_scaling_params->default_agc_max_gain;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_dbr_buf_release_fixed_tlv(wmi_unified_t wmi_handle,
uint8_t *event, struct direct_buf_rx_rsp *param)
{
WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *param_buf;
wmi_dma_buf_release_fixed_param *ev;
param_buf = (WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *)event;
if (!param_buf)
return QDF_STATUS_E_INVAL;
ev = param_buf->fixed_param;
if (!ev)
return QDF_STATUS_E_INVAL;
param->pdev_id = wmi_handle->ops->convert_target_pdev_id_to_host(
wmi_handle,
ev->pdev_id);
param->mod_id = ev->mod_id;
if ((!param_buf->num_entries) ||
param_buf->num_entries < ev->num_buf_release_entry) {
wmi_err("actual num of buf release entries less than provided entries");
return QDF_STATUS_E_INVAL;
}
param->num_buf_release_entry = ev->num_buf_release_entry;
if (((!param_buf->num_meta_data) ||
param_buf->num_meta_data < ev->num_meta_data_entry) &&
((!param_buf->num_cv_meta_data) ||
param_buf->num_cv_meta_data < ev->num_meta_data_entry) &&
((!param_buf->num_cqi_meta_data) ||
param_buf->num_cqi_meta_data < ev->num_meta_data_entry)) {
wmi_err(" actual num of meta data entries less than provided entries");
return QDF_STATUS_E_INVAL;
}
param->num_meta_data_entry = param_buf->num_meta_data;
param->num_cv_meta_data_entry = param_buf->num_cv_meta_data;
param->num_cqi_meta_data_entry = param_buf->num_cqi_meta_data;
wmi_debug("pdev id %d mod id %d num buf release entry %d",
param->pdev_id, param->mod_id, param->num_buf_release_entry);
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_dbr_buf_release_entry_tlv(wmi_unified_t wmi_handle,
uint8_t *event, uint8_t idx, struct direct_buf_rx_entry *param)
{
WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *param_buf;
wmi_dma_buf_release_entry *entry;
param_buf = (WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *)event;
if (!param_buf)
return QDF_STATUS_E_INVAL;
entry = &param_buf->entries[idx];
if (!entry) {
wmi_err("Entry is NULL");
return QDF_STATUS_E_FAILURE;
}
wmi_debug("paddr_lo[%d] = %x", idx, entry->paddr_lo);
param->paddr_lo = entry->paddr_lo;
param->paddr_hi = entry->paddr_hi;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_dbr_buf_metadata_tlv(
wmi_unified_t wmi_handle, uint8_t *event,
uint8_t idx, struct direct_buf_rx_metadata *param)
{
WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *param_buf;
wmi_dma_buf_release_spectral_meta_data *entry;
param_buf = (WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *)event;
if (!param_buf)
return QDF_STATUS_E_INVAL;
entry = &param_buf->meta_data[idx];
if (!entry) {
wmi_err("Entry is NULL");
return QDF_STATUS_E_FAILURE;
}
qdf_mem_copy(param->noisefloor, entry->noise_floor,
qdf_min(sizeof(entry->noise_floor),
sizeof(param->noisefloor)));
param->reset_delay = entry->reset_delay;
param->cfreq1 = entry->freq1;
param->cfreq2 = entry->freq2;
param->ch_width = entry->ch_width;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_dbr_buf_cv_metadata_tlv(
wmi_unified_t wmi_handle, uint8_t *event,
uint8_t idx, struct direct_buf_rx_cv_metadata *param)
{
WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *param_buf;
wmi_dma_buf_release_cv_upload_meta_data *ev;
param_buf = (WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *)event;
if (!param_buf)
return QDF_STATUS_E_INVAL;
ev = &param_buf->cv_meta_data[idx];
if (!ev) {
wmi_err("CV metadata is NULL");
return QDF_STATUS_E_FAILURE;
}
param->is_valid = ev->is_valid;
param->fb_type = ev->fb_type;
param->asnr_len =
WMI_DMA_BUF_RELEASE_CV_UPLOAD_GET_ASNR_LENGTH(ev->asnr_params);
param->asnr_offset =
WMI_DMA_BUF_RELEASE_CV_UPLOAD_GET_ASNR_OFFSET(ev->asnr_params);
param->dsnr_len =
WMI_DMA_BUF_RELEASE_CV_UPLOAD_GET_DSNR_LENGTH(ev->dsnr_params);
param->dsnr_offset =
WMI_DMA_BUF_RELEASE_CV_UPLOAD_GET_DSNR_OFFSET(ev->dsnr_params);
WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_mac_address,
&param->peer_mac.bytes[0]);
param->fb_params = ev->fb_params;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_dbr_buf_cqi_metadata_tlv(
wmi_unified_t wmi_handle, uint8_t *event,
uint8_t idx, struct direct_buf_rx_cqi_metadata *param)
{
WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *param_buf;
wmi_dma_buf_release_cqi_upload_meta_data *ev;
uint16_t asnr_len, asnr_offset;
uint8_t num_users = 0;
uint8_t i;
param_buf = (WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID_param_tlvs *)event;
if (!param_buf)
return QDF_STATUS_E_INVAL;
ev = &param_buf->cqi_meta_data[idx];
if (!ev) {
wmi_err("CQI metadata is NULL");
return QDF_STATUS_E_FAILURE;
}
param->fb_params = ev->fb_params_cqi;
asnr_len =
WMI_DMA_BUF_RELEASE_CV_UPLOAD_GET_ASNR_LENGTH(ev->asnr_params);
asnr_offset =
WMI_DMA_BUF_RELEASE_CV_UPLOAD_GET_ASNR_OFFSET(ev->asnr_params);
for (i = 0; i < MAX_NUM_CQI_USERS_IN_STANDALONE_SND; i++) {
if (WMI_DMA_BUF_RELEASE_CQI_UPLOAD_GET_FB_PARAMS_IS_VALID(
param->fb_params, i)) {
WMI_DMA_BUF_RELEASE_CQI_UPLOAD_SET_FB_PARAMS_IS_VALID(
param->is_valid, 1, i);
param->user_info[i].asnr_len = asnr_len;
param->user_info[i].asnr_offset =
asnr_offset + CQI_USER_DATA_OFFSET(i);
param->user_info[i].fb_params =
WMI_DMA_BUF_RELEASE_CQI_UPLOAD_GET_FB_PARAMS_NC(
param->fb_params, i);
WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_mac_address[i],
&param->user_info[i].peer_mac.bytes[0]);
num_users++;
}
}
param->num_users = num_users;
return QDF_STATUS_SUCCESS;
}
void wmi_dbr_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_dbr_cfg_cmd = send_dbr_cfg_cmd_tlv;
ops->extract_dbr_buf_release_entry = extract_dbr_buf_release_entry_tlv;
ops->extract_dbr_buf_metadata = extract_dbr_buf_metadata_tlv;
ops->extract_dbr_buf_cv_metadata = extract_dbr_buf_cv_metadata_tlv;
ops->extract_dbr_buf_cqi_metadata = extract_dbr_buf_cqi_metadata_tlv;
ops->extract_dbr_buf_release_fixed = extract_dbr_buf_release_fixed_tlv;
ops->extract_scaling_params_service_ready_ext =
extract_scaling_params_service_ready_ext_tlv;
}

76
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_dcs_api.c Normal file
View File

@@ -0,0 +1,76 @@
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to DCS component.
*/
#include <wmi_unified_dcs_api.h>
QDF_STATUS wmi_extract_dcs_interference_type(
void *wmi_hdl,
void *evt_buf,
struct wlan_host_dcs_interference_param *param)
{
wmi_unified_t wmi = (wmi_unified_t)wmi_hdl;
if (wmi->ops->extract_dcs_interference_type) {
return wmi->ops->extract_dcs_interference_type(wmi,
evt_buf,
param);
}
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dcs_im_tgt_stats(
void *wmi_hdl,
void *evt_buf,
struct wlan_host_dcs_im_tgt_stats *wlan_stat)
{
wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl;
if (wmi_handle->ops->extract_dcs_im_tgt_stats) {
return wmi_handle->ops->extract_dcs_im_tgt_stats(wmi_handle,
evt_buf,
wlan_stat);
}
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dcs_awgn_info(wmi_unified_t wmi_hdl, void *evt_buf,
struct wlan_host_dcs_awgn_info *awgn_info)
{
if (wmi_hdl && wmi_hdl->ops->extract_dcs_awgn_info)
return wmi_hdl->ops->extract_dcs_awgn_info(wmi_hdl, evt_buf,
awgn_info);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_send_dcs_pdev_param(wmi_unified_t wmi_handle,
uint32_t pdev_idx,
bool is_host_pdev_id,
uint32_t dcs_enable)
{
struct pdev_params pparam;
qdf_mem_zero(&pparam, sizeof(pparam));
pparam.is_host_pdev_id = is_host_pdev_id;
pparam.param_id = wmi_pdev_param_dcs;
pparam.param_value = dcs_enable;
return wmi_unified_pdev_param_send(wmi_handle, &pparam, pdev_idx);
}

150
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_dcs_tlv.c Normal file
View File

@@ -0,0 +1,150 @@
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "osdep.h"
#include "wmi.h"
#include "wmi_unified_priv.h"
/**
* extract_dcs_interference_type_tlv() - extract dcs interference type
* from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold dcs interference param
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_dcs_interference_type_tlv(
wmi_unified_t wmi_handle,
void *evt_buf, struct wlan_host_dcs_interference_param *param)
{
WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *param_buf;
param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid dcs interference event buffer");
return QDF_STATUS_E_INVAL;
}
if (!param_buf->fixed_param) {
wmi_err("Invalid fixed param");
return QDF_STATUS_E_INVAL;
}
param->interference_type = param_buf->fixed_param->interference_type;
/* Just support tlv currently */
param->pdev_id = wmi_handle->ops->convert_target_pdev_id_to_host(
wmi_handle,
param_buf->fixed_param->pdev_id);
return QDF_STATUS_SUCCESS;
}
/**
* extract_dcs_im_tgt_stats_tlv() - extract dcs im target stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @wlan_stat: Pointer to hold wlan stats
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_dcs_im_tgt_stats_tlv(
wmi_unified_t wmi_handle,
void *evt_buf,
struct wlan_host_dcs_im_tgt_stats *wlan_stat)
{
WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *param_buf;
wlan_dcs_im_tgt_stats_t *ev;
param_buf = (WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid dcs interference event buffer");
return QDF_STATUS_E_INVAL;
}
ev = param_buf->wlan_stat;
if (!ev) {
wmi_err("Invalid wlan stat");
return QDF_STATUS_E_INVAL;
}
wlan_stat->reg_tsf32 = ev->reg_tsf32;
wlan_stat->last_ack_rssi = ev->last_ack_rssi;
wlan_stat->tx_waste_time = ev->tx_waste_time;
wlan_stat->rx_time = ev->rx_time;
wlan_stat->phyerr_cnt = ev->phyerr_cnt;
wlan_stat->mib_stats.listen_time = ev->listen_time;
wlan_stat->mib_stats.reg_tx_frame_cnt = ev->reg_tx_frame_cnt;
wlan_stat->mib_stats.reg_rx_frame_cnt = ev->reg_rx_frame_cnt;
wlan_stat->mib_stats.reg_rxclr_cnt = ev->reg_rxclr_cnt;
wlan_stat->mib_stats.reg_cycle_cnt = ev->reg_cycle_cnt;
wlan_stat->mib_stats.reg_rxclr_ext_cnt = ev->reg_rxclr_ext_cnt;
wlan_stat->mib_stats.reg_ofdm_phyerr_cnt = ev->reg_ofdm_phyerr_cnt;
wlan_stat->mib_stats.reg_cck_phyerr_cnt = ev->reg_cck_phyerr_cnt;
wlan_stat->chan_nf = ev->chan_nf;
wlan_stat->my_bss_rx_cycle_count = ev->my_bss_rx_cycle_count;
return QDF_STATUS_SUCCESS;
}
/*
* extract_dcs_awgn_info_tlv() - extract DCS AWGN interference from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param awgn_info: Pointer to hold cw interference
*
* Return: QDF_STATUS_SUCCESS for success or QDF_STATUS_E_* for error
*/
static QDF_STATUS
extract_dcs_awgn_info_tlv(wmi_unified_t wmi_handle, void *evt_buf,
struct wlan_host_dcs_awgn_info *awgn_info)
{
WMI_DCS_INTERFERENCE_EVENTID_param_tlvs *param_buf;
wmi_dcs_awgn_int_t *ev;
param_buf = evt_buf;
if (!param_buf)
return QDF_STATUS_E_INVAL;
ev = param_buf->awgn_int;
if (!ev) {
wmi_err("Invalid awgn info");
return QDF_STATUS_E_INVAL;
}
awgn_info->channel_width = wmi_map_ch_width(ev->channel_width);
awgn_info->center_freq = (qdf_freq_t)ev->chan_freq;
awgn_info->center_freq0 = (qdf_freq_t)ev->center_freq0;
awgn_info->center_freq1 = (qdf_freq_t)ev->center_freq1;
awgn_info->chan_bw_intf_bitmap = ev->chan_bw_interference_bitmap;
wmi_debug("width: %u, freq: %u, freq0: %u, freq1: %u, bitmap: 0x%x",
awgn_info->channel_width, awgn_info->center_freq,
awgn_info->center_freq0, awgn_info->center_freq1,
awgn_info->chan_bw_intf_bitmap);
return QDF_STATUS_SUCCESS;
}
void wmi_dcs_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->extract_dcs_interference_type = extract_dcs_interference_type_tlv;
ops->extract_dcs_im_tgt_stats = extract_dcs_im_tgt_stats_tlv;
ops->extract_dcs_awgn_info = extract_dcs_awgn_info_tlv;
}

127
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_dfs_api.c Normal file
View File

@@ -0,0 +1,127 @@
/*
* Copyright (c) 2017-2019, 2021 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to DFS component.
*/
#include <qdf_status.h>
#include <qdf_module.h>
#include <wmi_unified_api.h>
#include <wmi_unified_priv.h>
#include <wlan_objmgr_vdev_obj.h>
#include <wlan_dfs_utils_api.h>
#include <wmi_unified_dfs_api.h>
#include <init_deinit_lmac.h>
QDF_STATUS wmi_extract_dfs_cac_complete_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
uint32_t *vdev_id,
uint32_t len)
{
if (wmi_handle && wmi_handle->ops->extract_dfs_cac_complete_event)
return wmi_handle->ops->extract_dfs_cac_complete_event(
wmi_handle, evt_buf, vdev_id, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_dfs_cac_complete_event);
QDF_STATUS
wmi_extract_dfs_ocac_complete_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct vdev_adfs_complete_status *param)
{
if (wmi_handle && wmi_handle->ops->extract_dfs_ocac_complete_event)
return wmi_handle->ops->extract_dfs_ocac_complete_event(
wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_dfs_ocac_complete_event);
QDF_STATUS wmi_extract_dfs_radar_detection_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct radar_found_info *radar_found,
uint32_t len)
{
if (wmi_handle && wmi_handle->ops->extract_dfs_radar_detection_event)
return wmi_handle->ops->extract_dfs_radar_detection_event(
wmi_handle, evt_buf, radar_found, len);
return QDF_STATUS_E_FAILURE;
}
#ifdef MOBILE_DFS_SUPPORT
QDF_STATUS wmi_extract_wlan_radar_event_info(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct radar_event_info *wlan_radar_event,
uint32_t len)
{
if (wmi_handle->ops->extract_wlan_radar_event_info)
return wmi_handle->ops->extract_wlan_radar_event_info(
wmi_handle, evt_buf, wlan_radar_event, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_dfs_radar_detection_event);
#endif
#if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD)
QDF_STATUS wmi_send_usenol_pdev_param(wmi_unified_t wmi_handle, bool usenol,
struct wlan_objmgr_pdev *pdev)
{
struct pdev_params pparam;
int pdev_idx;
pdev_idx = lmac_get_pdev_idx(pdev);
if (pdev_idx < 0)
return QDF_STATUS_E_FAILURE;
qdf_mem_zero(&pparam, sizeof(pparam));
pparam.param_id = wmi_pdev_param_use_nol;
pparam.param_value = usenol;
return wmi_unified_pdev_param_send(wmi_handle, &pparam, pdev_idx);
}
QDF_STATUS
wmi_send_subchan_marking_pdev_param(wmi_unified_t wmi_handle,
bool subchanmark,
struct wlan_objmgr_pdev *pdev)
{
struct pdev_params pparam;
int pdev_idx;
pdev_idx = lmac_get_pdev_idx(pdev);
if (pdev_idx < 0)
return QDF_STATUS_E_FAILURE;
qdf_mem_zero(&pparam, sizeof(pparam));
pparam.param_id = wmi_pdev_param_sub_channel_marking;
pparam.param_value = subchanmark;
return wmi_unified_pdev_param_send(wmi_handle, &pparam, pdev_idx);
}
#endif

140
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_extscan_api.c Normal file
View File

@@ -0,0 +1,140 @@
/*
* Copyright (c) 2016-2019 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_unified_priv.h"
QDF_STATUS wmi_unified_reset_passpoint_network_list_cmd(
wmi_unified_t wmi_handle,
struct wifi_passpoint_req_param *req)
{
if (wmi_handle->ops->send_reset_passpoint_network_list_cmd)
return wmi_handle->ops->send_reset_passpoint_network_list_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_passpoint_network_list_cmd(
wmi_unified_t wmi_handle,
struct wifi_passpoint_req_param *req)
{
if (wmi_handle->ops->send_set_passpoint_network_list_cmd)
return wmi_handle->ops->send_set_passpoint_network_list_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_epno_network_list_cmd(
wmi_unified_t wmi_handle,
struct wifi_enhanced_pno_params *req)
{
if (wmi_handle->ops->send_set_epno_network_list_cmd)
return wmi_handle->ops->send_set_epno_network_list_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extscan_get_capabilities_cmd(
wmi_unified_t wmi_handle,
struct extscan_capabilities_params *pgetcapab)
{
if (wmi_handle->ops->send_extscan_get_capabilities_cmd)
return wmi_handle->ops->send_extscan_get_capabilities_cmd(wmi_handle,
pgetcapab);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extscan_get_cached_results_cmd(
wmi_unified_t wmi_handle,
struct extscan_cached_result_params *pcached_results)
{
if (wmi_handle->ops->send_extscan_get_cached_results_cmd)
return wmi_handle->ops->send_extscan_get_cached_results_cmd(wmi_handle,
pcached_results);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extscan_stop_change_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_capabilities_reset_params *reset_req)
{
if (wmi_handle->ops->send_extscan_stop_change_monitor_cmd)
return wmi_handle->ops->send_extscan_stop_change_monitor_cmd(wmi_handle,
reset_req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extscan_start_change_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_set_sig_changereq_params *psigchange)
{
if (wmi_handle->ops->send_extscan_start_change_monitor_cmd)
return wmi_handle->ops->send_extscan_start_change_monitor_cmd(wmi_handle,
psigchange);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extscan_stop_hotlist_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_bssid_hotlist_reset_params *photlist_reset)
{
if (wmi_handle->ops->send_extscan_stop_hotlist_monitor_cmd)
return wmi_handle->ops->send_extscan_stop_hotlist_monitor_cmd(wmi_handle,
photlist_reset);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extscan_start_hotlist_monitor_cmd(
wmi_unified_t wmi_handle,
struct extscan_bssid_hotlist_set_params *params)
{
if (wmi_handle->ops->send_extscan_start_hotlist_monitor_cmd)
return wmi_handle->ops->send_extscan_start_hotlist_monitor_cmd(wmi_handle,
params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_stop_extscan_cmd(
wmi_unified_t wmi_handle,
struct extscan_stop_req_params *pstopcmd)
{
if (wmi_handle->ops->send_stop_extscan_cmd)
return wmi_handle->ops->send_stop_extscan_cmd(wmi_handle,
pstopcmd);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_start_extscan_cmd(
wmi_unified_t wmi_handle,
struct wifi_scan_cmd_req_params *pstart)
{
if (wmi_handle->ops->send_start_extscan_cmd)
return wmi_handle->ops->send_start_extscan_cmd(wmi_handle,
pstart);
return QDF_STATUS_E_FAILURE;
}

1102
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_extscan_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

101
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_fwol_api.c Normal file
View File

@@ -0,0 +1,101 @@
/*
* Copyright (c) 2019-2021 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to fw offload component.
*/
#include "wmi_unified_priv.h"
#include "wlan_fwol_public_structs.h"
#include "wmi_unified_fwol_api.h"
#ifdef WLAN_FEATURE_ELNA
QDF_STATUS
wmi_unified_send_set_elna_bypass_cmd(struct wmi_unified *wmi_handle,
struct set_elna_bypass_request *req)
{
if (wmi_handle->ops->send_set_elna_bypass_cmd)
return wmi_handle->ops->send_set_elna_bypass_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_send_get_elna_bypass_cmd(struct wmi_unified *wmi_handle,
struct get_elna_bypass_request *req)
{
if (wmi_handle->ops->send_get_elna_bypass_cmd)
return wmi_handle->ops->send_get_elna_bypass_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_get_elna_bypass_resp(struct wmi_unified *wmi_handle, void *resp_buf,
struct get_elna_bypass_response *resp)
{
if (wmi_handle->ops->extract_get_elna_bypass_resp)
return wmi_handle->ops->extract_get_elna_bypass_resp(wmi_handle,
resp_buf,
resp);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_FEATURE_ELNA */
#ifdef WLAN_SEND_DSCP_UP_MAP_TO_FW
QDF_STATUS
wmi_unified_send_dscp_tip_map_cmd(struct wmi_unified *wmi_handle,
uint32_t *dscp_to_tid_map)
{
if (wmi_handle->ops->send_dscp_tid_map_cmd)
return wmi_handle->ops->send_dscp_tid_map_cmd(wmi_handle,
dscp_to_tid_map);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_SEND_DSCP_UP_MAP_TO_FW */
#ifdef WLAN_FEATURE_MDNS_OFFLOAD
QDF_STATUS
wmi_unified_send_set_mdns_config_cmd(struct wmi_unified *wmi_handle,
struct mdns_config_info *mdns_info)
{
if (wmi_handle->ops->send_set_mdns_config_cmd)
return wmi_handle->ops->send_set_mdns_config_cmd(wmi_handle,
mdns_info);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_FEATURE_MDNS_OFFLOAD */
#ifdef THERMAL_STATS_SUPPORT
QDF_STATUS
wmi_unified_send_get_thermal_stats_cmd(struct wmi_unified *wmi_handle,
enum thermal_stats_request_type req_type,
uint8_t temp_offset)
{
if (wmi_handle->ops->send_get_thermal_stats_cmd)
return wmi_handle->ops->send_get_thermal_stats_cmd(wmi_handle,
req_type,
temp_offset);
return QDF_STATUS_E_FAILURE;
}
#endif /* THERMAL_STATS_SUPPORT */

494
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_fwol_tlv.c Normal file
View File

@@ -0,0 +1,494 @@
/*
* Copyright (c) 2019-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "osdep.h"
#include "wmi.h"
#include "wmi_unified_priv.h"
#include "wlan_fwol_public_structs.h"
#include "wmi_unified_fwol_api.h"
#ifdef WLAN_FEATURE_ELNA
/**
* send_set_elna_bypass_cmd_tlv() - send set elna bypass cmd to fw
* @wmi_handle: wmi handle
* @req: set eLNA bypass request
*
* Send WMI_SET_ELNA_BYPASS_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_set_elna_bypass_cmd_tlv(wmi_unified_t wmi_handle,
struct set_elna_bypass_request *req)
{
wmi_buf_t buf;
wmi_set_elna_bypass_cmd_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_set_elna_bypass_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_set_elna_bypass_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_set_elna_bypass_cmd_fixed_param));
cmd->vdev_id = req->vdev_id;
cmd->en_dis = req->elna_mode;
wmi_mtrace(WMI_SET_ELNA_BYPASS_CMDID, req->vdev_id, req->elna_mode);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_SET_ELNA_BYPASS_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send set param command ret = %d", ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* send_get_elna_bypass_cmd_tlv() - send get elna bypass cmd to fw
* @wmi_handle: wmi handle
* @req: get eLNA bypass request
*
* Send WMI_GET_ELNA_BYPASS_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_get_elna_bypass_cmd_tlv(wmi_unified_t wmi_handle,
struct get_elna_bypass_request *req)
{
wmi_buf_t buf;
wmi_get_elna_bypass_cmd_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_get_elna_bypass_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_get_elna_bypass_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_get_elna_bypass_cmd_fixed_param));
cmd->vdev_id = req->vdev_id;
wmi_mtrace(WMI_GET_ELNA_BYPASS_CMDID, req->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_GET_ELNA_BYPASS_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send set param command ret = %d", ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* extract_get_elna_bypass_resp_tlv() - Extract WMI get eLNA bypass response
* @wmi_handle: wmi handle
* @resp_buf: response buffer
* @resp: get eLNA bypass response
*
* Extract WMI get eLNA bypass response from firmware.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
extract_get_elna_bypass_resp_tlv(struct wmi_unified *wmi_handle, void *resp_buf,
struct get_elna_bypass_response *resp)
{
WMI_GET_ELNA_BYPASS_EVENTID_param_tlvs *param_buf;
wmi_get_elna_bypass_event_fixed_param *evt;
param_buf = resp_buf;
evt = param_buf->fixed_param;
if (!evt) {
wmi_err("Invalid get elna bypass event");
return QDF_STATUS_E_INVAL;
}
wmi_debug("Get elna bypass %d from vdev %d",
evt->en_dis, evt->vdev_id);
resp->vdev_id = evt->vdev_id;
resp->elna_mode = evt->en_dis;
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_FEATURE_ELNA */
#ifdef WLAN_FEATURE_ELNA
static void wmi_fwol_attach_elna_tlv(struct wmi_ops *ops)
{
ops->send_set_elna_bypass_cmd = send_set_elna_bypass_cmd_tlv;
ops->send_get_elna_bypass_cmd = send_get_elna_bypass_cmd_tlv;
ops->extract_get_elna_bypass_resp = extract_get_elna_bypass_resp_tlv;
}
#else
static void wmi_fwol_attach_elna_tlv(struct wmi_ops *ops)
{
}
#endif /* WLAN_FEATURE_ELNA */
#ifdef WLAN_SEND_DSCP_UP_MAP_TO_FW
/**
* send_dscp_tid_map_cmd_tlv() - send dscp to tid map cmd to fw
* @wmi_handle: wmi handle
* @dscp_to_tid_map: array of dscp to tid map values
*
* Send WMI_PDEV_SET_DSCP_TID_MAP_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_dscp_tid_map_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t *dscp_to_tid_map)
{
QDF_STATUS status;
wmi_pdev_set_dscp_tid_map_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint16_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_pdev_set_dscp_tid_map_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(
&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_dscp_tid_map_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_set_dscp_tid_map_cmd_fixed_param));
cmd->reserved0 = WMI_PDEV_ID_SOC;
qdf_mem_copy(&cmd->dscp_to_tid_map, dscp_to_tid_map,
sizeof(uint32_t) * WMI_DSCP_MAP_MAX);
status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_DSCP_TID_MAP_CMDID);
if (status) {
wmi_err("Failed to send dscp_up_map_to_fw %d", status);
wmi_buf_free(buf);
}
return status;
}
static void wmi_fwol_attach_dscp_tid_tlv(struct wmi_ops *ops)
{
ops->send_dscp_tid_map_cmd = send_dscp_tid_map_cmd_tlv;
}
#else
static void wmi_fwol_attach_dscp_tid_tlv(struct wmi_ops *ops)
{
}
#endif /* WLAN_SEND_DSCP_UP_MAP_TO_FW */
#ifdef WLAN_FEATURE_MDNS_OFFLOAD
/**
* send_set_mdns_fqdn_cmd_tlv() - send set mDNS FQDN cmd to fw
* @wmi_handle: wmi handle
* @mdns_info: mDNS config info
*
* Send WMI_MDNS_SET_FQDN_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_set_mdns_fqdn_cmd_tlv(wmi_unified_t wmi_handle,
struct mdns_config_info *mdns_info)
{
wmi_buf_t buf;
uint8_t *buf_ptr;
wmi_mdns_set_fqdn_cmd_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
uint16_t fqdn_len_aligned;
QDF_STATUS ret;
fqdn_len_aligned = roundup(mdns_info->fqdn_len, sizeof(uint32_t));
if (fqdn_len_aligned < mdns_info->fqdn_len) {
wmi_err_rl("integer overflow while rounding up data_len");
return QDF_STATUS_E_FAILURE;
}
if (fqdn_len_aligned > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE) {
wmi_err_rl("wmi_max_msg_size overflow for given data_len");
return QDF_STATUS_E_FAILURE;
}
len += WMI_TLV_HDR_SIZE + fqdn_len_aligned;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err_rl("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
cmd = (wmi_mdns_set_fqdn_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_mdns_set_fqdn_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_mdns_set_fqdn_cmd_fixed_param));
cmd->vdev_id = mdns_info->vdev_id;
cmd->type = mdns_info->fqdn_type;
cmd->fqdn_len = mdns_info->fqdn_len;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, fqdn_len_aligned);
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, mdns_info->fqdn_data, cmd->fqdn_len);
wmi_mtrace(WMI_MDNS_SET_FQDN_CMDID, mdns_info->vdev_id,
mdns_info->fqdn_type);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_MDNS_SET_FQDN_CMDID);
if (QDF_IS_STATUS_ERROR(ret))
wmi_buf_free(buf);
return ret;
}
/**
* send_set_mdns_response_cmd_tlv() - send set mDNS response cmd to fw
* @wmi_handle: wmi handle
* @mdns_info: mDNS config info
*
* Send WMI_MDNS_SET_RESPONSE_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_set_mdns_response_cmd_tlv(wmi_unified_t wmi_handle,
struct mdns_config_info *mdns_info)
{
wmi_buf_t buf;
uint8_t *buf_ptr;
wmi_mdns_set_resp_cmd_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
uint16_t resp_len_aligned;
QDF_STATUS ret;
resp_len_aligned = roundup(mdns_info->answer_payload_len, sizeof(uint32_t));
if (resp_len_aligned < mdns_info->answer_payload_len) {
wmi_err_rl("integer overflow while rounding up data_len");
return QDF_STATUS_E_FAILURE;
}
if (resp_len_aligned > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE) {
wmi_err_rl("wmi_max_msg_size overflow for given data_len");
return QDF_STATUS_E_FAILURE;
}
len += WMI_TLV_HDR_SIZE + resp_len_aligned;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err_rl("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
cmd = (wmi_mdns_set_resp_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_mdns_set_resp_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_mdns_set_resp_cmd_fixed_param));
cmd->vdev_id = mdns_info->vdev_id;
cmd->AR_count = mdns_info->resource_record_count;
cmd->resp_len = mdns_info->answer_payload_len;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, resp_len_aligned);
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, mdns_info->answer_payload_data, cmd->resp_len);
wmi_mtrace(WMI_MDNS_SET_RESPONSE_CMDID, mdns_info->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_MDNS_SET_RESPONSE_CMDID);
if (QDF_IS_STATUS_ERROR(ret))
wmi_buf_free(buf);
return ret;
}
/**
* send_set_mdns_offload_cmd_tlv() - send set mDNS offload cmd to fw
* @wmi_handle: wmi handle
* @mdns_info: mDNS config info
*
* Send WMI_MDNS_OFFLOAD_ENABLE_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_set_mdns_offload_cmd_tlv(wmi_unified_t wmi_handle,
struct mdns_config_info *mdns_info)
{
wmi_buf_t buf;
wmi_mdns_offload_cmd_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err_rl("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_mdns_offload_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_mdns_offload_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_mdns_offload_cmd_fixed_param));
cmd->vdev_id = mdns_info->vdev_id;
cmd->enable = mdns_info->enable;
wmi_mtrace(WMI_MDNS_OFFLOAD_ENABLE_CMDID, mdns_info->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_MDNS_OFFLOAD_ENABLE_CMDID);
if (QDF_IS_STATUS_ERROR(ret))
wmi_buf_free(buf);
return ret;
}
/**
* send_set_mdns_config_cmd_tlv() - send set mDNS config cmd to fw
* @wmi_handle: wmi handle
* @mdns_info: mdns config info
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_set_mdns_config_cmd_tlv(wmi_unified_t wmi_handle,
struct mdns_config_info *mdns_info)
{
QDF_STATUS ret;
if (!mdns_info->enable) {
ret = send_set_mdns_offload_cmd_tlv(wmi_handle, mdns_info);
if (QDF_IS_STATUS_ERROR(ret))
wmi_err_rl("Failed to send mDNS offload command. ret = %d", ret);
return ret;
}
ret = send_set_mdns_fqdn_cmd_tlv(wmi_handle, mdns_info);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err_rl("Failed to send set fqdn command. ret = %d", ret);
return ret;
}
ret = send_set_mdns_response_cmd_tlv(wmi_handle, mdns_info);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err_rl("Failed to send set mDNS response command. ret = %d", ret);
return ret;
}
ret = send_set_mdns_offload_cmd_tlv(wmi_handle, mdns_info);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err_rl("Failed to send set mDNS offload command. ret = %d", ret);
return ret;
}
return ret;
}
static void wmi_fwol_attach_mdns_tlv(struct wmi_ops *ops)
{
ops->send_set_mdns_config_cmd = send_set_mdns_config_cmd_tlv;
}
#else
static void wmi_fwol_attach_mdns_tlv(struct wmi_ops *ops)
{
}
#endif /* WLAN_FEATURE_MDNS_OFFLOAD */
#ifdef THERMAL_STATS_SUPPORT
/**
* send_get_thermal_stats_cmd_tlv() - send get thermal stats cmd to fw
* @wmi_handle: wmi handle
* @req_type: req type
* @temp_offset: temperature offset
*
* Send WMI_REQUEST_THERMAL_STATS_CMDID to fw.
*
* Return: QDF_STATUS
*/
static QDF_STATUS
send_get_thermal_stats_cmd_tlv(wmi_unified_t wmi_handle,
enum thermal_stats_request_type req_type,
uint8_t temp_offset)
{
wmi_buf_t buf;
wmi_thermal_stats_cmd_fixed_param *cmd;
uint16_t len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("Failed to allocate wmi buffer");
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_thermal_stats_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_thermal_stats_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_thermal_stats_cmd_fixed_param));
cmd->thermal_action = req_type;
cmd->thermal_offset = temp_offset;
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_REQUEST_THERMAL_STATS_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send get thermal stats cmd = %d", ret);
wmi_buf_free(buf);
}
return ret;
}
static void wmi_fwol_attach_thermal_stats_tlv(struct wmi_ops *ops)
{
ops->send_get_thermal_stats_cmd = send_get_thermal_stats_cmd_tlv;
}
#else
static void wmi_fwol_attach_thermal_stats_tlv(struct wmi_ops *ops)
{
}
#endif /* FW_THERMAL_THROTTLE_SUPPORT */
void wmi_fwol_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
wmi_fwol_attach_elna_tlv(ops);
wmi_fwol_attach_dscp_tid_tlv(ops);
wmi_fwol_attach_mdns_tlv(ops);
wmi_fwol_attach_thermal_stats_tlv(ops);
}

40
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_gpio_api.c Normal file
View File

@@ -0,0 +1,40 @@
/*
* Copyright (c) 2020, The Linux Foundation. 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to gpio component.
*/
#include <wmi_unified_priv.h>
#include <wmi_unified_gpio_api.h>
QDF_STATUS wmi_unified_gpio_config_cmd_send(wmi_unified_t wmi_handle,
struct gpio_config_params *param)
{
if (wmi_handle->ops->send_gpio_config_cmd)
return wmi_handle->ops->send_gpio_config_cmd(wmi_handle, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_gpio_output_cmd_send(wmi_unified_t wmi_handle,
struct gpio_output_params *param)
{
if (wmi_handle->ops->send_gpio_output_cmd)
return wmi_handle->ops->send_gpio_output_cmd(wmi_handle, param);
return QDF_STATUS_E_FAILURE;
}

238
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_gpio_tlv.c Normal file
View File

@@ -0,0 +1,238 @@
/*
* Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 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 above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_gpio_api.h>
/**
* convert_gpio_direction() - Function to convert unified gpio direction
* @dir: pointer to enum gpio_direction
*
* Convert the wmi unified gpio direction to FW TLV WMI gpio direction
*
* Return:
* 0 - Output
* 1 - Input
*/
static uint32_t
convert_gpio_direction(enum gpio_direction dir)
{
switch (dir) {
case WMI_HOST_GPIO_INPUT:
return WMI_FW_GPIO_INPUT;
case WMI_HOST_GPIO_OUTPUT:
return WMI_FW_GPIO_OUTPUT;
default:
return WMI_FW_GPIO_OUTPUT;
}
}
/**
* convert_gpio_pull_type() - Function to convert unified pull type
* @pull_type: pointer to enum gpio_pull_type
*
* Convert the wmi unified pull type to FW TLV WMI gpio pull type
*
* Return: FW TLV WMI gpio pull type
*/
static uint32_t
convert_gpio_pull_type(enum gpio_pull_type pull_type)
{
switch (pull_type) {
case WMI_HOST_GPIO_PULL_NONE:
return WMI_GPIO_PULL_NONE;
case WMI_HOST_GPIO_PULL_UP:
return WMI_GPIO_PULL_UP;
case WMI_HOST_GPIO_PULL_DOWN:
return WMI_GPIO_PULL_DOWN;
default:
return WMI_GPIO_PULL_NONE;
}
}
/**
* convert_gpio_interrupt_mode() - Function to convert unified interrupt mode
* @intr_mode: pointer to enum gpio_interrupt_mode
*
* Convert the wmi unified interrupt mode to FW TLV WMI gpio interrupt mode
*
* Return: FW TLV WMI gpio interrupt mode
*/
static uint32_t
convert_gpio_interrupt_mode(enum gpio_interrupt_mode intr_mode)
{
switch (intr_mode) {
case WMI_HOST_GPIO_INTMODE_DISABLE:
return WMI_GPIO_INTTYPE_DISABLE;
case WMI_HOST_GPIO_INTMODE_RISING_EDGE:
return WMI_GPIO_INTTYPE_RISING_EDGE;
case WMI_HOST_GPIO_INTMODE_FALLING_EDGE:
return WMI_GPIO_INTTYPE_FALLING_EDGE;
case WMI_HOST_GPIO_INTMODE_BOTH_EDGE:
return WMI_GPIO_INTTYPE_BOTH_EDGE;
case WMI_HOST_GPIO_INTMODE_LEVEL_LOW:
return WMI_GPIO_INTTYPE_LEVEL_LOW;
case WMI_HOST_GPIO_INTMODE_LEVEL_HIGH:
return WMI_GPIO_INTTYPE_LEVEL_HIGH;
default:
return WMI_GPIO_INTTYPE_DISABLE;
}
}
/**
* convert_gpio_output_value() - Function to convert unified gpio output value
* @value: pointer to enum gpio_value
*
* Convert the wmi unified gpio output value to FW TLV WMI gpio output value
*
* Return:
* 0 - Output low level
* 1 - Output high level
*/
static uint32_t
convert_gpio_output_value(enum gpio_value value)
{
switch (value) {
case WMI_HOST_GPIO_LEVEL_LOW:
return 0;
case WMI_HOST_GPIO_LEVEL_HIGH:
return 1;
default:
return 0;
}
}
/**
* send_gpio_config_cmd_tlv() - send gpio config to fw
* @wmi_handle: wmi handle
* @param: pointer to hold gpio config params
*
* Send gpio configuration to firmware.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
static QDF_STATUS
send_gpio_config_cmd_tlv(wmi_unified_t wmi_handle,
struct gpio_config_params *param)
{
wmi_gpio_config_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len;
QDF_STATUS ret;
len = sizeof(*cmd);
/* Sanity Checks */
if (param->pin_pull_type >= WMI_HOST_GPIO_PULL_MAX ||
param->pin_intr_mode >= WMI_HOST_GPIO_INTMODE_MAX ||
param->pin_dir >= WMI_HOST_GPIO_DIR_MAX) {
return QDF_STATUS_E_FAILURE;
}
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
cmd = (wmi_gpio_config_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_gpio_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_gpio_config_cmd_fixed_param));
cmd->gpio_num = param->pin_num;
cmd->input = convert_gpio_direction(param->pin_dir);
cmd->pull_type = convert_gpio_pull_type(param->pin_pull_type);
cmd->intr_mode = convert_gpio_interrupt_mode(param->pin_intr_mode);
cmd->mux_config_val = param->mux_config_val;
cmd->drive = param->drive;
cmd->init_enable = param->init_enable;
wmi_debug("GPIO num %d, input-dir %d, pull_type %d, intr_mode %d"
" mux_config_val %d drive %d init_enable %d",
cmd->gpio_num, cmd->input, cmd->pull_type, cmd->intr_mode,
cmd->mux_config_val, cmd->drive, cmd->init_enable);
wmi_mtrace(WMI_GPIO_CONFIG_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_GPIO_CONFIG_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Sending GPIO config cmd failed");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_gpio_output_cmd_tlv() - send gpio output to fw
* @wmi_handle: wmi handle
* @param: pointer to hold gpio output param
*
* Send gpio output value to firmware.
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
static QDF_STATUS
send_gpio_output_cmd_tlv(wmi_unified_t wmi_handle,
struct gpio_output_params *param)
{
wmi_gpio_output_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len;
QDF_STATUS ret;
len = sizeof(*cmd);
/* Sanity Checks */
if (param->pin_set >= WMI_HOST_GPIO_LEVEL_MAX)
return QDF_STATUS_E_FAILURE;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
cmd = (wmi_gpio_output_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_gpio_output_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_gpio_output_cmd_fixed_param));
cmd->gpio_num = param->pin_num;
cmd->set = convert_gpio_output_value(param->pin_set);
wmi_debug("GPIO num %d, set %d", cmd->gpio_num, cmd->set);
wmi_mtrace(WMI_GPIO_OUTPUT_CMDID, NO_SESSION, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_GPIO_OUTPUT_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Sending GPIO output cmd failed");
wmi_buf_free(buf);
}
return ret;
}
void wmi_gpio_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_gpio_config_cmd = send_gpio_config_cmd_tlv;
ops->send_gpio_output_cmd = send_gpio_output_cmd_tlv;
}

41
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_interop_issues_ap_api.c Normal file
View File

@@ -0,0 +1,41 @@
/*
* Copyright (c) 2019 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to interop issues ap component.
*/
#include <wmi_unified_priv.h>
#include <wmi_unified_interop_issues_ap_api.h>
QDF_STATUS
wmi_extract_interop_issues_ap_ev_param(wmi_unified_t wmi_handle, void *evt_buf,
struct wlan_interop_issues_ap_event *param)
{
if (wmi_handle->ops->extract_interop_issues_ap_ev_param)
return wmi_handle->ops->extract_interop_issues_ap_ev_param(
wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_rap_ps_cmd(wmi_unified_t wmi_handle,
struct wlan_interop_issues_ap_info *rap)
{
if (wmi_handle->ops->send_set_rap_ps_cmd)
return wmi_handle->ops->send_set_rap_ps_cmd(wmi_handle, rap);
return QDF_STATUS_E_FAILURE;
}

139
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_interop_issues_ap_tlv.c Normal file
View File

@@ -0,0 +1,139 @@
/*
* Copyright (c) 2019-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_interop_issues_ap_api.h>
/**
* extract_interop_issues_ap_ev_param_tlv() - extract info from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @data: Pointer to hold interop issues ap info
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
extract_interop_issues_ap_ev_param_tlv(wmi_unified_t wmi_handle, void *evt_buf,
struct wlan_interop_issues_ap_event *data)
{
wmi_pdev_rap_info_event_fixed_param *fixed_param;
WMI_PDEV_RAP_INFO_EVENTID_param_tlvs *param_buf =
(WMI_PDEV_RAP_INFO_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err_rl("Invalid param_buf");
return -EINVAL;
}
fixed_param = param_buf->fixed_param;
if (!fixed_param) {
wmi_err_rl("Invalid fixed_praram");
return -EINVAL;
}
if (fixed_param->type != WMI_ROGUE_AP_ON_STA_PS) {
wmi_err_rl("Invalid type");
return -EINVAL;
}
data->pdev_id = fixed_param->pdev_id;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_param->bssid, data->rap_addr.bytes);
return QDF_STATUS_SUCCESS;
}
/**
* send_set_rap_ps_cmd_tlv() - set interop issues ap mac address in fw
* @wmi_handle: wmi handle
* @rap: interop issues ap info
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
send_set_rap_ps_cmd_tlv(wmi_unified_t wmi_handle,
struct wlan_interop_issues_ap_info *rap)
{
wmi_pdev_set_rap_config_fixed_param *cmd;
wmi_pdev_set_rap_config_on_sta_ps_tlv_param *param;
uint8_t *buf_ptr;
wmi_buf_t buf;
uint32_t ret;
uint32_t len, count;
qdf_size_t i;
count = rap->count;
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*param) * count;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
buf_ptr = wmi_buf_data(buf);
cmd = (wmi_pdev_set_rap_config_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_rap_config_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_set_rap_config_fixed_param));
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
WMI_HOST_PDEV_ID_SOC);
cmd->type = WMI_ROGUE_AP_ON_STA_PS;
if (rap->detect_enable)
cmd->sta_ps_detection_enabled = 1;
else
cmd->sta_ps_detection_enabled = 0;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
sizeof(wmi_pdev_set_rap_config_on_sta_ps_tlv_param) * count);
buf_ptr += WMI_TLV_HDR_SIZE;
for (i = 0; i < count; i++) {
param = (wmi_pdev_set_rap_config_on_sta_ps_tlv_param *)buf_ptr;
WMITLV_SET_HDR(&param->tlv_header,
WMITLV_TAG_STRUC_wmi_pdev_set_rap_config_on_sta_ps_tlv_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_pdev_set_rap_config_on_sta_ps_tlv_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(rap->rap_items[i].bytes,
&param->bssid);
buf_ptr += sizeof(*param);
}
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_SET_RAP_CONFIG_CMDID);
if (ret) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
void wmi_interop_issues_ap_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->extract_interop_issues_ap_ev_param =
extract_interop_issues_ap_ev_param_tlv;
ops->send_set_rap_ps_cmd = send_set_rap_ps_cmd_tlv;
}

191
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_nan_api.c Normal file
View File

@@ -0,0 +1,191 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to NAN component.
*/
#include <wmi_unified_priv.h>
#include <wmi_unified_nan_api.h>
QDF_STATUS wmi_unified_nan_req_cmd(wmi_unified_t wmi_handle,
struct nan_msg_params *nan_msg)
{
if (wmi_handle->ops->send_nan_req_cmd)
return wmi_handle->ops->send_nan_req_cmd(wmi_handle,
nan_msg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_nan_disable_req_cmd(wmi_unified_t wmi_handle,
struct nan_disable_req *nan_msg)
{
if (wmi_handle->ops->send_nan_disable_req_cmd)
return wmi_handle->ops->send_nan_disable_req_cmd(wmi_handle,
nan_msg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_nan_event_rsp(wmi_unified_t wmi_handle, void *evt_buf,
struct nan_event_params *nan_evt_params,
uint8_t **nan_msg_buf)
{
if (wmi_handle->ops->extract_nan_event_rsp)
return wmi_handle->ops->extract_nan_event_rsp(wmi_handle,
evt_buf,
nan_evt_params,
nan_msg_buf);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_ndp_initiator_req_cmd_send(wmi_unified_t wmi_handle,
struct nan_datapath_initiator_req *req)
{
if (wmi_handle->ops->send_ndp_initiator_req_cmd)
return wmi_handle->ops->send_ndp_initiator_req_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_ndp_responder_req_cmd_send(wmi_unified_t wmi_handle,
struct nan_datapath_responder_req *req)
{
if (wmi_handle->ops->send_ndp_responder_req_cmd)
return wmi_handle->ops->send_ndp_responder_req_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_terminate_all_ndps_req_cmd(wmi_unified_t wmi_handle,
uint32_t vdev_id)
{
if (wmi_handle->ops->send_terminate_all_ndps_req_cmd)
return wmi_handle->ops->send_terminate_all_ndps_req_cmd(
wmi_handle,
vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_ndp_end_req_cmd_send(wmi_unified_t wmi_handle,
struct nan_datapath_end_req *req)
{
if (wmi_handle->ops->send_ndp_end_req_cmd)
return wmi_handle->ops->send_ndp_end_req_cmd(wmi_handle,
req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_nan_msg(wmi_unified_t wmi_handle,
uint8_t *data,
struct nan_dump_msg *msg)
{
if (wmi_handle->ops->extract_nan_msg)
return wmi_handle->ops->extract_nan_msg(data, msg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_initiator_rsp(wmi_unified_t wmi_handle,
uint8_t *data, struct nan_datapath_initiator_rsp *rsp)
{
if (wmi_handle->ops->extract_ndp_initiator_rsp)
return wmi_handle->ops->extract_ndp_initiator_rsp(wmi_handle,
data, rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_ind(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_indication_event *ind)
{
if (wmi_handle->ops->extract_ndp_ind)
return wmi_handle->ops->extract_ndp_ind(wmi_handle,
data, ind);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_confirm(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_confirm_event *ev)
{
if (wmi_handle->ops->extract_ndp_confirm)
return wmi_handle->ops->extract_ndp_confirm(wmi_handle,
data, ev);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_responder_rsp(wmi_unified_t wmi_handle,
uint8_t *data,
struct nan_datapath_responder_rsp *rsp)
{
if (wmi_handle->ops->extract_ndp_responder_rsp)
return wmi_handle->ops->extract_ndp_responder_rsp(wmi_handle,
data, rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_end_rsp(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_end_rsp_event *rsp)
{
if (wmi_handle->ops->extract_ndp_end_rsp)
return wmi_handle->ops->extract_ndp_end_rsp(wmi_handle,
data, rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_end_ind(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_end_indication_event **ind)
{
if (wmi_handle->ops->extract_ndp_end_ind)
return wmi_handle->ops->extract_ndp_end_ind(wmi_handle,
data, ind);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_sch_update(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_sch_update_event *ind)
{
if (wmi_handle->ops->extract_ndp_sch_update)
return wmi_handle->ops->extract_ndp_sch_update(wmi_handle,
data, ind);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ndp_host_event(wmi_unified_t wmi_handle, uint8_t *data,
struct nan_datapath_host_event *evt)
{
if (wmi_handle->ops->extract_ndp_host_event)
return wmi_handle->ops->extract_ndp_host_event(wmi_handle,
data, evt);
return QDF_STATUS_E_FAILURE;
}

1268
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_nan_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

153
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_ocb_api.c Normal file
View File

@@ -0,0 +1,153 @@
/*
* Copyright (c) 2013-2018 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to DSRC component.
*/
#include <wmi_unified_priv.h>
#include <wlan_ocb_public_structs.h>
#include <wmi_unified_ocb_api.h>
QDF_STATUS wmi_unified_ocb_start_timing_advert(struct wmi_unified *wmi_hdl,
struct ocb_timing_advert_param *timing_advert)
{
if (wmi_hdl->ops->send_ocb_start_timing_advert_cmd)
return wmi_hdl->ops->send_ocb_start_timing_advert_cmd(wmi_hdl,
timing_advert);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_ocb_stop_timing_advert(struct wmi_unified *wmi_hdl,
struct ocb_timing_advert_param *timing_advert)
{
if (wmi_hdl->ops->send_ocb_stop_timing_advert_cmd)
return wmi_hdl->ops->send_ocb_stop_timing_advert_cmd(wmi_hdl,
timing_advert);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_ocb_set_utc_time_cmd(struct wmi_unified *wmi_hdl,
struct ocb_utc_param *utc)
{
if (wmi_hdl->ops->send_ocb_set_utc_time_cmd)
return wmi_hdl->ops->send_ocb_set_utc_time_cmd(wmi_hdl, utc);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_ocb_get_tsf_timer(struct wmi_unified *wmi_hdl,
struct ocb_get_tsf_timer_param *req)
{
if (wmi_hdl->ops->send_ocb_get_tsf_timer_cmd)
return wmi_hdl->ops->send_ocb_get_tsf_timer_cmd(wmi_hdl,
req->vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_dcc_get_stats_cmd(struct wmi_unified *wmi_hdl,
struct ocb_dcc_get_stats_param *get_stats_param)
{
if (wmi_hdl->ops->send_dcc_get_stats_cmd)
return wmi_hdl->ops->send_dcc_get_stats_cmd(wmi_hdl,
get_stats_param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_dcc_clear_stats(struct wmi_unified *wmi_hdl,
struct ocb_dcc_clear_stats_param *clear_stats_param)
{
if (wmi_hdl->ops->send_dcc_clear_stats_cmd)
return wmi_hdl->ops->send_dcc_clear_stats_cmd(wmi_hdl,
clear_stats_param->vdev_id,
clear_stats_param->dcc_stats_bitmap);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_dcc_update_ndl(struct wmi_unified *wmi_hdl,
struct ocb_dcc_update_ndl_param *update_ndl_param)
{
if (wmi_hdl->ops->send_dcc_update_ndl_cmd)
return wmi_hdl->ops->send_dcc_update_ndl_cmd(wmi_hdl,
update_ndl_param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_ocb_set_config(struct wmi_unified *wmi_hdl,
struct ocb_config *config)
{
if (wmi_hdl->ops->send_ocb_set_config_cmd)
return wmi_hdl->ops->send_ocb_set_config_cmd(wmi_hdl,
config);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_ocb_set_channel_config_resp(struct wmi_unified *wmi_hdl,
void *evt_buf,
uint32_t *status)
{
if (wmi_hdl->ops->extract_ocb_chan_config_resp)
return wmi_hdl->ops->extract_ocb_chan_config_resp(wmi_hdl,
evt_buf,
status);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_ocb_tsf_timer(struct wmi_unified *wmi_hdl,
void *evt_buf,
struct ocb_get_tsf_timer_response *resp)
{
if (wmi_hdl->ops->extract_ocb_tsf_timer)
return wmi_hdl->ops->extract_ocb_tsf_timer(wmi_hdl,
evt_buf,
resp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dcc_update_ndl_resp(struct wmi_unified *wmi_hdl,
void *evt_buf, struct ocb_dcc_update_ndl_response *resp)
{
if (wmi_hdl->ops->extract_dcc_update_ndl_resp)
return wmi_hdl->ops->extract_dcc_update_ndl_resp(wmi_hdl,
evt_buf,
resp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_dcc_stats(struct wmi_unified *wmi_hdl,
void *evt_buf,
struct ocb_dcc_get_stats_response **resp)
{
if (wmi_hdl->ops->extract_dcc_stats)
return wmi_hdl->ops->extract_dcc_stats(wmi_hdl,
evt_buf,
resp);
return QDF_STATUS_E_FAILURE;
}

793
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_ocb_tlv.c Normal file
View File

@@ -0,0 +1,793 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include <wlan_ocb_public_structs.h>
#include <wmi_unified_ocb_api.h>
/**
* send_ocb_set_utc_time_cmd_tlv() - send the UTC time to the firmware
* @wmi_handle: pointer to the wmi handle
* @utc: pointer to the UTC time struct
*
* Return: 0 on success
*/
static QDF_STATUS send_ocb_set_utc_time_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_utc_param *utc)
{
QDF_STATUS ret;
wmi_ocb_set_utc_time_cmd_fixed_param *cmd;
uint8_t *buf_ptr;
uint32_t len, i;
wmi_buf_t buf;
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_ocb_set_utc_time_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_set_utc_time_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_utc_time_cmd_fixed_param));
cmd->vdev_id = utc->vdev_id;
for (i = 0; i < SIZE_UTC_TIME; i++)
WMI_UTC_TIME_SET(cmd, i, utc->utc_time[i]);
for (i = 0; i < SIZE_UTC_TIME_ERROR; i++)
WMI_TIME_ERROR_SET(cmd, i, utc->time_error[i]);
wmi_mtrace(WMI_OCB_SET_UTC_TIME_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_OCB_SET_UTC_TIME_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to set OCB UTC time");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_ocb_start_timing_advert_cmd_tlv() - start sending the timing advertisement
* frames on a channel
* @wmi_handle: pointer to the wmi handle
* @timing_advert: pointer to the timing advertisement struct
*
* Return: 0 on success
*/
static QDF_STATUS send_ocb_start_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_timing_advert_param *timing_advert)
{
QDF_STATUS ret;
wmi_ocb_start_timing_advert_cmd_fixed_param *cmd;
uint8_t *buf_ptr;
uint32_t len, len_template;
wmi_buf_t buf;
len = sizeof(*cmd) +
WMI_TLV_HDR_SIZE;
len_template = timing_advert->template_length;
/* Add padding to the template if needed */
if (len_template % 4 != 0)
len_template += 4 - (len_template % 4);
len += len_template;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_ocb_start_timing_advert_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_start_timing_advert_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_ocb_start_timing_advert_cmd_fixed_param));
cmd->vdev_id = timing_advert->vdev_id;
cmd->repeat_rate = timing_advert->repeat_rate;
cmd->channel_freq = timing_advert->chan_freq;
cmd->timestamp_offset = timing_advert->timestamp_offset;
cmd->time_value_offset = timing_advert->time_value_offset;
cmd->timing_advert_template_length = timing_advert->template_length;
buf_ptr += sizeof(*cmd);
/* Add the timing advert template */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
len_template);
qdf_mem_copy(buf_ptr + WMI_TLV_HDR_SIZE,
(uint8_t *)timing_advert->template_value,
timing_advert->template_length);
wmi_mtrace(WMI_OCB_START_TIMING_ADVERT_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_OCB_START_TIMING_ADVERT_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to start OCB timing advert");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_ocb_stop_timing_advert_cmd_tlv() - stop sending the timing advertisement frames
* on a channel
* @wmi_handle: pointer to the wmi handle
* @timing_advert: pointer to the timing advertisement struct
*
* Return: 0 on success
*/
static QDF_STATUS send_ocb_stop_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_timing_advert_param *timing_advert)
{
QDF_STATUS ret;
wmi_ocb_stop_timing_advert_cmd_fixed_param *cmd;
uint8_t *buf_ptr;
uint32_t len;
wmi_buf_t buf;
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_ocb_stop_timing_advert_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_stop_timing_advert_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_ocb_stop_timing_advert_cmd_fixed_param));
cmd->vdev_id = timing_advert->vdev_id;
cmd->channel_freq = timing_advert->chan_freq;
wmi_mtrace(WMI_OCB_STOP_TIMING_ADVERT_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_OCB_STOP_TIMING_ADVERT_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to stop OCB timing advert");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_ocb_get_tsf_timer_cmd_tlv() - get ocb tsf timer val
* @wmi_handle: pointer to the wmi handle
* @vdev_id: vdev identifier
*
* Return: 0 on success
*/
static QDF_STATUS send_ocb_get_tsf_timer_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t vdev_id)
{
QDF_STATUS ret;
wmi_ocb_get_tsf_timer_cmd_fixed_param *cmd;
uint8_t *buf_ptr;
wmi_buf_t buf;
int32_t len;
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_ocb_get_tsf_timer_cmd_fixed_param *)buf_ptr;
qdf_mem_zero(cmd, len);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_get_tsf_timer_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_ocb_get_tsf_timer_cmd_fixed_param));
cmd->vdev_id = vdev_id;
/* Send the WMI command */
wmi_mtrace(WMI_OCB_GET_TSF_TIMER_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_OCB_GET_TSF_TIMER_CMDID);
/* If there is an error, set the completion event */
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send WMI message: %d", ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* send_dcc_get_stats_cmd_tlv() - get the DCC channel stats
* @wmi_handle: pointer to the wmi handle
* @get_stats_param: pointer to the dcc stats
*
* Return: 0 on success
*/
static QDF_STATUS send_dcc_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_dcc_get_stats_param *get_stats_param)
{
QDF_STATUS ret;
wmi_dcc_get_stats_cmd_fixed_param *cmd;
wmi_dcc_channel_stats_request *channel_stats_array;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint32_t len;
uint32_t i;
/* Validate the input */
if (get_stats_param->request_array_len !=
get_stats_param->channel_count * sizeof(*channel_stats_array)) {
wmi_err("Invalid parameter");
return QDF_STATUS_E_INVAL;
}
/* Allocate memory for the WMI command */
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
get_stats_param->request_array_len;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
qdf_mem_zero(buf_ptr, len);
/* Populate the WMI command */
cmd = (wmi_dcc_get_stats_cmd_fixed_param *)buf_ptr;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_dcc_get_stats_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_get_stats_cmd_fixed_param));
cmd->vdev_id = get_stats_param->vdev_id;
cmd->num_channels = get_stats_param->channel_count;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
get_stats_param->request_array_len);
buf_ptr += WMI_TLV_HDR_SIZE;
channel_stats_array = (wmi_dcc_channel_stats_request *)buf_ptr;
qdf_mem_copy(channel_stats_array, get_stats_param->request_array,
get_stats_param->request_array_len);
for (i = 0; i < cmd->num_channels; i++)
WMITLV_SET_HDR(&channel_stats_array[i].tlv_header,
WMITLV_TAG_STRUC_wmi_dcc_channel_stats_request,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_channel_stats_request));
/* Send the WMI command */
wmi_mtrace(WMI_DCC_GET_STATS_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_DCC_GET_STATS_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send WMI message: %d", ret);
wmi_buf_free(buf);
}
return ret;
}
/**
* send_dcc_clear_stats_cmd_tlv() - command to clear the DCC stats
* @wmi_handle: pointer to the wmi handle
* @vdev_id: vdev id
* @dcc_stats_bitmap: dcc status bitmap
*
* Return: 0 on success
*/
static QDF_STATUS send_dcc_clear_stats_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t vdev_id, uint32_t dcc_stats_bitmap)
{
QDF_STATUS ret;
wmi_dcc_clear_stats_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint32_t len;
/* Allocate memory for the WMI command */
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
qdf_mem_zero(buf_ptr, len);
/* Populate the WMI command */
cmd = (wmi_dcc_clear_stats_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_dcc_clear_stats_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_clear_stats_cmd_fixed_param));
cmd->vdev_id = vdev_id;
cmd->dcc_stats_bitmap = dcc_stats_bitmap;
/* Send the WMI command */
wmi_mtrace(WMI_DCC_CLEAR_STATS_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_DCC_CLEAR_STATS_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to send the WMI command");
wmi_buf_free(buf);
}
return ret;
}
/**
* send_dcc_update_ndl_cmd_tlv() - command to update the NDL data
* @wmi_handle: pointer to the wmi handle
* @update_ndl_param: pointer to the request parameters
*
* Return: 0 on success
*/
static QDF_STATUS send_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_dcc_update_ndl_param *update_ndl_param)
{
QDF_STATUS qdf_status;
wmi_dcc_update_ndl_cmd_fixed_param *cmd;
wmi_dcc_ndl_chan *ndl_chan_array;
wmi_dcc_ndl_active_state_config *ndl_active_state_array;
uint32_t active_state_count;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint32_t len;
uint32_t i;
/* validate the input */
if (update_ndl_param->dcc_ndl_chan_list_len !=
update_ndl_param->channel_count * sizeof(*ndl_chan_array)) {
wmi_err("Invalid parameter");
return QDF_STATUS_E_INVAL;
}
active_state_count = 0;
ndl_chan_array = update_ndl_param->dcc_ndl_chan_list;
for (i = 0; i < update_ndl_param->channel_count; i++)
active_state_count +=
WMI_NDL_NUM_ACTIVE_STATE_GET(&ndl_chan_array[i]);
if (update_ndl_param->dcc_ndl_active_state_list_len !=
active_state_count * sizeof(*ndl_active_state_array)) {
wmi_err("Invalid parameter");
return QDF_STATUS_E_INVAL;
}
/* Allocate memory for the WMI command */
len = sizeof(*cmd) +
WMI_TLV_HDR_SIZE + update_ndl_param->dcc_ndl_chan_list_len +
WMI_TLV_HDR_SIZE +
update_ndl_param->dcc_ndl_active_state_list_len;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = wmi_buf_data(buf);
qdf_mem_zero(buf_ptr, len);
/* Populate the WMI command */
cmd = (wmi_dcc_update_ndl_cmd_fixed_param *)buf_ptr;
buf_ptr += sizeof(*cmd);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_dcc_update_ndl_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_update_ndl_cmd_fixed_param));
cmd->vdev_id = update_ndl_param->vdev_id;
cmd->num_channel = update_ndl_param->channel_count;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
update_ndl_param->dcc_ndl_chan_list_len);
buf_ptr += WMI_TLV_HDR_SIZE;
ndl_chan_array = (wmi_dcc_ndl_chan *)buf_ptr;
qdf_mem_copy(ndl_chan_array, update_ndl_param->dcc_ndl_chan_list,
update_ndl_param->dcc_ndl_chan_list_len);
for (i = 0; i < cmd->num_channel; i++)
WMITLV_SET_HDR(&ndl_chan_array[i].tlv_header,
WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_ndl_chan));
buf_ptr += update_ndl_param->dcc_ndl_chan_list_len;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
update_ndl_param->dcc_ndl_active_state_list_len);
buf_ptr += WMI_TLV_HDR_SIZE;
ndl_active_state_array = (wmi_dcc_ndl_active_state_config *)buf_ptr;
qdf_mem_copy(ndl_active_state_array,
update_ndl_param->dcc_ndl_active_state_list,
update_ndl_param->dcc_ndl_active_state_list_len);
for (i = 0; i < active_state_count; i++) {
WMITLV_SET_HDR(&ndl_active_state_array[i].tlv_header,
WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_ndl_active_state_config));
}
buf_ptr += update_ndl_param->dcc_ndl_active_state_list_len;
/* Send the WMI command */
wmi_mtrace(WMI_DCC_UPDATE_NDL_CMDID, cmd->vdev_id, 0);
qdf_status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_DCC_UPDATE_NDL_CMDID);
/* If there is an error, set the completion event */
if (QDF_IS_STATUS_ERROR(qdf_status)) {
wmi_err("Failed to send WMI message: %d", qdf_status);
wmi_buf_free(buf);
}
return qdf_status;
}
/**
* send_ocb_set_config_cmd_tlv() - send the OCB config to the FW
* @wmi_handle: pointer to the wmi handle
* @config: the OCB configuration
*
* Return: 0 on success
*/
static QDF_STATUS send_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_config *config)
{
QDF_STATUS ret;
wmi_ocb_set_config_cmd_fixed_param *cmd;
wmi_channel *chan;
wmi_ocb_channel *ocb_chan;
wmi_qos_parameter *qos_param;
wmi_dcc_ndl_chan *ndl_chan;
wmi_dcc_ndl_active_state_config *ndl_active_config;
wmi_ocb_schedule_element *sched_elem;
uint8_t *buf_ptr;
wmi_buf_t buf;
int32_t len;
int32_t i, j, active_state_count;
/*
* Validate the dcc_ndl_chan_list_len and count the number of active
* states. Validate dcc_ndl_active_state_list_len.
*/
active_state_count = 0;
if (config->dcc_ndl_chan_list_len) {
if (!config->dcc_ndl_chan_list ||
config->dcc_ndl_chan_list_len !=
config->channel_count * sizeof(wmi_dcc_ndl_chan)) {
wmi_err("NDL channel is invalid. List len: %d",
config->dcc_ndl_chan_list_len);
return QDF_STATUS_E_INVAL;
}
for (i = 0, ndl_chan = config->dcc_ndl_chan_list;
i < config->channel_count; ++i, ++ndl_chan)
active_state_count +=
WMI_NDL_NUM_ACTIVE_STATE_GET(ndl_chan);
if (active_state_count) {
if (!config->dcc_ndl_active_state_list ||
config->dcc_ndl_active_state_list_len !=
active_state_count *
sizeof(wmi_dcc_ndl_active_state_config)) {
wmi_err("NDL active state is invalid");
return QDF_STATUS_E_INVAL;
}
}
}
len = sizeof(*cmd) +
WMI_TLV_HDR_SIZE + config->channel_count *
sizeof(wmi_channel) +
WMI_TLV_HDR_SIZE + config->channel_count *
sizeof(wmi_ocb_channel) +
WMI_TLV_HDR_SIZE + config->channel_count *
sizeof(wmi_qos_parameter) * WMI_MAX_NUM_AC +
WMI_TLV_HDR_SIZE + config->dcc_ndl_chan_list_len +
WMI_TLV_HDR_SIZE + active_state_count *
sizeof(wmi_dcc_ndl_active_state_config) +
WMI_TLV_HDR_SIZE + config->schedule_size *
sizeof(wmi_ocb_schedule_element);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_ocb_set_config_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_set_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_config_cmd_fixed_param));
cmd->vdev_id = config->vdev_id;
cmd->channel_count = config->channel_count;
cmd->schedule_size = config->schedule_size;
cmd->flags = config->flags;
buf_ptr += sizeof(*cmd);
/* Add the wmi_channel info */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
config->channel_count * sizeof(wmi_channel));
buf_ptr += WMI_TLV_HDR_SIZE;
for (i = 0; i < config->channel_count; i++) {
chan = (wmi_channel *)buf_ptr;
WMITLV_SET_HDR(&chan->tlv_header,
WMITLV_TAG_STRUC_wmi_channel,
WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
chan->mhz = config->channels[i].chan_freq;
chan->band_center_freq1 = config->channels[i].chan_freq;
chan->band_center_freq2 = 0;
chan->info = 0;
WMI_SET_CHANNEL_MODE(chan, config->channels[i].ch_mode);
WMI_SET_CHANNEL_MAX_POWER(chan, config->channels[i].max_pwr);
WMI_SET_CHANNEL_MIN_POWER(chan, config->channels[i].min_pwr);
WMI_SET_CHANNEL_MAX_TX_POWER(chan, config->channels[i].max_pwr);
WMI_SET_CHANNEL_REG_POWER(chan, config->channels[i].reg_pwr);
WMI_SET_CHANNEL_ANTENNA_MAX(chan,
config->channels[i].antenna_max);
if (config->channels[i].bandwidth < 10)
WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
else if (config->channels[i].bandwidth < 20)
WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
buf_ptr += sizeof(*chan);
}
/* Add the wmi_ocb_channel info */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
config->channel_count * sizeof(wmi_ocb_channel));
buf_ptr += WMI_TLV_HDR_SIZE;
for (i = 0; i < config->channel_count; i++) {
ocb_chan = (wmi_ocb_channel *)buf_ptr;
WMITLV_SET_HDR(&ocb_chan->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_channel,
WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_channel));
ocb_chan->bandwidth = config->channels[i].bandwidth;
WMI_CHAR_ARRAY_TO_MAC_ADDR(
config->channels[i].mac_address.bytes,
&ocb_chan->mac_address);
buf_ptr += sizeof(*ocb_chan);
}
/* Add the wmi_qos_parameter info */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
config->channel_count * sizeof(wmi_qos_parameter)*WMI_MAX_NUM_AC);
buf_ptr += WMI_TLV_HDR_SIZE;
/* WMI_MAX_NUM_AC parameters for each channel */
for (i = 0; i < config->channel_count; i++) {
for (j = 0; j < WMI_MAX_NUM_AC; j++) {
qos_param = (wmi_qos_parameter *)buf_ptr;
WMITLV_SET_HDR(&qos_param->tlv_header,
WMITLV_TAG_STRUC_wmi_qos_parameter,
WMITLV_GET_STRUCT_TLVLEN(wmi_qos_parameter));
qos_param->aifsn =
config->channels[i].qos_params[j].aifsn;
qos_param->cwmin =
config->channels[i].qos_params[j].cwmin;
qos_param->cwmax =
config->channels[i].qos_params[j].cwmax;
buf_ptr += sizeof(*qos_param);
}
}
/* Add the wmi_dcc_ndl_chan (per channel) */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
config->dcc_ndl_chan_list_len);
buf_ptr += WMI_TLV_HDR_SIZE;
if (config->dcc_ndl_chan_list_len) {
ndl_chan = (wmi_dcc_ndl_chan *)buf_ptr;
qdf_mem_copy(ndl_chan, config->dcc_ndl_chan_list,
config->dcc_ndl_chan_list_len);
for (i = 0; i < config->channel_count; i++)
WMITLV_SET_HDR(&(ndl_chan[i].tlv_header),
WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
WMITLV_GET_STRUCT_TLVLEN(wmi_dcc_ndl_chan));
buf_ptr += config->dcc_ndl_chan_list_len;
}
/* Add the wmi_dcc_ndl_active_state_config */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, active_state_count *
sizeof(wmi_dcc_ndl_active_state_config));
buf_ptr += WMI_TLV_HDR_SIZE;
if (active_state_count) {
ndl_active_config = (wmi_dcc_ndl_active_state_config *)buf_ptr;
qdf_mem_copy(ndl_active_config,
config->dcc_ndl_active_state_list,
active_state_count * sizeof(*ndl_active_config));
for (i = 0; i < active_state_count; ++i)
WMITLV_SET_HDR(&(ndl_active_config[i].tlv_header),
WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
WMITLV_GET_STRUCT_TLVLEN(
wmi_dcc_ndl_active_state_config));
buf_ptr += active_state_count *
sizeof(*ndl_active_config);
}
/* Add the wmi_ocb_schedule_element info */
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
config->schedule_size * sizeof(wmi_ocb_schedule_element));
buf_ptr += WMI_TLV_HDR_SIZE;
for (i = 0; i < config->schedule_size; i++) {
sched_elem = (wmi_ocb_schedule_element *)buf_ptr;
WMITLV_SET_HDR(&sched_elem->tlv_header,
WMITLV_TAG_STRUC_wmi_ocb_schedule_element,
WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_schedule_element));
sched_elem->channel_freq = config->schedule[i].chan_freq;
sched_elem->total_duration = config->schedule[i].total_duration;
sched_elem->guard_interval = config->schedule[i].guard_interval;
buf_ptr += sizeof(*sched_elem);
}
wmi_mtrace(WMI_OCB_SET_CONFIG_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_OCB_SET_CONFIG_CMDID);
if (QDF_IS_STATUS_ERROR(ret)) {
wmi_err("Failed to set OCB config");
wmi_buf_free(buf);
}
return ret;
}
/**
* extract_ocb_channel_config_resp_tlv() - extract ocb channel config resp
* @wmi_handle: wmi handle
* @evt_buf: wmi event buffer
* @status: status buffer
*
* Return: QDF_STATUS_SUCCESS on success
*/
static QDF_STATUS extract_ocb_channel_config_resp_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
uint32_t *status)
{
WMI_OCB_SET_CONFIG_RESP_EVENTID_param_tlvs *param_tlvs;
wmi_ocb_set_config_resp_event_fixed_param *fix_param;
param_tlvs = evt_buf;
fix_param = param_tlvs->fixed_param;
*status = fix_param->status;
return QDF_STATUS_SUCCESS;
}
/**
* extract_ocb_tsf_timer_tlv() - extract TSF timer from event buffer
* @wmi_handle: wmi handle
* @evt_buf: wmi event buffer
* @resp: response buffer
*
* Return: QDF_STATUS_SUCCESS on success
*/
static QDF_STATUS extract_ocb_tsf_timer_tlv(wmi_unified_t wmi_handle,
void *evt_buf, struct ocb_get_tsf_timer_response *resp)
{
WMI_OCB_GET_TSF_TIMER_RESP_EVENTID_param_tlvs *param_tlvs;
wmi_ocb_get_tsf_timer_resp_event_fixed_param *fix_param;
param_tlvs = evt_buf;
fix_param = param_tlvs->fixed_param;
resp->vdev_id = fix_param->vdev_id;
resp->timer_high = fix_param->tsf_timer_high;
resp->timer_low = fix_param->tsf_timer_low;
return QDF_STATUS_SUCCESS;
}
/**
* extract_ocb_ndl_resp_tlv() - extract TSF timer from event buffer
* @wmi_handle: wmi handle
* @evt_buf: wmi event buffer
* @resp: response buffer
*
* Return: QDF_STATUS_SUCCESS on success
*/
static QDF_STATUS extract_ocb_ndl_resp_tlv(wmi_unified_t wmi_handle,
void *evt_buf, struct ocb_dcc_update_ndl_response *resp)
{
WMI_DCC_UPDATE_NDL_RESP_EVENTID_param_tlvs *param_tlvs;
wmi_dcc_update_ndl_resp_event_fixed_param *fix_param;
param_tlvs = evt_buf;
fix_param = param_tlvs->fixed_param;
resp->vdev_id = fix_param->vdev_id;
resp->status = fix_param->status;
return QDF_STATUS_SUCCESS;
}
/**
* extract_ocb_dcc_stats_tlv() - extract DCC stats from event buffer
* @wmi_handle: wmi handle
* @evt_buf: wmi event buffer
* @resp: response buffer
*
* Since length of stats is variable, buffer for DCC stats will be allocated
* in this function. The caller must free the buffer.
*
* Return: QDF_STATUS_SUCCESS on success
*/
static QDF_STATUS extract_ocb_dcc_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, struct ocb_dcc_get_stats_response **resp)
{
struct ocb_dcc_get_stats_response *response;
WMI_DCC_GET_STATS_RESP_EVENTID_param_tlvs *param_tlvs;
wmi_dcc_get_stats_resp_event_fixed_param *fix_param;
param_tlvs = (WMI_DCC_GET_STATS_RESP_EVENTID_param_tlvs *)evt_buf;
fix_param = param_tlvs->fixed_param;
/* Allocate and populate the response */
if (fix_param->num_channels > ((WMI_SVC_MSG_MAX_SIZE -
sizeof(*fix_param)) / sizeof(wmi_dcc_ndl_stats_per_channel)) ||
fix_param->num_channels > param_tlvs->num_stats_per_channel_list) {
wmi_warn("Too many channels:%d actual:%d",
fix_param->num_channels,
param_tlvs->num_stats_per_channel_list);
*resp = NULL;
return QDF_STATUS_E_INVAL;
}
response = qdf_mem_malloc(sizeof(*response) + fix_param->num_channels *
sizeof(wmi_dcc_ndl_stats_per_channel));
*resp = response;
if (!response)
return QDF_STATUS_E_NOMEM;
response->vdev_id = fix_param->vdev_id;
response->num_channels = fix_param->num_channels;
response->channel_stats_array_len =
fix_param->num_channels *
sizeof(wmi_dcc_ndl_stats_per_channel);
response->channel_stats_array = ((uint8_t *)response) +
sizeof(*response);
qdf_mem_copy(response->channel_stats_array,
param_tlvs->stats_per_channel_list,
response->channel_stats_array_len);
return QDF_STATUS_SUCCESS;
}
void wmi_ocb_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_ocb_set_utc_time_cmd = send_ocb_set_utc_time_cmd_tlv;
ops->send_ocb_get_tsf_timer_cmd = send_ocb_get_tsf_timer_cmd_tlv;
ops->send_dcc_clear_stats_cmd = send_dcc_clear_stats_cmd_tlv;
ops->send_dcc_get_stats_cmd = send_dcc_get_stats_cmd_tlv;
ops->send_dcc_update_ndl_cmd = send_dcc_update_ndl_cmd_tlv;
ops->send_ocb_set_config_cmd = send_ocb_set_config_cmd_tlv;
ops->send_ocb_stop_timing_advert_cmd =
send_ocb_stop_timing_advert_cmd_tlv;
ops->send_ocb_start_timing_advert_cmd =
send_ocb_start_timing_advert_cmd_tlv;
ops->extract_ocb_chan_config_resp =
extract_ocb_channel_config_resp_tlv;
ops->extract_ocb_tsf_timer = extract_ocb_tsf_timer_tlv;
ops->extract_dcc_update_ndl_resp = extract_ocb_ndl_resp_tlv;
ops->extract_dcc_stats = extract_ocb_dcc_stats_tlv;
}

509
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_ocb_ut.c Normal file
View File

@@ -0,0 +1,509 @@
/*
* Copyright (c) 2018-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "wmi_unified_api.h"
#include "wmi.h"
#include "wmi_version.h"
#include "wmi_unified_priv.h"
#include <wlan_defs.h>
#include "target_if.h"
#include "wma.h"
#include "wlan_ocb_ucfg_api.h"
#include "wlan_ocb_main.h"
void wmi_ocb_ut_attach(struct wmi_unified *wmi_handle);
static inline struct wlan_ocb_rx_ops *
target_if_ocb_get_rx_ops(struct wlan_objmgr_psoc *psoc)
{
struct wlan_objmgr_pdev *pdev;
struct ocb_pdev_obj *pdev_obj;
pdev = wlan_objmgr_get_pdev_by_id(psoc, 0,
WLAN_OCB_SB_ID);
pdev_obj = (struct ocb_pdev_obj *)
wlan_objmgr_pdev_get_comp_private_obj(pdev,
WLAN_UMAC_COMP_OCB);
return &pdev_obj->ocb_rxops;
}
/**
* fake_vdev_create_cmd_tlv() - send VDEV create command to fw
* @wmi_handle: wmi handle
* @param: pointer to hold vdev create parameter
* @macaddr: vdev mac address
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS fake_vdev_create_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct vdev_create_params *param)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_vdev_delete_cmd_tlv() - send VDEV delete command to fw
* @wmi_handle: wmi handle
* @if_id: vdev id
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS fake_vdev_delete_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t if_id)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_ocb_set_utc_time_cmd_tlv() - send the UTC time to the firmware
* @wmi_handle: pointer to the wmi handle
* @utc: pointer to the UTC time struct
*
* Return: 0 on success
*/
static QDF_STATUS fake_ocb_set_utc_time_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_utc_param *utc)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_ocb_get_tsf_timer_cmd_tlv() - get ocb tsf timer val
* @wmi_handle: pointer to the wmi handle
* @vdev_id: vdev of interest
*
* Return: 0 on success
*/
static QDF_STATUS fake_ocb_get_tsf_timer_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t vdev_id)
{
QDF_STATUS status;
struct wlan_objmgr_psoc *psoc;
struct wlan_ocb_rx_ops *ocb_rx_ops;
struct ocb_get_tsf_timer_response response;
ol_scn_t scn = (ol_scn_t) wmi_handle->scn_handle;
wmi_debug("called");
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
wmi_err("null psoc");
return -EINVAL;
}
response.vdev_id = vdev_id;
response.timer_high = 0x1234;
response.timer_low = 0x5678;
ocb_rx_ops = target_if_ocb_get_rx_ops(psoc);
if (ocb_rx_ops->ocb_tsf_timer) {
status = ocb_rx_ops->ocb_tsf_timer(psoc, &response);
if (status != QDF_STATUS_SUCCESS) {
wmi_err("ocb_tsf_timer failed");
return -EINVAL;
}
} else {
wmi_err("No ocb_tsf_timer callback");
return -EINVAL;
}
return QDF_STATUS_SUCCESS;
}
/**
* fake_dcc_clear_stats_cmd_tlv() - command to clear the DCC stats
* @wmi_handle: pointer to the wmi handle
* @vdev_id: vdev id
* @dcc_stats_bitmap: dcc status bitmap
*
* Return: 0 on success
*/
static QDF_STATUS fake_dcc_clear_stats_cmd_tlv(wmi_unified_t wmi_handle,
uint32_t vdev_id, uint32_t dcc_stats_bitmap)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
wmi_dcc_ndl_stats_per_channel chan1_info[2] = {
[0] = {.chan_info = 5860,
.tx_power_datarate = 23 | (10 << 8),
.carrier_sense_est_comm_range = 107 | (198 << 13),
.dcc_stats = 78 | (56 << 8) | (345 << 16),
.packet_stats = 1278 | (789 << 14),
.channel_busy_time = 1389,
},
[1] = {.chan_info = 5880,
.tx_power_datarate = 53 | (17 << 8),
.carrier_sense_est_comm_range = 137 | (198 << 13),
.dcc_stats = 78 | (66 << 8) | (245 << 16),
.packet_stats = 1278 | (889 << 14),
.channel_busy_time = 2389,
},
};
/**
* fake_dcc_get_stats_cmd_tlv() - get the DCC channel stats
* @wmi_handle: pointer to the wmi handle
* @get_stats_param: pointer to the dcc stats
*
* Return: 0 on success
*/
static QDF_STATUS fake_dcc_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_dcc_get_stats_param *get_stats_param)
{
QDF_STATUS status;
struct wlan_objmgr_psoc *psoc;
struct wlan_ocb_rx_ops *ocb_rx_ops;
ol_scn_t scn = (ol_scn_t) wmi_handle->scn_handle;
struct ocb_dcc_get_stats_response *response;
wmi_debug("called");
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
wmi_err("null psoc");
return -EINVAL;
}
response = qdf_mem_malloc(sizeof(*response) + 2 *
sizeof(wmi_dcc_ndl_stats_per_channel));
response->num_channels = 2;
response->channel_stats_array_len = 2 *
sizeof(wmi_dcc_ndl_stats_per_channel);
response->vdev_id = get_stats_param->vdev_id;
response->channel_stats_array = (uint8_t *)response + sizeof(*response);
qdf_mem_copy(response->channel_stats_array,
&chan1_info,
2 * sizeof(wmi_dcc_ndl_stats_per_channel));
wmi_debug("channel1 freq %d, channel2 freq %d", chan1_info[0].chan_info,
chan1_info[1].chan_info);
ocb_rx_ops = target_if_ocb_get_rx_ops(psoc);
if (ocb_rx_ops->ocb_dcc_stats_indicate) {
status = ocb_rx_ops->ocb_dcc_stats_indicate(psoc,
response, true);
if (status != QDF_STATUS_SUCCESS) {
wmi_err("dcc_stats_indicate failed");
status = -EINVAL;
} else {
status = 0;
}
} else {
wmi_err("No dcc_stats_indicate callback");
status = -EINVAL;
}
qdf_mem_free(response);
return QDF_STATUS_SUCCESS;
}
/**
* fake_dcc_update_ndl_cmd_tlv() - command to update the NDL data
* @wmi_handle: pointer to the wmi handle
* @update_ndl_param: pointer to the request parameters
*
* Return: 0 on success
*/
static QDF_STATUS fake_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_dcc_update_ndl_param *update_ndl_param)
{
QDF_STATUS status;
struct wlan_objmgr_psoc *psoc;
struct wlan_ocb_rx_ops *ocb_rx_ops;
ol_scn_t scn = (ol_scn_t) wmi_handle->scn_handle;
struct ocb_dcc_update_ndl_response *resp;
wmi_debug("called");
/* Allocate and populate the response */
resp = qdf_mem_malloc(sizeof(*resp));
if (!resp)
return -ENOMEM;
resp->vdev_id = update_ndl_param->vdev_id;
resp->status = 0;
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
wmi_err("null psoc");
return -EINVAL;
}
ocb_rx_ops = target_if_ocb_get_rx_ops(psoc);
if (ocb_rx_ops->ocb_dcc_ndl_update) {
status = ocb_rx_ops->ocb_dcc_ndl_update(psoc, resp);
if (status != QDF_STATUS_SUCCESS) {
wmi_err("dcc_ndl_update failed");
status = -EINVAL;
} else {
status = 0;
}
} else {
wmi_err("No dcc_ndl_update callback");
status = -EINVAL;
}
qdf_mem_free(resp);
return QDF_STATUS_SUCCESS;
}
/**
* fake_ocb_set_config_cmd_tlv() - send the OCB config to the FW
* @wmi_handle: pointer to the wmi handle
* @config: the OCB configuration
*
* Return: 0 on success
*/
static QDF_STATUS fake_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_config *config)
{
u32 i;
QDF_STATUS status;
struct wlan_objmgr_psoc *psoc;
struct wlan_ocb_rx_ops *ocb_rx_ops;
ol_scn_t scn = (ol_scn_t) wmi_handle->scn_handle;
wmi_debug("vdev_id=%d, channel_count=%d, schedule_size=%d, flag=%x",
config->vdev_id, config->channel_count,
config->schedule_size, config->flags);
for (i = 0; i < config->channel_count; i++) {
wmi_debug("channel info for channel %d"
" chan_freq=%d, bandwidth=%d, " QDF_MAC_ADDR_FMT
" max_pwr=%d, min_pwr=%d, reg_pwr=%d, antenna_max=%d, "
"flags=%d", i, config->channels[i].chan_freq,
config->channels[i].bandwidth,
QDF_MAC_ADDR_REF(
config->channels[i].mac_address.bytes),
config->channels[i].max_pwr,
config->channels[i].min_pwr,
config->channels[i].reg_pwr,
config->channels[i].antenna_max,
config->channels[i].flags);
}
for (i = 0; i < config->schedule_size; i++) {
wmi_debug("schedule info for channel %d: "
"chan_fre=%d, total_duration=%d, guard_intreval=%d",
i, config->schedule[i].chan_freq,
config->schedule[i].total_duration,
config->schedule[i].guard_interval);
}
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
wmi_err("null psoc");
return -EINVAL;
}
ocb_rx_ops = target_if_ocb_get_rx_ops(psoc);
if (ocb_rx_ops->ocb_set_config_status) {
status = ocb_rx_ops->ocb_set_config_status(psoc, 0);
if (status != QDF_STATUS_SUCCESS) {
wmi_err("ocb_set_config_status failed");
return -EINVAL;
}
} else {
wmi_err("No ocb_set_config_status callback");
return -EINVAL;
}
return QDF_STATUS_SUCCESS;
}
/**
* fake_ocb_stop_timing_advert_cmd_tlv() - stop sending the
* timing advertisement frames on a channel
* @wmi_handle: pointer to the wmi handle
* @timing_advert: pointer to the timing advertisement struct
*
* Return: 0 on success
*/
static QDF_STATUS fake_ocb_stop_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_timing_advert_param *timing_advert)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_ocb_start_timing_advert_cmd_tlv() - start sending the
* timing advertisement frames on a channel
* @wmi_handle: pointer to the wmi handle
* @timing_advert: pointer to the timing advertisement struct
*
* Return: 0 on success
*/
static QDF_STATUS
fake_ocb_start_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
struct ocb_timing_advert_param *timing_advert)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_peer_create_cmd_tlv() - send peer create command to fw
* @wmi: wmi handle
* @param: peer create parameters
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS fake_peer_create_cmd_tlv(wmi_unified_t wmi,
struct peer_create_params *param)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_peer_delete_cmd_tlv() - send PEER delete command to fw
* @wmi: wmi handle
* @peer_addr: peer mac addr
* @param: peer delete parameters
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS fake_peer_delete_cmd_tlv(wmi_unified_t wmi,
uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
struct peer_delete_cmd_params *param)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_vdev_start_cmd_tlv() - send vdev start request to fw
* @wmi_handle: wmi handle
* @req: vdev start params
*
* Return: QDF status
*/
static QDF_STATUS fake_vdev_start_cmd_tlv(wmi_unified_t wmi_handle,
struct vdev_start_params *req)
{
tp_wma_handle wma = (tp_wma_handle) wmi_handle->scn_handle;
wmi_debug("vdev_id %d freq %d chanmode %d ch_info is_dfs %d "
"beacon interval %d dtim %d center_chan %d center_freq2 %d "
"max_txpow: 0x%x "
"Tx SS %d, Rx SS %d, ldpc_rx: %d, cac %d, regd %d, HE ops: %d",
(int)req->vdev_id, req->channel.mhz,
req->channel.phy_mode,
(int)req->channel.dfs_set, req->beacon_intval, req->dtim_period,
req->channel.cfreq1, req->channel.cfreq2,
req->channel.maxregpower,
req->preferred_tx_streams, req->preferred_rx_streams,
(int)req->ldpc_rx_enabled, req->cac_duration_ms,
req->regdomain, req->he_ops);
ucfg_ocb_config_channel(wma->pdev);
return QDF_STATUS_SUCCESS;
}
/**
* fake_vdev_down_cmd_tlv() - send vdev down command to fw
* @wmi: wmi handle
* @vdev_id: vdev id
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS fake_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_vdev_set_param_cmd_tlv() - WMI vdev set parameter function
* @wmi_handle: handle to WMI.
* @param: pointer to hold vdev set parameter
*
* Return: 0 on success and -ve on failure.
*/
static QDF_STATUS fake_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
struct vdev_set_params *param)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv() -
* faked API to enable/disable mcc scheduler
* @wmi_handle: wmi handle
* @mcc_adaptive_scheduler: enable/disable
* @pdev_id: pdev ID
*
* This function enable/disable mcc adaptive scheduler in fw.
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS fake_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv(
wmi_unified_t wmi_handle, uint32_t mcc_adaptive_scheduler,
uint32_t pdev_id)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
/**
* fake_process_set_ie_info_cmd_tlv() - Function to send IE info to firmware
* @wmi_handle: Pointer to WMi handle
* @ie_info: Pointer for ie info
*
* This function sends IE information to firmware
*
* Return: QDF_STATUS_SUCCESS for success otherwise failure
*
*/
static QDF_STATUS fake_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
struct vdev_ie_info_param *ie_info)
{
wmi_debug("called");
return QDF_STATUS_SUCCESS;
}
void wmi_ocb_ut_attach(struct wmi_unified *wmi_handle)
{
struct wmi_ops *wmi_ops;
if (!wmi_handle) {
wmi_err("null wmi handle");
return;
}
wmi_ops = wmi_handle->ops;
wmi_ops->send_vdev_create_cmd = fake_vdev_create_cmd_tlv;
wmi_ops->send_vdev_delete_cmd = fake_vdev_delete_cmd_tlv;
wmi_ops->send_vdev_down_cmd = fake_vdev_down_cmd_tlv;
wmi_ops->send_vdev_start_cmd = fake_vdev_start_cmd_tlv;
wmi_ops->send_peer_create_cmd = fake_peer_create_cmd_tlv;
wmi_ops->send_peer_delete_cmd = fake_peer_delete_cmd_tlv;
wmi_ops->send_vdev_set_param_cmd = fake_vdev_set_param_cmd_tlv;
wmi_ops->send_ocb_set_utc_time_cmd = fake_ocb_set_utc_time_cmd_tlv;
wmi_ops->send_ocb_get_tsf_timer_cmd = fake_ocb_get_tsf_timer_cmd_tlv;
wmi_ops->send_dcc_clear_stats_cmd = fake_dcc_clear_stats_cmd_tlv;
wmi_ops->send_dcc_get_stats_cmd = fake_dcc_get_stats_cmd_tlv;
wmi_ops->send_dcc_update_ndl_cmd = fake_dcc_update_ndl_cmd_tlv;
wmi_ops->send_ocb_set_config_cmd = fake_ocb_set_config_cmd_tlv;
wmi_ops->send_ocb_stop_timing_advert_cmd =
fake_ocb_stop_timing_advert_cmd_tlv;
wmi_ops->send_ocb_start_timing_advert_cmd =
fake_ocb_start_timing_advert_cmd_tlv;
wmi_ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd =
fake_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv;
wmi_ops->send_process_set_ie_info_cmd =
fake_process_set_ie_info_cmd_tlv;
}

126
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_p2p_api.c Normal file
View File

@@ -0,0 +1,126 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to P2P component.
*/
#include <wmi_unified_priv.h>
#include <wmi_unified_p2p_api.h>
QDF_STATUS wmi_unified_set_p2pgo_oppps_req(wmi_unified_t wmi_handle,
struct p2p_ps_params *oppps)
{
if (wmi_handle->ops->send_set_p2pgo_oppps_req_cmd)
return wmi_handle->ops->send_set_p2pgo_oppps_req_cmd(wmi_handle,
oppps);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_p2pgo_noa_req_cmd(wmi_unified_t wmi_handle,
struct p2p_ps_params *noa)
{
if (wmi_handle->ops->send_set_p2pgo_noa_req_cmd)
return wmi_handle->ops->send_set_p2pgo_noa_req_cmd(wmi_handle,
noa);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_p2p_noa_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct p2p_noa_info *param)
{
if (!wmi_handle) {
wmi_err("wmi handle is null");
return QDF_STATUS_E_INVAL;
}
if (wmi_handle->ops->extract_p2p_noa_ev_param)
return wmi_handle->ops->extract_p2p_noa_ev_param(
wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_mac_addr_rx_filter_evt_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct p2p_set_mac_filter_evt *param)
{
if (!wmi_handle) {
wmi_err("wmi handle is null");
return QDF_STATUS_E_INVAL;
}
if (wmi_handle->ops->extract_mac_addr_rx_filter_evt_param)
return wmi_handle->ops->extract_mac_addr_rx_filter_evt_param(
wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
QDF_STATUS wmi_unified_p2p_lo_start_cmd(wmi_unified_t wmi_handle,
struct p2p_lo_start *param)
{
if (!wmi_handle) {
wmi_err("wmi handle is null");
return QDF_STATUS_E_INVAL;
}
if (wmi_handle->ops->send_p2p_lo_start_cmd)
return wmi_handle->ops->send_p2p_lo_start_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_p2p_lo_stop_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id)
{
if (!wmi_handle) {
wmi_err("wmi handle is null");
return QDF_STATUS_E_INVAL;
}
if (wmi_handle->ops->send_p2p_lo_stop_cmd)
return wmi_handle->ops->send_p2p_lo_stop_cmd(wmi_handle,
vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_p2p_lo_stop_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct p2p_lo_event *param)
{
if (!wmi_handle) {
wmi_err("wmi handle is null");
return QDF_STATUS_E_INVAL;
}
if (wmi_handle->ops->extract_p2p_lo_stop_ev_param)
return wmi_handle->ops->extract_p2p_lo_stop_ev_param(
wmi_handle, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
#endif /* End of FEATURE_P2P_LISTEN_OFFLOAD*/

431
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_p2p_tlv.c Normal file
View File

@@ -0,0 +1,431 @@
/*
* Copyright (c) 2013-2018, 2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_p2p_api.h>
/**
* send_set_p2pgo_noa_req_cmd_tlv() - send p2p go noa request to fw
* @wmi_handle: wmi handle
* @noa: p2p power save parameters
*
* Return: QDF status
*/
static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
struct p2p_ps_params *noa)
{
wmi_p2p_set_noa_cmd_fixed_param *cmd;
wmi_p2p_noa_descriptor *noa_discriptor;
wmi_buf_t buf;
uint8_t *buf_ptr;
uint16_t len;
QDF_STATUS status;
uint32_t duration;
len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
status = QDF_STATUS_E_FAILURE;
goto end;
}
buf_ptr = (uint8_t *)wmi_buf_data(buf);
cmd = (wmi_p2p_set_noa_cmd_fixed_param *)buf_ptr;
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_p2p_set_noa_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_p2p_set_noa_cmd_fixed_param));
duration = (noa->count == 1) ? noa->single_noa_duration : noa->duration;
cmd->vdev_id = noa->session_id;
cmd->enable = (duration) ? true : false;
cmd->num_noa = 1;
WMITLV_SET_HDR((buf_ptr + sizeof(wmi_p2p_set_noa_cmd_fixed_param)),
WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_p2p_noa_descriptor));
noa_discriptor = (wmi_p2p_noa_descriptor *)(buf_ptr +
sizeof
(wmi_p2p_set_noa_cmd_fixed_param)
+ WMI_TLV_HDR_SIZE);
WMITLV_SET_HDR(&noa_discriptor->tlv_header,
WMITLV_TAG_STRUC_wmi_p2p_noa_descriptor,
WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_noa_descriptor));
noa_discriptor->type_count = noa->count;
noa_discriptor->duration = duration;
noa_discriptor->interval = noa->interval;
noa_discriptor->start_time = noa->start;
wmi_debug("SET P2P GO NOA:vdev_id:%d count:%d duration:%d interval:%d start:%d",
cmd->vdev_id, noa->count, noa_discriptor->duration,
noa->interval, noa->start);
wmi_mtrace(WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID);
if (QDF_IS_STATUS_ERROR(status)) {
wmi_err("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID");
wmi_buf_free(buf);
}
end:
return status;
}
/**
* send_set_p2pgo_oppps_req_cmd_tlv() - send p2p go opp power save request to fw
* @wmi_handle: wmi handle
* @oppps: p2p opp power save parameters
*
* Return: QDF status
*/
static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
struct p2p_ps_params *oppps)
{
wmi_p2p_set_oppps_cmd_fixed_param *cmd;
wmi_buf_t buf;
QDF_STATUS status;
buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!buf) {
status = QDF_STATUS_E_FAILURE;
goto end;
}
cmd = (wmi_p2p_set_oppps_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_p2p_set_oppps_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_p2p_set_oppps_cmd_fixed_param));
cmd->vdev_id = oppps->session_id;
if (oppps->ctwindow)
WMI_UNIFIED_OPPPS_ATTR_ENABLED_SET(cmd);
WMI_UNIFIED_OPPPS_ATTR_CTWIN_SET(cmd, oppps->ctwindow);
wmi_debug("SET P2P GO OPPPS:vdev_id:%d ctwindow:%d",
cmd->vdev_id, oppps->ctwindow);
wmi_mtrace(WMI_P2P_SET_OPPPS_PARAM_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
WMI_P2P_SET_OPPPS_PARAM_CMDID);
if (QDF_IS_STATUS_ERROR(status)) {
wmi_err("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID");
wmi_buf_free(buf);
}
end:
return status;
}
/**
* extract_p2p_noa_ev_param_tlv() - extract p2p noa information from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold p2p noa info
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_p2p_noa_ev_param_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
struct p2p_noa_info *param)
{
WMI_P2P_NOA_EVENTID_param_tlvs *param_tlvs;
wmi_p2p_noa_event_fixed_param *fixed_param;
uint8_t i;
wmi_p2p_noa_info *wmi_noa_info;
uint8_t *buf_ptr;
uint32_t descriptors;
param_tlvs = (WMI_P2P_NOA_EVENTID_param_tlvs *)evt_buf;
if (!param_tlvs) {
wmi_err("Invalid P2P NoA event buffer");
return QDF_STATUS_E_INVAL;
}
if (!param) {
wmi_err("noa information param is null");
return QDF_STATUS_E_INVAL;
}
fixed_param = param_tlvs->fixed_param;
buf_ptr = (uint8_t *) fixed_param;
buf_ptr += sizeof(wmi_p2p_noa_event_fixed_param);
wmi_noa_info = (wmi_p2p_noa_info *) (buf_ptr);
if (!WMI_UNIFIED_NOA_ATTR_IS_MODIFIED(wmi_noa_info)) {
wmi_err("noa attr is not modified");
return QDF_STATUS_E_INVAL;
}
param->vdev_id = fixed_param->vdev_id;
param->index =
(uint8_t)WMI_UNIFIED_NOA_ATTR_INDEX_GET(wmi_noa_info);
param->opps_ps =
(uint8_t)WMI_UNIFIED_NOA_ATTR_OPP_PS_GET(wmi_noa_info);
param->ct_window =
(uint8_t)WMI_UNIFIED_NOA_ATTR_CTWIN_GET(wmi_noa_info);
descriptors = WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET(wmi_noa_info);
param->num_desc = (uint8_t)descriptors;
if (param->num_desc > WMI_P2P_MAX_NOA_DESCRIPTORS) {
wmi_err("Invalid num desc: %d", param->num_desc);
return QDF_STATUS_E_INVAL;
}
wmi_debug("index %u, opps_ps %u, ct_window %u, num_descriptors = %u",
param->index, param->opps_ps, param->ct_window,
param->num_desc);
for (i = 0; i < param->num_desc; i++) {
param->noa_desc[i].type_count =
(uint8_t)wmi_noa_info->noa_descriptors[i].
type_count;
param->noa_desc[i].duration =
wmi_noa_info->noa_descriptors[i].duration;
param->noa_desc[i].interval =
wmi_noa_info->noa_descriptors[i].interval;
param->noa_desc[i].start_time =
wmi_noa_info->noa_descriptors[i].start_time;
wmi_debug("NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u",
i, param->noa_desc[i].type_count,
param->noa_desc[i].duration,
param->noa_desc[i].interval,
param->noa_desc[i].start_time);
}
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_mac_addr_rx_filter_evt_param_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
struct p2p_set_mac_filter_evt *param)
{
WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID_param_tlvs *param_buf;
wmi_vdev_add_mac_addr_to_rx_filter_status_event_fixed_param *event;
param_buf =
(WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID_param_tlvs *)
evt_buf;
if (!param_buf) {
wmi_err("Invalid action frame filter mac event");
return QDF_STATUS_E_INVAL;
}
event = param_buf->fixed_param;
if (!event) {
wmi_err("Invalid fixed param");
return QDF_STATUS_E_INVAL;
}
param->vdev_id = event->vdev_id;
param->status = event->status;
return QDF_STATUS_SUCCESS;
}
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
/**
* send_p2p_lo_start_cmd_tlv() - send p2p lo start request to fw
* @wmi_handle: wmi handle
* @param: p2p listen offload start parameters
*
* Return: QDF status
*/
static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle,
struct p2p_lo_start *param)
{
wmi_buf_t buf;
wmi_p2p_lo_start_cmd_fixed_param *cmd;
int32_t len = sizeof(*cmd);
uint8_t *buf_ptr;
QDF_STATUS status;
int device_types_len_aligned;
int probe_resp_len_aligned;
if (!param) {
wmi_err("lo start param is null");
return QDF_STATUS_E_INVAL;
}
wmi_debug("vdev_id: %d", param->vdev_id);
device_types_len_aligned =
qdf_roundup(param->dev_types_len,
sizeof(uint32_t));
probe_resp_len_aligned =
qdf_roundup(param->probe_resp_len,
sizeof(uint32_t));
len += 2 * WMI_TLV_HDR_SIZE + device_types_len_aligned +
probe_resp_len_aligned;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_p2p_lo_start_cmd_fixed_param *)wmi_buf_data(buf);
buf_ptr = (uint8_t *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_p2p_lo_start_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_lo_start_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->ctl_flags = param->ctl_flags;
cmd->channel = param->freq;
cmd->period = param->period;
cmd->interval = param->interval;
cmd->count = param->count;
cmd->device_types_len = param->dev_types_len;
cmd->prob_resp_len = param->probe_resp_len;
buf_ptr += sizeof(wmi_p2p_lo_start_cmd_fixed_param);
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
device_types_len_aligned);
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, param->device_types,
param->dev_types_len);
buf_ptr += device_types_len_aligned;
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
probe_resp_len_aligned);
buf_ptr += WMI_TLV_HDR_SIZE;
qdf_mem_copy(buf_ptr, param->probe_resp_tmplt,
param->probe_resp_len);
wmi_debug("Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d",
cmd->channel, cmd->period, cmd->interval, cmd->count);
wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_START_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle,
buf, len,
WMI_P2P_LISTEN_OFFLOAD_START_CMDID);
if (status != QDF_STATUS_SUCCESS) {
wmi_err("Failed to send p2p lo start: %d", status);
wmi_buf_free(buf);
return status;
}
wmi_debug("Successfully sent WMI_P2P_LO_START");
return QDF_STATUS_SUCCESS;
}
/**
* send_p2p_lo_stop_cmd_tlv() - send p2p lo stop request to fw
* @wmi_handle: wmi handle
* @vdev_id: vdev identifier
*
* Return: QDF status
*/
static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t vdev_id)
{
wmi_buf_t buf;
wmi_p2p_lo_stop_cmd_fixed_param *cmd;
int32_t len;
QDF_STATUS status;
wmi_debug("vdev_id: %d", vdev_id);
len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_p2p_lo_stop_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_p2p_lo_stop_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_lo_stop_cmd_fixed_param));
cmd->vdev_id = vdev_id;
wmi_debug("Sending WMI_P2P_LO_STOP command");
wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID, cmd->vdev_id, 0);
status = wmi_unified_cmd_send(wmi_handle,
buf, len,
WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID);
if (status != QDF_STATUS_SUCCESS) {
wmi_err("Failed to send p2p lo stop: %d", status);
wmi_buf_free(buf);
return status;
}
wmi_debug("Successfully sent WMI_P2P_LO_STOP");
return QDF_STATUS_SUCCESS;
}
/**
* extract_p2p_lo_stop_ev_param_tlv() - extract p2p lo stop
* information from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @param: Pointer to hold p2p lo stop event information
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_p2p_lo_stop_ev_param_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
struct p2p_lo_event *param)
{
WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *param_tlvs;
wmi_p2p_lo_stopped_event_fixed_param *lo_param;
param_tlvs = (WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *)
evt_buf;
if (!param_tlvs) {
wmi_err("Invalid P2P lo stop event buffer");
return QDF_STATUS_E_INVAL;
}
if (!param) {
wmi_err("lo stop event param is null");
return QDF_STATUS_E_INVAL;
}
lo_param = param_tlvs->fixed_param;
param->vdev_id = lo_param->vdev_id;
param->reason_code = lo_param->reason;
wmi_debug("vdev_id:%d, reason:%d",
param->vdev_id, param->reason_code);
return QDF_STATUS_SUCCESS;
}
void wmi_p2p_listen_offload_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_p2p_lo_start_cmd = send_p2p_lo_start_cmd_tlv;
ops->send_p2p_lo_stop_cmd = send_p2p_lo_stop_cmd_tlv;
ops->extract_p2p_lo_stop_ev_param =
extract_p2p_lo_stop_ev_param_tlv;
}
#endif /* FEATURE_P2P_LISTEN_OFFLOAD */
void wmi_p2p_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_set_p2pgo_oppps_req_cmd = send_set_p2pgo_oppps_req_cmd_tlv;
ops->send_set_p2pgo_noa_req_cmd = send_set_p2pgo_noa_req_cmd_tlv;
ops->extract_p2p_noa_ev_param = extract_p2p_noa_ev_param_tlv;
ops->extract_mac_addr_rx_filter_evt_param =
extract_mac_addr_rx_filter_evt_param_tlv,
wmi_p2p_listen_offload_attach_tlv(wmi_handle);
}

377
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_pmo_api.c Normal file
View File

@@ -0,0 +1,377 @@
/*
* Copyright (c) 2017-2019, 2021 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to PMO component.
*/
#include "ol_if_athvar.h"
#include "ol_defines.h"
#include "wmi_unified_priv.h"
#include "wmi_unified_pmo_api.h"
#include "wlan_pmo_hw_filter_public_struct.h"
#ifdef FEATURE_WLAN_D0WOW
QDF_STATUS wmi_unified_d0wow_enable_send(wmi_unified_t wmi_handle,
uint8_t mac_id)
{
if (wmi_handle->ops->send_d0wow_enable_cmd)
return wmi_handle->ops->send_d0wow_enable_cmd(wmi_handle,
mac_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_d0wow_disable_send(wmi_unified_t wmi_handle,
uint8_t mac_id)
{
if (wmi_handle->ops->send_d0wow_disable_cmd)
return wmi_handle->ops->send_d0wow_disable_cmd(wmi_handle,
mac_id);
return QDF_STATUS_E_FAILURE;
}
#endif /* FEATURE_WLAN_D0WOW */
QDF_STATUS wmi_unified_add_wow_wakeup_event_cmd(wmi_unified_t wmi_handle,
uint32_t vdev_id,
uint32_t *bitmap,
bool enable)
{
if (wmi_handle->ops->send_add_wow_wakeup_event_cmd)
return wmi_handle->ops->send_add_wow_wakeup_event_cmd(
wmi_handle, vdev_id, bitmap, enable);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_wow_patterns_to_fw_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id, uint8_t ptrn_id,
const uint8_t *ptrn, uint8_t ptrn_len,
uint8_t ptrn_offset, const uint8_t *mask,
uint8_t mask_len, bool user,
uint8_t default_patterns)
{
if (wmi_handle->ops->send_wow_patterns_to_fw_cmd)
return wmi_handle->ops->send_wow_patterns_to_fw_cmd(wmi_handle,
vdev_id, ptrn_id, ptrn,
ptrn_len, ptrn_offset, mask,
mask_len, user, default_patterns);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_enable_arp_ns_offload_cmd(
wmi_unified_t wmi_handle,
struct pmo_arp_offload_params *arp_offload_req,
struct pmo_ns_offload_params *ns_offload_req,
uint8_t vdev_id)
{
if (wmi_handle->ops->send_enable_arp_ns_offload_cmd)
return wmi_handle->ops->send_enable_arp_ns_offload_cmd(
wmi_handle,
arp_offload_req, ns_offload_req, vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_add_clear_mcbc_filter_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id,
struct qdf_mac_addr multicast_addr,
bool clear_list)
{
if (wmi_handle->ops->send_add_clear_mcbc_filter_cmd)
return wmi_handle->ops->send_add_clear_mcbc_filter_cmd(
wmi_handle, vdev_id, multicast_addr, clear_list);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_multiple_add_clear_mcbc_filter_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id,
struct pmo_mcast_filter_params *filter_param)
{
if (wmi_handle->ops->send_multiple_add_clear_mcbc_filter_cmd)
return wmi_handle->ops->send_multiple_add_clear_mcbc_filter_cmd(
wmi_handle, vdev_id, filter_param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_conf_hw_filter_cmd(wmi_unified_t wmi_handle,
struct pmo_hw_filter_params *req)
{
if (!wmi_handle->ops->send_conf_hw_filter_cmd)
return QDF_STATUS_E_NOSUPPORT;
return wmi_handle->ops->send_conf_hw_filter_cmd(wmi_handle, req);
}
QDF_STATUS wmi_unified_send_gtk_offload_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
struct pmo_gtk_req *params,
bool enable_offload,
uint32_t gtk_offload_opcode)
{
if (wmi_handle->ops->send_gtk_offload_cmd)
return wmi_handle->ops->send_gtk_offload_cmd(wmi_handle,
vdev_id, params, enable_offload,
gtk_offload_opcode);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_IGMP_OFFLOAD
QDF_STATUS
wmi_unified_send_igmp_offload_cmd(wmi_unified_t wmi_handle,
struct pmo_igmp_offload_req *pmo_igmp_req)
{
if (wmi_handle->ops->send_igmp_offload_cmd)
return wmi_handle->ops->send_igmp_offload_cmd(wmi_handle,
pmo_igmp_req);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS wmi_unified_process_gtk_offload_getinfo_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint64_t offload_req_opcode)
{
if (wmi_handle->ops->send_process_gtk_offload_getinfo_cmd)
return wmi_handle->ops->send_process_gtk_offload_getinfo_cmd(
wmi_handle, vdev_id, offload_req_opcode);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_enable_enhance_multicast_offload_cmd(
wmi_unified_t wmi_handle, uint8_t vdev_id, bool action)
{
struct wmi_ops *ops;
ops = wmi_handle->ops;
if (ops && ops->send_enable_enhance_multicast_offload_cmd)
return ops->send_enable_enhance_multicast_offload_cmd(
wmi_handle, vdev_id, action);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_gtk_rsp_event(
wmi_unified_t wmi_handle, void *evt_buf,
struct pmo_gtk_rsp_params *gtk_rsp_param, uint32_t len)
{
if (wmi_handle->ops->extract_gtk_rsp_event)
return wmi_handle->ops->extract_gtk_rsp_event(wmi_handle,
evt_buf, gtk_rsp_param, len);
return QDF_STATUS_E_FAILURE;
}
#ifdef FEATURE_WLAN_RA_FILTERING
QDF_STATUS wmi_unified_wow_sta_ra_filter_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint8_t default_pattern,
uint16_t rate_limit_interval)
{
if (wmi_handle->ops->send_wow_sta_ra_filter_cmd)
return wmi_handle->ops->send_wow_sta_ra_filter_cmd(wmi_handle,
vdev_id, default_pattern, rate_limit_interval);
return QDF_STATUS_E_FAILURE;
}
#endif /* FEATURE_WLAN_RA_FILTERING */
QDF_STATUS wmi_unified_action_frame_patterns_cmd(
wmi_unified_t wmi_handle,
struct pmo_action_wakeup_set_params *action_params)
{
if (wmi_handle->ops->send_action_frame_patterns_cmd)
return wmi_handle->ops->send_action_frame_patterns_cmd(
wmi_handle, action_params);
return QDF_STATUS_E_FAILURE;
}
#ifdef FEATURE_WLAN_LPHB
QDF_STATUS wmi_unified_lphb_config_hbenable_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_enable_cmd_fixed_param *params)
{
if (wmi_handle->ops->send_lphb_config_hbenable_cmd)
return wmi_handle->ops->send_lphb_config_hbenable_cmd(
wmi_handle, params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_lphb_config_tcp_params_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_tcp_params_cmd_fixed_param *lphb_conf_req)
{
if (wmi_handle->ops->send_lphb_config_tcp_params_cmd)
return wmi_handle->ops->send_lphb_config_tcp_params_cmd(
wmi_handle, lphb_conf_req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_lphb_config_tcp_pkt_filter_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *g_hb_tcp_filter_fp)
{
if (wmi_handle->ops->send_lphb_config_tcp_pkt_filter_cmd)
return wmi_handle->ops->send_lphb_config_tcp_pkt_filter_cmd(
wmi_handle, g_hb_tcp_filter_fp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_lphb_config_udp_params_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_udp_params_cmd_fixed_param *lphb_conf_req)
{
if (wmi_handle->ops->send_lphb_config_udp_params_cmd)
return wmi_handle->ops->send_lphb_config_udp_params_cmd(
wmi_handle, lphb_conf_req);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_lphb_config_udp_pkt_filter_cmd(
wmi_unified_t wmi_handle,
wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req)
{
if (wmi_handle->ops->send_lphb_config_udp_pkt_filter_cmd)
return wmi_handle->ops->send_lphb_config_udp_pkt_filter_cmd(
wmi_handle, lphb_conf_req);
return QDF_STATUS_E_FAILURE;
}
#endif /* FEATURE_WLAN_LPHB */
#ifdef WLAN_FEATURE_PACKET_FILTERING
QDF_STATUS
wmi_unified_enable_disable_packet_filter_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id, bool enable)
{
if (wmi_handle->ops->send_enable_disable_packet_filter_cmd)
return wmi_handle->ops->send_enable_disable_packet_filter_cmd(
wmi_handle, vdev_id, enable);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_config_packet_filter_cmd(
wmi_unified_t wmi_handle,
uint8_t vdev_id, struct pmo_rcv_pkt_fltr_cfg *rcv_filter_param,
uint8_t filter_id, bool enable)
{
if (wmi_handle->ops->send_config_packet_filter_cmd)
return wmi_handle->ops->send_config_packet_filter_cmd(
wmi_handle, vdev_id, rcv_filter_param, filter_id, enable);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_FEATURE_PACKET_FILTERING */
QDF_STATUS wmi_unified_wow_delete_pattern_cmd(wmi_unified_t wmi_handle,
uint8_t ptrn_id,
uint8_t vdev_id)
{
if (wmi_handle->ops->send_wow_delete_pattern_cmd)
return wmi_handle->ops->send_wow_delete_pattern_cmd(wmi_handle,
ptrn_id,
vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_host_wakeup_ind_to_fw_cmd(wmi_unified_t wmi_handle,
bool tx_pending_ind)
{
if (wmi_handle->ops->send_host_wakeup_ind_to_fw_cmd)
return wmi_handle->ops->send_host_wakeup_ind_to_fw_cmd
(wmi_handle,
tx_pending_ind);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_wow_timer_pattern_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint32_t cookie, uint32_t time)
{
if (wmi_handle->ops->send_wow_timer_pattern_cmd)
return wmi_handle->ops->send_wow_timer_pattern_cmd(wmi_handle,
vdev_id, cookie, time);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
QDF_STATUS wmi_unified_enable_ext_wow_cmd(wmi_unified_t wmi_handle,
struct ext_wow_params *params)
{
if (wmi_handle->ops->send_enable_ext_wow_cmd)
return wmi_handle->ops->send_enable_ext_wow_cmd(wmi_handle,
params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_app_type2_params_in_fw_cmd(
wmi_unified_t wmi_handle,
struct app_type2_params *appType2Params)
{
if (wmi_handle->ops->send_set_app_type2_params_in_fw_cmd)
return wmi_handle->ops->send_set_app_type2_params_in_fw_cmd(
wmi_handle, appType2Params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_app_type1_params_in_fw_cmd(
wmi_unified_t wmi_handle,
struct app_type1_params *app_type1_params)
{
if (wmi_handle->ops->send_app_type1_params_in_fw_cmd)
return wmi_handle->ops->send_app_type1_params_in_fw_cmd(
wmi_handle, app_type1_params);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_FEATURE_EXTWOW_SUPPORT */
#ifdef WLAN_FEATURE_ICMP_OFFLOAD
QDF_STATUS wmi_unified_config_icmp_offload_cmd(wmi_unified_t wmi_handle,
struct pmo_icmp_offload *pmo_icmp_req)
{
if (wmi_handle->ops->send_icmp_offload_config_cmd)
return wmi_handle->ops->send_icmp_offload_config_cmd(
wmi_handle, pmo_icmp_req);
return QDF_STATUS_E_FAILURE;
}
#endif

2251
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_pmo_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

170
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_reg_api.c Normal file
View File

@@ -0,0 +1,170 @@
/*
* Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to Regulatory component.
*/
#include <qdf_status.h>
#include <qdf_module.h>
#include <wmi_unified_api.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_reg_api.h>
QDF_STATUS wmi_extract_reg_chan_list_update_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct cur_regulatory_info *reg_info,
uint32_t len)
{
if (wmi_handle && wmi_handle->ops->extract_reg_chan_list_update_event)
return wmi_handle->ops->extract_reg_chan_list_update_event
(wmi_handle,
evt_buf, reg_info, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_reg_chan_list_update_event);
#ifdef CONFIG_BAND_6GHZ
QDF_STATUS wmi_extract_reg_chan_list_ext_update_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct cur_regulatory_info *reg_info,
uint32_t len)
{
if (wmi_handle &&
wmi_handle->ops->extract_reg_chan_list_ext_update_event)
return wmi_handle->ops->extract_reg_chan_list_ext_update_event
(wmi_handle, evt_buf, reg_info, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_reg_chan_list_ext_update_event);
#ifdef CONFIG_AFC_SUPPORT
QDF_STATUS wmi_extract_afc_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct afc_regulatory_info *afc_info,
uint32_t len)
{
if (wmi_handle &&
wmi_handle->ops->extract_afc_event)
return wmi_handle->ops->extract_afc_event(wmi_handle, evt_buf,
afc_info, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_afc_event);
#endif
#endif
/*
* wmi_unified_send_start_11d_scan_cmd() - start 11d scan
* @wmi_handle: wmi handle
* @start_11d_scan: pointer to 11d scan start req.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_start_11d_scan_cmd(wmi_unified_t wmi_handle,
struct reg_start_11d_scan_req *start_11d_scan)
{
if (wmi_handle->ops->send_start_11d_scan_cmd)
return wmi_handle->ops->send_start_11d_scan_cmd(wmi_handle,
start_11d_scan);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_unified_send_start_11d_scan_cmd);
/*
* wmi_unified_send_stop_11d_scan_cmd() - stop 11d scan
* @wmi_handle: wmi handle
* @stop_11d_scan: pointer to 11d scan stop req.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_stop_11d_scan_cmd(wmi_unified_t wmi_handle,
struct reg_stop_11d_scan_req *stop_11d_scan)
{
if (wmi_handle->ops->send_stop_11d_scan_cmd)
return wmi_handle->ops->send_stop_11d_scan_cmd(wmi_handle,
stop_11d_scan);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_unified_send_stop_11d_scan_cmd);
QDF_STATUS wmi_extract_reg_11d_new_cc_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct reg_11d_new_country *reg_11d_new_cc,
uint32_t len)
{
if (wmi_handle && wmi_handle->ops->extract_reg_11d_new_country_event)
return wmi_handle->ops->extract_reg_11d_new_country_event(
wmi_handle, evt_buf, reg_11d_new_cc, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_reg_11d_new_cc_event);
QDF_STATUS wmi_unified_set_user_country_code_cmd_send(
wmi_unified_t wmi_handle,
uint8_t pdev_id, struct cc_regdmn_s *rd)
{
if (wmi_handle->ops->send_user_country_code_cmd)
return wmi_handle->ops->send_user_country_code_cmd(
wmi_handle, pdev_id, rd);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_unified_set_user_country_code_cmd_send);
QDF_STATUS wmi_extract_reg_ch_avoid_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct ch_avoid_ind_type *ch_avoid_ind,
uint32_t len)
{
if (wmi_handle && wmi_handle->ops->extract_reg_ch_avoid_event)
return wmi_handle->ops->extract_reg_ch_avoid_event(
wmi_handle, evt_buf, ch_avoid_ind, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_reg_ch_avoid_event);
QDF_STATUS wmi_extract_tgtr2p_table_event(
wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct r2p_table_update_status_obj *update_status,
uint32_t len)
{
if (wmi_handle &&
wmi_handle->ops->extract_tgtr2p_table_event)
return wmi_handle->ops->extract_tgtr2p_table_event(
wmi_handle, evt_buf, update_status, len);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_extract_tgtr2p_table_event);

418
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_sta_api.c Normal file
View File

@@ -0,0 +1,418 @@
/*
* Copyright (c) 2013-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to STA component.
*/
#include <wmi.h>
#include "wmi_unified_priv.h"
#include "wmi_unified_sta_api.h"
QDF_STATUS wmi_unified_set_sta_sa_query_param_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint32_t max_retries,
uint32_t retry_interval)
{
if (wmi_handle->ops->send_set_sta_sa_query_param_cmd)
return wmi_handle->ops->send_set_sta_sa_query_param_cmd(wmi_handle,
vdev_id, max_retries,
retry_interval);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_set_sta_keep_alive_cmd(wmi_unified_t wmi_handle,
struct sta_keep_alive_params *params)
{
if (wmi_handle->ops->send_set_sta_keep_alive_cmd)
return wmi_handle->ops->send_set_sta_keep_alive_cmd(wmi_handle,
params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_vdev_set_gtx_cfg_cmd(wmi_unified_t wmi_handle, uint32_t if_id,
struct wmi_gtx_config *gtx_info)
{
if (wmi_handle->ops->send_vdev_set_gtx_cfg_cmd)
return wmi_handle->ops->send_vdev_set_gtx_cfg_cmd(wmi_handle,
if_id,
gtx_info);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_process_dhcp_ind(
wmi_unified_t wmi_handle,
wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind)
{
if (wmi_handle->ops->send_process_dhcp_ind_cmd)
return wmi_handle->ops->send_process_dhcp_ind_cmd(wmi_handle,
ta_dhcp_ind);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_get_link_speed_cmd(wmi_unified_t wmi_handle,
wmi_mac_addr peer_macaddr)
{
if (wmi_handle->ops->send_get_link_speed_cmd)
return wmi_handle->ops->send_get_link_speed_cmd(wmi_handle,
peer_macaddr);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_fw_profiling_data_cmd(wmi_unified_t wmi_handle,
uint32_t cmd,
uint32_t value1,
uint32_t value2)
{
if (wmi_handle->ops->send_fw_profiling_cmd)
return wmi_handle->ops->send_fw_profiling_cmd(wmi_handle,
cmd,
value1,
value2);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_nat_keepalive_en_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id)
{
if (wmi_handle->ops->send_nat_keepalive_en_cmd)
return wmi_handle->ops->send_nat_keepalive_en_cmd(wmi_handle,
vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_wlm_latency_level_cmd(wmi_unified_t wmi_handle,
struct wlm_latency_level_param *param)
{
if (wmi_handle->ops->send_wlm_latency_level_cmd)
return wmi_handle->ops->send_wlm_latency_level_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_process_set_ie_info_cmd(wmi_unified_t wmi_handle,
struct vdev_ie_info_param *ie_info)
{
if (wmi_handle->ops->send_process_set_ie_info_cmd)
return wmi_handle->ops->send_process_set_ie_info_cmd(wmi_handle,
ie_info);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_base_macaddr_indicate_cmd(wmi_unified_t wmi_handle,
uint8_t *custom_addr)
{
if (wmi_handle->ops->send_set_base_macaddr_indicate_cmd)
return wmi_handle->ops->send_set_base_macaddr_indicate_cmd(
wmi_handle, custom_addr);
return QDF_STATUS_E_FAILURE;
}
#ifdef FEATURE_WLAN_TDLS
QDF_STATUS wmi_unified_set_tdls_offchan_mode_cmd(
wmi_unified_t wmi_handle,
struct tdls_channel_switch_params *chan_switch_params)
{
if (wmi_handle->ops->send_set_tdls_offchan_mode_cmd)
return wmi_handle->ops->send_set_tdls_offchan_mode_cmd(
wmi_handle, chan_switch_params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_update_fw_tdls_state_cmd(wmi_unified_t wmi_handle,
struct tdls_info *tdls_param,
enum wmi_tdls_state tdls_state)
{
if (wmi_handle->ops->send_update_fw_tdls_state_cmd)
return wmi_handle->ops->send_update_fw_tdls_state_cmd(
wmi_handle, tdls_param, tdls_state);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_update_tdls_peer_state_cmd(wmi_unified_t wmi_handle,
struct tdls_peer_update_state *peer_state,
uint32_t *ch_mhz)
{
if (wmi_handle->ops->send_update_tdls_peer_state_cmd)
return wmi_handle->ops->send_update_tdls_peer_state_cmd(wmi_handle,
peer_state, ch_mhz);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_vdev_tdls_ev_param(wmi_unified_t wmi_handle,
void *evt_buf,
struct tdls_event_info *param)
{
if (wmi_handle->ops->extract_vdev_tdls_ev_param)
return wmi_handle->ops->extract_vdev_tdls_ev_param(wmi_handle,
evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
#endif /* FEATURE_WLAN_TDLS */
#if defined(WLAN_FEATURE_ROAM_OFFLOAD) && defined(FEATURE_DENYLIST_MGR)
QDF_STATUS
wmi_unified_send_reject_ap_list(struct wmi_unified *wmi_handle,
struct reject_ap_params *reject_params)
{
if (wmi_handle->ops->send_reject_ap_list_cmd)
return wmi_handle->ops->send_reject_ap_list_cmd(wmi_handle,
reject_params);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS wmi_unified_send_sar_limit_cmd(wmi_unified_t wmi_handle,
struct sar_limit_cmd_params *params)
{
if (wmi_handle->ops->send_sar_limit_cmd)
return wmi_handle->ops->send_sar_limit_cmd(
wmi_handle,
params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_get_sar_limit_cmd(wmi_unified_t wmi_handle)
{
if (wmi_handle->ops->get_sar_limit_cmd)
return wmi_handle->ops->get_sar_limit_cmd(wmi_handle);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extract_sar_limit_event(wmi_unified_t wmi_handle,
uint8_t *evt_buf,
struct sar_limit_event *event)
{
if (wmi_handle->ops->extract_sar_limit_event)
return wmi_handle->ops->extract_sar_limit_event(wmi_handle,
evt_buf,
event);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_extract_sar2_result_event(void *handle,
uint8_t *event, uint32_t len)
{
wmi_unified_t wmi_handle = handle;
if (wmi_handle->ops->extract_sar2_result_event)
return wmi_handle->ops->extract_sar2_result_event(wmi_handle,
event,
len);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_set_del_pmkid_cache(wmi_unified_t wmi_handle,
struct wmi_unified_pmk_cache *req_buf)
{
if (wmi_handle->ops->send_set_del_pmkid_cache_cmd)
return wmi_handle->ops->send_set_del_pmkid_cache_cmd(wmi_handle,
req_buf);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_del_ts_cmd(wmi_unified_t wmi_handle, uint8_t vdev_id,
uint8_t ac)
{
if (wmi_handle->ops->send_del_ts_cmd)
return wmi_handle->ops->send_del_ts_cmd(wmi_handle,
vdev_id, ac);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_aggr_qos_cmd(
wmi_unified_t wmi_handle,
struct aggr_add_ts_param *aggr_qos_rsp_msg)
{
if (wmi_handle->ops->send_aggr_qos_cmd)
return wmi_handle->ops->send_aggr_qos_cmd(wmi_handle,
aggr_qos_rsp_msg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_add_ts_cmd(wmi_unified_t wmi_handle,
struct add_ts_param *msg)
{
if (wmi_handle->ops->send_add_ts_cmd)
return wmi_handle->ops->send_add_ts_cmd(wmi_handle,
msg);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_process_add_periodic_tx_ptrn_cmd(
wmi_unified_t wmi_handle,
struct periodic_tx_pattern *pattern,
uint8_t vdev_id)
{
if (wmi_handle->ops->send_process_add_periodic_tx_ptrn_cmd)
return wmi_handle->ops->send_process_add_periodic_tx_ptrn_cmd(
wmi_handle, pattern, vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_process_del_periodic_tx_ptrn_cmd(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint8_t pattern_id)
{
if (wmi_handle->ops->send_process_del_periodic_tx_ptrn_cmd)
return wmi_handle->ops->send_process_del_periodic_tx_ptrn_cmd(
wmi_handle,
vdev_id,
pattern_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_auto_shutdown_timer_cmd(wmi_unified_t wmi_handle,
uint32_t timer_val)
{
if (wmi_handle->ops->send_set_auto_shutdown_timer_cmd)
return wmi_handle->ops->send_set_auto_shutdown_timer_cmd(
wmi_handle,
timer_val);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_set_led_flashing_cmd(wmi_unified_t wmi_handle,
struct flashing_req_params *flashing)
{
if (wmi_handle->ops->send_set_led_flashing_cmd)
return wmi_handle->ops->send_set_led_flashing_cmd(wmi_handle,
flashing);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_process_ch_avoid_update_cmd(wmi_unified_t wmi_handle)
{
if (wmi_handle->ops->send_process_ch_avoid_update_cmd)
return wmi_handle->ops->send_process_ch_avoid_update_cmd(
wmi_handle);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_pdev_set_pcl_cmd(wmi_unified_t wmi_handle,
struct wmi_pcl_chan_weights *msg)
{
if (wmi_handle->ops->send_pdev_set_pcl_cmd)
return wmi_handle->ops->send_pdev_set_pcl_cmd(wmi_handle, msg);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_POLICY_MGR_ENABLE
QDF_STATUS wmi_unified_pdev_set_dual_mac_config_cmd(
wmi_unified_t wmi_handle,
struct policy_mgr_dual_mac_config *msg)
{
if (wmi_handle->ops->send_pdev_set_dual_mac_config_cmd)
return wmi_handle->ops->send_pdev_set_dual_mac_config_cmd(
wmi_handle,
msg);
return QDF_STATUS_E_FAILURE;
}
#endif /* WLAN_POLICY_MGR_ENABLE */
QDF_STATUS wmi_unified_send_adapt_dwelltime_params_cmd(
wmi_unified_t wmi_handle,
struct wmi_adaptive_dwelltime_params *dwelltime_params)
{
if (wmi_handle->ops->send_adapt_dwelltime_params_cmd)
return wmi_handle->ops->
send_adapt_dwelltime_params_cmd(wmi_handle,
dwelltime_params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_send_dbs_scan_sel_params_cmd(
wmi_unified_t wmi_handle,
struct wmi_dbs_scan_sel_params *dbs_scan_params)
{
if (wmi_handle->ops->send_dbs_scan_sel_params_cmd)
return wmi_handle->ops->
send_dbs_scan_sel_params_cmd(wmi_handle,
dbs_scan_params);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_set_arp_stats_req(wmi_unified_t wmi_handle,
struct set_arp_stats *req_buf)
{
if (wmi_handle->ops->send_set_arp_stats_req_cmd)
return wmi_handle->ops->send_set_arp_stats_req_cmd(wmi_handle,
req_buf);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_get_arp_stats_req(wmi_unified_t wmi_handle,
struct get_arp_stats *req_buf)
{
if (wmi_handle->ops->send_get_arp_stats_req_cmd)
return wmi_handle->ops->send_get_arp_stats_req_cmd(wmi_handle,
req_buf);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_peer_unmap_conf_send(wmi_unified_t wmi_handle,
uint8_t vdev_id,
uint32_t peer_id_cnt,
uint16_t *peer_id_list)
{
if (wmi_handle->ops->send_peer_unmap_conf_cmd)
return wmi_handle->ops->send_peer_unmap_conf_cmd(wmi_handle,
vdev_id, peer_id_cnt, peer_id_list);
return QDF_STATUS_E_FAILURE;
}

2518
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_sta_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

23228
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

604
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_twt_api.c Normal file
View File

@@ -0,0 +1,604 @@
/*
* 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to TWT component.
*/
#include "wmi_unified_priv.h"
#include "wmi_unified_twt_api.h"
#if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED)
#include <wlan_twt_public_structs.h>
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)
{
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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_twt_disable_complete_event *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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_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 wmi_twt_session_stats_event_param *params,
struct wmi_host_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 wmi_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;
}
#endif

2376
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_twt_tlv.c Normal file
View File

File diff suppressed because it is too large Load Diff

237
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_vdev_api.c Normal file
View File

@@ -0,0 +1,237 @@
/*
* Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* This file contains the API definitions for the Unified Wireless Module
* Interface (WMI).
*/
#include <htc_api.h>
#include <htc_api.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_api.h>
#include <qdf_module.h>
#include <qdf_list.h>
#include <qdf_platform.h>
#ifdef WMI_EXT_DBG
#include <qdf_list.h>
#endif
#include <linux/debugfs.h>
#include <wmi_unified_param.h>
#include <cdp_txrx_cmn_struct.h>
#include <wmi_unified_vdev_api.h>
QDF_STATUS
wmi_extract_tbttoffset_num_vdevs(struct wmi_unified *wmi_handle, void *evt_buf,
uint32_t *num_vdevs)
{
if (wmi_handle->ops->extract_tbttoffset_num_vdevs)
return wmi_handle->ops->extract_tbttoffset_num_vdevs(wmi_handle,
evt_buf,
num_vdevs);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_send_multiple_vdev_restart_req_cmd(
struct wmi_unified *wmi_handle,
struct multiple_vdev_restart_params *param)
{
if (wmi_handle->ops->send_multiple_vdev_restart_req_cmd)
return wmi_handle->ops->send_multiple_vdev_restart_req_cmd(
wmi_handle, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_send_multiple_vdev_set_param_cmd(
struct wmi_unified *wmi_handle,
struct multiple_vdev_set_param *param)
{
if (wmi_handle->ops->send_multiple_vdev_set_param_cmd)
return wmi_handle->ops->send_multiple_vdev_set_param_cmd(
wmi_handle, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_beacon_send_cmd(struct wmi_unified *wmi_handle,
struct beacon_params *param)
{
if (wmi_handle->ops->send_beacon_send_cmd)
return wmi_handle->ops->send_beacon_send_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_vdev_start_resp(struct wmi_unified *wmi_handle, void *evt_buf,
struct vdev_start_response *vdev_rsp)
{
if (wmi_handle->ops->extract_vdev_start_resp)
return wmi_handle->ops->extract_vdev_start_resp(wmi_handle,
evt_buf,
vdev_rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_vdev_delete_resp(struct wmi_unified *wmi_handle, void *evt_buf,
struct vdev_delete_response *delete_rsp)
{
if (wmi_handle->ops->extract_vdev_delete_resp)
return wmi_handle->ops->extract_vdev_delete_resp(wmi_handle,
evt_buf,
delete_rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_vdev_peer_delete_all_response_event(
struct wmi_unified *wmi_handle,
void *evt_buf,
struct peer_delete_all_response *delete_rsp)
{
if (wmi_handle->ops->extract_vdev_peer_delete_all_response_event)
return
wmi_handle->ops->extract_vdev_peer_delete_all_response_event(
wmi_handle,
evt_buf,
delete_rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_vdev_stopped_param(struct wmi_unified *wmi_handle, void *evt_buf,
uint32_t *vdev_id)
{
if (wmi_handle->ops->extract_vdev_stopped_param)
return wmi_handle->ops->extract_vdev_stopped_param(wmi_handle,
evt_buf,
vdev_id);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_ext_tbttoffset_num_vdevs(struct wmi_unified *wmi_handle,
void *evt_buf, uint32_t *num_vdevs)
{
if (wmi_handle->ops->extract_ext_tbttoffset_num_vdevs)
return wmi_handle->ops->extract_ext_tbttoffset_num_vdevs(
wmi_handle,
evt_buf, num_vdevs);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_vdev_config_ratemask_cmd_send(struct wmi_unified *wmi_handle,
struct config_ratemask_params *param)
{
if (wmi_handle->ops->send_vdev_config_ratemask_cmd)
return wmi_handle->ops->send_vdev_config_ratemask_cmd(
wmi_handle, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_peer_filter_set_tx_cmd_send(struct wmi_unified *wmi_handle,
uint8_t macaddr[],
struct set_tx_peer_filter *param)
{
struct wmi_ops *ops = wmi_handle->ops;
if (ops->send_peer_filter_set_tx_cmd)
return ops->send_peer_filter_set_tx_cmd(wmi_handle, macaddr,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_vdev_set_neighbour_rx_cmd_send(
struct wmi_unified *wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct set_neighbour_rx_params *param)
{
if (wmi_handle->ops->send_vdev_set_neighbour_rx_cmd)
return wmi_handle->ops->send_vdev_set_neighbour_rx_cmd(
wmi_handle,
macaddr, param);
return QDF_STATUS_E_FAILURE;
}
qdf_export_symbol(wmi_unified_vdev_set_neighbour_rx_cmd_send);
QDF_STATUS
wmi_send_peer_vlan_config(struct wmi_unified *wmi_handle,
uint8_t *macaddr,
struct peer_vlan_config_param param)
{
char peer_mac[QDF_MAC_ADDR_SIZE];
qdf_mem_copy(peer_mac, macaddr, QDF_MAC_ADDR_SIZE);
if (wmi_handle->ops->send_peer_vlan_config_cmd)
return wmi_handle->ops->send_peer_vlan_config_cmd(wmi_handle,
peer_mac,
&param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_multi_vdev_restart_resp_event(
struct wmi_unified *wmi_handle,
void *evt_buf,
struct multi_vdev_restart_resp *restart_rsp)
{
if (wmi_handle->ops->extract_multi_vdev_restart_resp_event)
return wmi_handle->ops->extract_multi_vdev_restart_resp_event(
wmi_handle, evt_buf, restart_rsp);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_unified_multisoc_tbtt_sync_cmd(wmi_unified_t wmi_handle,
struct rnr_tbtt_multisoc_sync_param *param)
{
if (wmi_handle->ops->multisoc_tbtt_sync_cmd)
return wmi_handle->ops->multisoc_tbtt_sync_cmd(wmi_handle,
param);
return QDF_STATUS_E_FAILURE;
}
#ifdef WLAN_FEATURE_SR
QDF_STATUS
wmi_unified_vdev_param_sr_prohibit_send(wmi_unified_t wmi_hdl,
struct sr_prohibit_param *srp_param)
{
if (wmi_hdl->ops->vdev_param_sr_prohibit_send)
return wmi_hdl->ops->vdev_param_sr_prohibit_send(wmi_hdl,
srp_param);
return QDF_STATUS_E_FAILURE;
}
#endif

604
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_vdev_tlv.c Normal file
View File

@@ -0,0 +1,604 @@
/*
* Copyright (c) 2016-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <qdf_module.h>
#include <qdf_list.h>
#include <qdf_platform.h>
#include <wmi_unified_vdev_tlv.h>
#include <wlan_vdev_mgr_tgt_if_tx_defs.h>
static QDF_STATUS
send_vdev_config_ratemask_cmd_tlv(struct wmi_unified *wmi_handle,
struct config_ratemask_params *param)
{
wmi_vdev_config_ratemask_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_vdev_config_ratemask_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_config_ratemask_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_vdev_config_ratemask_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->type = param->type;
cmd->mask_lower32 = param->lower32;
cmd->mask_higher32 = param->higher32;
cmd->mask_lower32_2 = param->lower32_2;
cmd->mask_higher32_2 = param->higher32_2;
wmi_debug("vdev_id %d type %d lower32 0x%x lower32_2 0x%x",
cmd->vdev_id, cmd->type, cmd->mask_lower32,
cmd->mask_lower32_2);
wmi_debug("higher32 0x%x higher32_2 0x%x", cmd->mask_higher32,
cmd->mask_higher32_2);
wmi_mtrace(WMI_VDEV_RATEMASK_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_RATEMASK_CMDID)) {
wmi_err("Setting vdev ratemask failed");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
send_beacon_send_cmd_tlv(struct wmi_unified *wmi_handle,
struct beacon_params *param)
{
QDF_STATUS ret;
wmi_bcn_send_from_host_cmd_fixed_param *cmd;
wmi_buf_t wmi_buf;
qdf_dma_addr_t dma_addr;
uint32_t dtim_flag = 0;
wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
if (!wmi_buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_NOMEM;
}
if (param->is_dtim_count_zero) {
dtim_flag |= WMI_BCN_SEND_DTIM_ZERO;
if (param->is_bitctl_reqd) {
/* deliver CAB traffic in next DTIM beacon */
dtim_flag |= WMI_BCN_SEND_DTIM_BITCTL_SET;
}
}
cmd = (wmi_bcn_send_from_host_cmd_fixed_param *)wmi_buf_data(wmi_buf);
WMITLV_SET_HDR(
&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_bcn_send_from_host_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_bcn_send_from_host_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->data_len = qdf_nbuf_len(param->wbuf);
cmd->frame_ctrl = param->frame_ctrl;
cmd->dtim_flag = dtim_flag;
dma_addr = qdf_nbuf_get_frag_paddr(param->wbuf, 0);
cmd->frag_ptr_lo = qdf_get_lower_32_bits(dma_addr);
#if defined(HTT_PADDR64)
cmd->frag_ptr_hi = qdf_get_upper_32_bits(dma_addr) & 0x1F;
#endif
cmd->bcn_antenna = param->bcn_txant;
wmi_mtrace(WMI_PDEV_SEND_BCN_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
WMI_PDEV_SEND_BCN_CMDID);
if (ret != QDF_STATUS_SUCCESS) {
wmi_err("Failed to send bcn: %d", ret);
wmi_buf_free(wmi_buf);
}
return ret;
}
static QDF_STATUS
extract_tbttoffset_num_vdevs_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
uint32_t *num_vdevs)
{
WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
uint32_t vdev_map;
param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid tbtt update ext event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_event = param_buf->fixed_param;
vdev_map = tbtt_offset_event->vdev_map;
*num_vdevs = wmi_vdev_map_to_num_vdevs(vdev_map);
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
send_peer_filter_set_tx_cmd_tlv(struct wmi_unified *wmi_handle,
uint8_t macaddr[],
struct set_tx_peer_filter *param)
{
wmi_peer_tx_filter_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
cmd = (wmi_peer_tx_filter_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_tx_filter_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_peer_tx_filter_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->action = param->action;
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->addr);
wmi_mtrace(WMI_PEER_TX_FILTER_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_TX_FILTER_CMDID)) {
wmi_err("Failed to set neighbour rx param");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
send_vdev_set_neighbour_rx_cmd_tlv(struct wmi_unified *wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct set_neighbour_rx_params *param)
{
wmi_vdev_filter_nrp_config_cmd_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_vdev_filter_nrp_config_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_filter_nrp_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_vdev_filter_nrp_config_cmd_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->bssid_idx = param->idx;
cmd->action = param->action;
cmd->type = param->type;
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->addr);
cmd->flag = 0;
wmi_mtrace(WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID)) {
wmi_err("Failed to set neighbour rx param");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
extract_vdev_start_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
struct vdev_start_response *vdev_rsp)
{
WMI_VDEV_START_RESP_EVENTID_param_tlvs *param_buf;
wmi_vdev_start_response_event_fixed_param *ev;
param_buf = (WMI_VDEV_START_RESP_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid start response event buffer");
return QDF_STATUS_E_INVAL;
}
ev = param_buf->fixed_param;
if (!ev) {
wmi_err("Invalid start response event buffer");
return QDF_STATUS_E_INVAL;
}
qdf_mem_zero(vdev_rsp, sizeof(*vdev_rsp));
vdev_rsp->vdev_id = ev->vdev_id;
vdev_rsp->requestor_id = ev->requestor_id;
switch (ev->resp_type) {
case WMI_VDEV_START_RESP_EVENT:
vdev_rsp->resp_type = WMI_HOST_VDEV_START_RESP_EVENT;
break;
case WMI_VDEV_RESTART_RESP_EVENT:
vdev_rsp->resp_type = WMI_HOST_VDEV_RESTART_RESP_EVENT;
break;
default:
wmi_err("Invalid start response event buffer");
break;
};
vdev_rsp->status = ev->status;
vdev_rsp->chain_mask = ev->chain_mask;
vdev_rsp->smps_mode = ev->smps_mode;
vdev_rsp->mac_id = ev->mac_id;
vdev_rsp->cfgd_tx_streams = ev->cfgd_tx_streams;
vdev_rsp->cfgd_rx_streams = ev->cfgd_rx_streams;
vdev_rsp->max_allowed_tx_power = ev->max_allowed_tx_power;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
extract_vdev_delete_resp_tlv(struct wmi_unified *wmi_handle, void *evt_buf,
struct vdev_delete_response *delete_rsp)
{
WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *param_buf;
wmi_vdev_delete_resp_event_fixed_param *ev;
param_buf = (WMI_VDEV_DELETE_RESP_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid vdev delete response event buffer");
return QDF_STATUS_E_INVAL;
}
ev = param_buf->fixed_param;
if (!ev) {
wmi_err("Invalid vdev delete response event");
return QDF_STATUS_E_INVAL;
}
qdf_mem_zero(delete_rsp, sizeof(*delete_rsp));
delete_rsp->vdev_id = ev->vdev_id;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_vdev_peer_delete_all_response_event_tlv(
wmi_unified_t wmi_hdl,
void *evt_buf,
struct peer_delete_all_response *param)
{
WMI_VDEV_DELETE_ALL_PEER_RESP_EVENTID_param_tlvs *param_buf;
wmi_vdev_delete_all_peer_resp_event_fixed_param *ev;
param_buf = (WMI_VDEV_DELETE_ALL_PEER_RESP_EVENTID_param_tlvs *)evt_buf;
ev = (wmi_vdev_delete_all_peer_resp_event_fixed_param *)
param_buf->fixed_param;
if (!ev) {
wmi_err("Invalid peer_delete all response");
return QDF_STATUS_E_FAILURE;
}
param->vdev_id = ev->vdev_id;
param->status = ev->status;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS
extract_vdev_stopped_param_tlv(struct wmi_unified *wmi_handle,
void *evt_buf, uint32_t *vdev_id)
{
WMI_VDEV_STOPPED_EVENTID_param_tlvs *param_buf;
wmi_vdev_stopped_event_fixed_param *resp_event;
param_buf = (WMI_VDEV_STOPPED_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid event buffer");
return QDF_STATUS_E_INVAL;
}
resp_event = param_buf->fixed_param;
*vdev_id = resp_event->vdev_id;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_ext_tbttoffset_num_vdevs_tlv(
wmi_unified_t wmi_hdl,
void *evt_buf,
uint32_t *num_vdevs)
{
WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_ext_event_fixed_param *tbtt_offset_ext_event;
param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid tbtt update ext event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_ext_event = param_buf->fixed_param;
*num_vdevs = tbtt_offset_ext_event->num_vdevs;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_tbttoffset_update_params_tlv(
wmi_unified_t wmi_hdl,
void *evt_buf, uint8_t idx,
struct tbttoffset_params *tbtt_param)
{
WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
uint32_t vdev_map;
param_buf = (WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid tbtt update event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_event = param_buf->fixed_param;
vdev_map = tbtt_offset_event->vdev_map;
tbtt_param->vdev_id = wmi_vdev_map_to_vdev_id(vdev_map, idx);
if (tbtt_param->vdev_id == WLAN_INVALID_VDEV_ID)
return QDF_STATUS_E_INVAL;
tbtt_param->tbttoffset =
param_buf->tbttoffset_list[tbtt_param->vdev_id];
if (param_buf->tbtt_qtime_low_us_list)
tbtt_param->vdev_tbtt_qtime_lo =
param_buf->tbtt_qtime_low_us_list[tbtt_param->vdev_id];
if (param_buf->tbtt_qtime_high_us_list)
tbtt_param->vdev_tbtt_qtime_hi =
param_buf->tbtt_qtime_high_us_list[tbtt_param->vdev_id];
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_ext_tbttoffset_update_params_tlv(
wmi_unified_t wmi_hdl,
void *evt_buf, uint8_t idx,
struct tbttoffset_params *tbtt_param)
{
WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *param_buf;
wmi_tbtt_offset_info *tbtt_offset_info;
param_buf = (WMI_TBTTOFFSET_EXT_UPDATE_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid tbtt update event buffer");
return QDF_STATUS_E_INVAL;
}
tbtt_offset_info = &param_buf->tbtt_offset_info[idx];
tbtt_param->vdev_id = tbtt_offset_info->vdev_id;
tbtt_param->tbttoffset = tbtt_offset_info->tbttoffset;
tbtt_param->vdev_tbtt_qtime_lo = tbtt_offset_info->tbtt_qtime_low_us;
tbtt_param->vdev_tbtt_qtime_hi = tbtt_offset_info->tbtt_qtime_high_us;
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS extract_muedca_params_tlv(wmi_unified_t wmi_hdl,
void *evt_buf,
struct muedca_params *muedca_param_list)
{
WMI_MUEDCA_PARAMS_CONFIG_EVENTID_param_tlvs *param_buf;
wmi_muedca_params_config_event_fixed_param *muedca_param;
int i;
param_buf = (WMI_MUEDCA_PARAMS_CONFIG_EVENTID_param_tlvs *)evt_buf;
if (!param_buf) {
wmi_err("Invalid muedca evt buffer");
return QDF_STATUS_E_INVAL;
}
muedca_param = param_buf->fixed_param;
muedca_param_list->pdev_id = wmi_hdl->ops->
convert_target_pdev_id_to_host(wmi_hdl,
muedca_param->pdev_id);
for (i = 0; i < WMI_AC_MAX; i++) {
muedca_param_list->muedca_aifsn[i] = muedca_param->aifsn[i] &
WMI_MUEDCA_PARAM_MASK;
muedca_param_list->muedca_ecwmin[i] = muedca_param->ecwmin[i] &
WMI_MUEDCA_PARAM_MASK;
muedca_param_list->muedca_ecwmax[i] = muedca_param->ecwmax[i] &
WMI_MUEDCA_PARAM_MASK;
muedca_param_list->muedca_timer[i] = muedca_param->muedca_expiration_time[i] &
WMI_MUEDCA_PARAM_MASK;
}
return QDF_STATUS_SUCCESS;
}
#ifdef WLAN_FEATURE_SR
static QDF_STATUS
vdev_param_sr_prohibit_send_tlv(struct wmi_unified *wmi_handle,
struct sr_prohibit_param *param)
{
wmi_vdev_param_enable_sr_prohibit_fixed_param *cmd;
wmi_buf_t buf;
int32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
wmi_err("wmi_buf_alloc failed");
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_vdev_param_enable_sr_prohibit_fixed_param *)
wmi_buf_data(buf);
WMITLV_SET_HDR
(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_vdev_param_enable_sr_prohibit_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_vdev_param_enable_sr_prohibit_fixed_param));
cmd->vdev_id = param->vdev_id;
cmd->tidmap = 0;
cmd->prohibit_enable = param->sr_he_siga_val15_allowed;
wmi_debug("SR Prohibit enabled: %d", cmd->prohibit_enable);
wmi_mtrace(WMI_VDEV_PARAM_ENABLE_SR_PROHIBIT_CMDID, cmd->vdev_id, 0);
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_VDEV_PARAM_ENABLE_SR_PROHIBIT_CMDID)) {
wmi_err("Failed to set neighbour rx param");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
static void wmi_vdev_attach_sr_cmds_tlv(struct wmi_ops *wmi_ops)
{
if (!wmi_ops)
return;
wmi_ops->vdev_param_sr_prohibit_send =
vdev_param_sr_prohibit_send_tlv;
}
#else
static inline void wmi_vdev_attach_sr_cmds_tlv(struct wmi_ops *wmi_ops)
{
}
#endif
static void
set_peer_tx_vlan_config(wmi_peer_config_vlan_cmd_fixed_param *cmd,
struct peer_vlan_config_param *cfg)
{
WMI_VLAN_TX_SET(cmd->peer_vlan_config_mask, cfg->tx_cmd);
/* Setting insert_or_strip bit for Tx */
WMI_TX_INSERT_OR_STRIP_SET(cmd->peer_vlan_config_mask,
cfg->tx_strip_insert);
if (cfg->tx_strip_insert_inner && cfg->tx_strip_insert) {
/* Setting the strip_insert_vlan_inner bit fo Tx */
WMI_TX_STRIP_INSERT_VLAN_INNER_SET(cmd->peer_vlan_config_mask,
cfg->tx_strip_insert_inner);
/* If Insert inner tag bit is set, then fill inner_tci */
WMI_TX_INSERT_VLAN_INNER_TCI_SET(cmd->insert_vlan_tci,
cfg->insert_vlan_inner_tci);
}
if (cfg->tx_strip_insert_outer && cfg->tx_strip_insert) {
/* Setting the strip_insert_vlan_outer bit for Tx */
WMI_TX_STRIP_INSERT_VLAN_OUTER_SET(cmd->peer_vlan_config_mask,
cfg->tx_strip_insert_outer);
/* If Insert outer tag bit is set, then fill outer_tci */
WMI_TX_INSERT_VLAN_OUTER_TCI_SET(cmd->insert_vlan_tci,
cfg->insert_vlan_outer_tci);
}
}
static void
wmi_set_peer_vlan_config(wmi_peer_config_vlan_cmd_fixed_param *cmd,
struct peer_vlan_config_param *param)
{
/* Tx command - Check if cmd is Tx then configure Tx cmd */
if (param->tx_cmd)
set_peer_tx_vlan_config(cmd, param);
/* Rx command - Check if cmd is Rx then configure Rx cmd */
if (param->rx_cmd) {
WMI_VLAN_RX_SET(cmd->peer_vlan_config_mask, param->rx_cmd);
/* Setting the strip_vlan_c_tag_decap bit in RX */
WMI_RX_STRIP_VLAN_C_TAG_SET(cmd->peer_vlan_config_mask,
param->rx_strip_c_tag);
/* Setting the strip_vlan_s_tag_decap bit in RX */
WMI_RX_STRIP_VLAN_S_TAG_SET(cmd->peer_vlan_config_mask,
param->rx_strip_s_tag);
/* Setting the insert_vlan_c_tag_decap bit in RX */
WMI_RX_INSERT_VLAN_C_TAG_SET(cmd->peer_vlan_config_mask,
param->rx_insert_c_tag);
/* Setting the insert_vlan_s_tag_decap bit in RX */
WMI_RX_INSERT_VLAN_S_TAG_SET(cmd->peer_vlan_config_mask,
param->rx_insert_s_tag);
}
}
static QDF_STATUS
send_peer_vlan_config_cmd_tlv(wmi_unified_t wmi,
uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
struct peer_vlan_config_param *param)
{
wmi_peer_config_vlan_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint32_t len = sizeof(*cmd);
buf = wmi_buf_alloc(wmi, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
cmd = (wmi_peer_config_vlan_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_config_vlan_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_config_vlan_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
/* vdev id */
cmd->vdev_id = param->vdev_id;
wmi_set_peer_vlan_config(cmd, param);
if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_CONFIG_VLAN_CMDID)) {
wmi_err("Failed to send peer hw vlan acceleration command");
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
void wmi_vdev_attach_tlv(struct wmi_unified *wmi_handle)
{
struct wmi_ops *wmi_ops;
if (!wmi_handle) {
wmi_err("null wmi handle");
return;
}
wmi_ops = wmi_handle->ops;
wmi_ops->extract_vdev_delete_resp = extract_vdev_delete_resp_tlv;
wmi_ops->extract_vdev_stopped_param = extract_vdev_stopped_param_tlv;
wmi_ops->extract_vdev_start_resp = extract_vdev_start_resp_tlv;
wmi_ops->extract_vdev_peer_delete_all_response_event =
extract_vdev_peer_delete_all_response_event_tlv;
wmi_ops->extract_tbttoffset_num_vdevs =
extract_tbttoffset_num_vdevs_tlv;
wmi_ops->extract_tbttoffset_update_params =
extract_tbttoffset_update_params_tlv;
wmi_ops->extract_ext_tbttoffset_update_params =
extract_ext_tbttoffset_update_params_tlv;
wmi_ops->extract_ext_tbttoffset_num_vdevs =
extract_ext_tbttoffset_num_vdevs_tlv;
wmi_ops->extract_muedca_params_handler =
extract_muedca_params_tlv;
wmi_ops->send_vdev_set_neighbour_rx_cmd =
send_vdev_set_neighbour_rx_cmd_tlv;
wmi_ops->send_beacon_send_cmd = send_beacon_send_cmd_tlv;
wmi_ops->send_vdev_config_ratemask_cmd =
send_vdev_config_ratemask_cmd_tlv;
wmi_ops->send_peer_filter_set_tx_cmd = send_peer_filter_set_tx_cmd_tlv;
wmi_ops->send_peer_vlan_config_cmd = send_peer_vlan_config_cmd_tlv;
wmi_vdev_attach_sr_cmds_tlv(wmi_ops);
}

53
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_wds_api.c Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright (c) 2021 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to WDS component.
*/
#include <wmi_unified_priv.h>
#include <wmi_unified_wds_api.h>
QDF_STATUS
wmi_unified_peer_add_wds_entry_cmd(wmi_unified_t wmi_hdl,
struct peer_add_wds_entry_params *param)
{
if (wmi_hdl->ops->send_peer_add_wds_entry_cmd)
return wmi_hdl->ops->send_peer_add_wds_entry_cmd(wmi_hdl,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_peer_del_wds_entry_cmd(wmi_unified_t wmi_hdl,
struct peer_del_wds_entry_params *param)
{
if (wmi_hdl->ops->send_peer_del_wds_entry_cmd)
return wmi_hdl->ops->send_peer_del_wds_entry_cmd(wmi_hdl,
param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_unified_update_wds_entry_cmd(wmi_unified_t wmi_hdl,
struct peer_update_wds_entry_params *param)
{
if (wmi_hdl->ops->send_peer_update_wds_entry_cmd)
return wmi_hdl->ops->send_peer_update_wds_entry_cmd(wmi_hdl,
param);
return QDF_STATUS_E_FAILURE;
}

152
qcom/opensource/wlan/qca-wifi-host-cmn/wmi/src/wmi_unified_wds_tlv.c Normal file
View File

@@ -0,0 +1,152 @@
/*
* Copyright (c) 2021 The Linux Foundation. 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <osdep.h>
#include <wmi.h>
#include <wmi_unified_priv.h>
#include <wmi_unified_wds_api.h>
/**
* send_peer_add_wds_entry_cmd_tlv() - send peer add command to fw
* @wmi_handle: wmi handle
* @param: pointer holding peer details
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
send_peer_add_wds_entry_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_add_wds_entry_params *param)
{
wmi_peer_add_wds_entry_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
cmd = (wmi_peer_add_wds_entry_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_add_wds_entry_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_add_wds_entry_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
cmd->flags = (param->flags & WMI_HOST_WDS_FLAG_STATIC) ?
WMI_WDS_FLAG_STATIC : 0;
cmd->vdev_id = param->vdev_id;
wmi_mtrace(WMI_PEER_ADD_WDS_ENTRY_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_ADD_WDS_ENTRY_CMDID);
if (QDF_IS_STATUS_ERROR(ret))
wmi_buf_free(buf);
return ret;
}
/**
* send_peer_del_wds_entry_cmd_tlv() - send peer delete command to fw
* @wmi_handle: wmi handle
* @param: pointer holding peer details
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
send_peer_del_wds_entry_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_del_wds_entry_params *param)
{
wmi_peer_remove_wds_entry_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
cmd = (wmi_peer_remove_wds_entry_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_remove_wds_entry_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_remove_wds_entry_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
cmd->vdev_id = param->vdev_id;
wmi_mtrace(WMI_PEER_REMOVE_WDS_ENTRY_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_REMOVE_WDS_ENTRY_CMDID);
if (QDF_IS_STATUS_ERROR(ret))
wmi_buf_free(buf);
return ret;
}
/**
* send_peer_update_wds_entry_cmd_tlv() - send peer update command to fw
* @wmi_handle: wmi handle
* @param: pointer holding peer details
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
send_peer_update_wds_entry_cmd_tlv(wmi_unified_t wmi_handle,
struct peer_update_wds_entry_params *param)
{
wmi_peer_update_wds_entry_cmd_fixed_param *cmd;
wmi_buf_t buf;
int len = sizeof(*cmd);
QDF_STATUS ret;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
cmd = (wmi_peer_update_wds_entry_cmd_fixed_param *)wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_update_wds_entry_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_update_wds_entry_cmd_fixed_param));
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
cmd->flags = (param->flags & WMI_HOST_WDS_FLAG_STATIC) ?
WMI_WDS_FLAG_STATIC : 0;
cmd->vdev_id = param->vdev_id;
wmi_mtrace(WMI_PEER_UPDATE_WDS_ENTRY_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PEER_UPDATE_WDS_ENTRY_CMDID);
if (QDF_IS_STATUS_ERROR(ret))
wmi_buf_free(buf);
return ret;
}
void wmi_wds_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_peer_add_wds_entry_cmd = send_peer_add_wds_entry_cmd_tlv;
ops->send_peer_del_wds_entry_cmd = send_peer_del_wds_entry_cmd_tlv;
ops->send_peer_update_wds_entry_cmd =
send_peer_update_wds_entry_cmd_tlv;
}