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

qcacld-3.0: Add wow user pattern support in PMO

Browse Source 
Add wow user pattern support in PMO.

Change-Id: I186e650e3a165ea0aeaada4bba880005c5be8b5f
CRs-Fixed: 2135644
This commit is contained in:
Mukul Sharma
2017-11-02 17:08:23 +05:30
committed by snandini
parent 29b81c20aa
commit 0c1c379514
18 changed files with 277 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
components/pmo/core/inc/wlan_pmo_wow.h
View File

@@ -175,6 +175,54 @@ static inline void pmo_decrement_wow_default_ptrn(
}
}
/**
* pmo_get_wow_default_ptrn() -Get wow default ptrn
* @vdev_ctx: pmo vdev priv ctx
*
* API to get wow default ptrn
*
* Return: current wow default ptrn count
*/
static inline uint8_t pmo_get_wow_default_ptrn(
struct pmo_vdev_priv_obj *vdev_ctx)
{
uint8_t count;
if (vdev_ctx->pmo_psoc_ctx->psoc_cfg.ptrn_id_per_vdev) {
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
count = vdev_ctx->num_wow_default_patterns;
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
} else {
qdf_spin_lock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
count = vdev_ctx->pmo_psoc_ctx->wow.ptrn_id_def;
qdf_spin_unlock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
}
return count;
}
/**
* pmo_get_wow_default_ptrn() -Set wow default ptrn
* @vdev_ctx: pmo vdev priv ctx
*
* API to set wow default ptrn
*
* Return: Set wow default ptrn count
*/
static inline void pmo_set_wow_default_ptrn(
struct pmo_vdev_priv_obj *vdev_ctx, uint8_t value)
{
if (vdev_ctx->pmo_psoc_ctx->psoc_cfg.ptrn_id_per_vdev) {
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
vdev_ctx->num_wow_default_patterns = value;
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
} else {
qdf_spin_lock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
vdev_ctx->pmo_psoc_ctx->wow.ptrn_id_def = value;
qdf_spin_unlock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
}
}
/**
* pmo_increment_wow_user_ptrn() -increment wow user ptrn
* @vdev_ctx: pmo vdev priv ctx
@@ -219,6 +267,32 @@ static inline void pmo_decrement_wow_user_ptrn(
}
}
/**
* pmo_get_wow_user_ptrn() -Get wow user ptrn
* @vdev_ctx: pmo vdev priv ctx
*
* API to Get wow user ptrn
*
* Return: None
*/
static inline uint8_t pmo_get_wow_user_ptrn(
struct pmo_vdev_priv_obj *vdev_ctx)
{
uint8_t count;
if (vdev_ctx->pmo_psoc_ctx->psoc_cfg.ptrn_id_per_vdev) {
qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
count = vdev_ctx->num_wow_user_patterns;
qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
} else {
qdf_spin_lock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
count = vdev_ctx->pmo_psoc_ctx->wow.ptrn_id_usr;
qdf_spin_unlock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
}
return count;
}
void pmo_dump_wow_ptrn(struct pmo_wow_add_pattern *ptrn);
/**
@@ -229,18 +303,18 @@ void pmo_dump_wow_ptrn(struct pmo_wow_add_pattern *ptrn);
*
* Return: false if any errors encountered, QDF_STATUS_SUCCESS otherwise
*/
QDF_STATUS pmo_core_add_wow_pattern(struct wlan_objmgr_vdev *vdev,
const char *ptrn);
QDF_STATUS pmo_core_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_add_pattern *ptrn);
/**
* pmo_core_del_wow_pattern() - Function which will delete the WoWL pattern
* @vdev: pointer to the vdev
* @ptrn: pointer to the pattern string to be added
* @ptrn: pointer to the pattern string to be delete
*
* Return: error if any errors encountered, QDF_STATUS_SUCCESS otherwise
*/
QDF_STATUS pmo_core_del_wow_pattern(struct wlan_objmgr_vdev *vdev,
const char *ptrn);
QDF_STATUS pmo_core_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
uint8_t pattern_id);
/**
* pmo_core_wow_enter() - store enable/disable status for pattern

101
components/pmo/core/src/wlan_pmo_wow.c
View File

@@ -27,30 +27,105 @@
#include "wlan_pmo_static_config.h"
#include "wlan_reg_services_api.h"
static inline int pmo_find_wow_ptrn_len(const char *ptrn)
QDF_STATUS pmo_core_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_add_pattern *ptrn)
{
int len = 0;
QDF_STATUS status;
uint8_t id;
uint8_t bit_to_check, pos;
uint8_t new_mask[PMO_WOWL_BCAST_PATTERN_MAX_SIZE];
struct pmo_vdev_priv_obj *vdev_ctx;
while (*ptrn != '\0' && *ptrn != PMO_WOW_INTER_PTRN_TOKENIZER) {
len++;
ptrn++;
status = pmo_vdev_get_ref(vdev);
if (QDF_IS_STATUS_ERROR(status))
goto out;
vdev_ctx = pmo_vdev_get_priv(vdev);
/* clear all default patterns cofigured by pmo */
for (id = 0; id < pmo_get_wow_default_ptrn(vdev_ctx); id++)
pmo_tgt_del_wow_pattern(vdev, id, false);
pmo_set_wow_default_ptrn(vdev_ctx, 0);
pmo_debug("Add user passed wow pattern id %d vdev id %d",
ptrn->pattern_id, ptrn->session_id);
/*
* Convert received pattern mask value from bit representation
* to byte representation.
*
* For example, received value from umac,
*
* Mask value : A1 (equivalent binary is "1010 0001")
* Pattern value : 12:00:13:00:00:00:00:44
*
* The value which goes to FW after the conversion from this
* function (1 in mask value will become FF and 0 will
* become 00),
*
* Mask value : FF:00:FF:00:0:00:00:FF
* Pattern value : 12:00:13:00:00:00:00:44
*/
qdf_mem_zero(new_mask, sizeof(new_mask));
for (pos = 0; pos < ptrn->pattern_size; pos++) {
bit_to_check = (PMO_NUM_BITS_IN_BYTE - 1) -
(pos % PMO_NUM_BITS_IN_BYTE);
bit_to_check = 0x1 << bit_to_check;
if (ptrn->pattern_mask[pos / PMO_NUM_BITS_IN_BYTE] &
bit_to_check)
new_mask[pos] = PMO_WOW_PTRN_MASK_VALID;
}
return len;
status = pmo_tgt_send_wow_patterns_to_fw(vdev,
ptrn->pattern_id,
ptrn->pattern, ptrn->pattern_size,
ptrn->pattern_byte_offset, new_mask,
ptrn->pattern_size, true);
if (status != QDF_STATUS_SUCCESS)
pmo_err("Failed to add wow pattern %d", ptrn->pattern_id);
pmo_vdev_put_ref(vdev);
out:
PMO_EXIT();
return status;
}
QDF_STATUS pmo_core_add_wow_pattern(struct wlan_objmgr_vdev *vdev,
const char *ptrn)
QDF_STATUS pmo_core_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
uint8_t pattern_id)
{
return QDF_STATUS_SUCCESS;
QDF_STATUS status;
struct pmo_vdev_priv_obj *vdev_ctx;
status = pmo_vdev_get_ref(vdev);
if (QDF_IS_STATUS_ERROR(status))
goto out;
vdev_ctx = pmo_vdev_get_priv(vdev);
if (pmo_get_wow_user_ptrn(vdev_ctx) <= 0) {
pmo_err("No valid user pattern. Num user pattern %u",
pmo_get_wow_user_ptrn(vdev_ctx));
status = QDF_STATUS_E_INVAL;
goto rel_ref;
}
QDF_STATUS pmo_core_del_wow_pattern(struct wlan_objmgr_vdev *vdev,
const char *ptrn)
{
return QDF_STATUS_SUCCESS;
pmo_debug("Delete user passed wow pattern id %d total user pattern %d",
pattern_id, pmo_get_wow_user_ptrn(vdev_ctx));
pmo_tgt_del_wow_pattern(vdev, pattern_id, true);
/* configure default patterns once all user patterns are deleted */
if (!pmo_get_wow_user_ptrn(vdev_ctx))
pmo_register_wow_default_patterns(vdev);
rel_ref:
pmo_vdev_put_ref(vdev);
out:
PMO_EXIT();
return status;
}
QDF_STATUS pmo_core_wow_enter(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_enter_params *wow_enter_param)
{

3
components/pmo/dispatcher/inc/wlan_pmo_obj_mgmt_public_struct.h
View File

@@ -74,6 +74,7 @@ int (*pmo_pld_auto_resume_cb)(void);
* @send_enable_wakeup_event_req: fp to send enable wow wakeup events req
* @send_disable_wakeup_event_req: fp to send disable wow wakeup events req
* @send_add_wow_pattern: fp to send wow pattern request
* @del_wow_pattern: fp to delete wow pattern from firmware
* @send_enhance_mc_offload_req: fp to send enhanced multicast offload request
* @send_set_mc_filter_req: fp to send set mc filter request
* @send_clear_mc_filter_req: fp to send clear mc filter request
@@ -128,6 +129,8 @@ struct wlan_pmo_tx_ops {
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);
QDF_STATUS (*del_wow_pattern)(
struct wlan_objmgr_vdev *vdev, uint8_t ptrn_id);
QDF_STATUS (*send_enhance_mc_offload_req)(
struct wlan_objmgr_vdev *vdev, bool enable);
QDF_STATUS (*send_set_mc_filter_req)(

4
components/pmo/dispatcher/inc/wlan_pmo_tgt_api.h
View File

@@ -150,6 +150,10 @@ QDF_STATUS pmo_tgt_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
uint8_t ptrn_offset, const uint8_t *mask,
uint8_t mask_len, bool user);
QDF_STATUS pmo_tgt_del_wow_pattern(
struct wlan_objmgr_vdev *vdev, uint8_t ptrn_id,
bool user);
/**
* pmo_tgt_set_mc_filter_req() - Set mcast filter command to fw
* @vdev: objmgr vdev

6
components/pmo/dispatcher/inc/wlan_pmo_ucfg_api.h
View File

@@ -529,6 +529,12 @@ QDF_STATUS pmo_ucfg_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
QDF_STATUS pmo_ucfg_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
int disable_target_intr);
QDF_STATUS pmo_ucfg_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_add_pattern *ptrn);
QDF_STATUS pmo_ucfg_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
uint8_t pattern_id);
/**
* pmo_ucfg_psoc_bus_resume() -handle bus resume request for psoc
* @psoc: objmgr psoc handle

3
components/pmo/dispatcher/inc/wlan_pmo_wow_public_struct.h
View File

@@ -36,6 +36,9 @@
#define PMO_WOW_INTER_PTRN_TOKENIZER ';'
#define PMO_WOW_INTRA_PTRN_TOKENIZER ':'
#define PMO_WOW_PTRN_MASK_VALID 0xFF
#define PMO_NUM_BITS_IN_BYTE 8
/* Action frame categories */

35
components/pmo/dispatcher/src/wlan_pmo_tgt_wow.c
View File

@@ -107,7 +107,7 @@ QDF_STATUS pmo_tgt_send_wow_patterns_to_fw(
if (status != QDF_STATUS_SUCCESS) {
if (!user)
pmo_decrement_wow_default_ptrn(vdev_ctx);
pmo_err("Failed to sen wow pattern event");
pmo_err("Failed to send wow pattern event");
goto out;
}
@@ -119,3 +119,36 @@ out:
return status;
}
QDF_STATUS pmo_tgt_del_wow_pattern(
struct wlan_objmgr_vdev *vdev, uint8_t ptrn_id,
bool user)
{
QDF_STATUS status;
struct pmo_vdev_priv_obj *vdev_ctx;
struct wlan_objmgr_psoc *psoc;
struct wlan_pmo_tx_ops pmo_tx_ops;
PMO_ENTER();
psoc = pmo_vdev_get_psoc(vdev);
vdev_ctx = pmo_vdev_get_priv(vdev);
pmo_tx_ops = GET_PMO_TX_OPS_FROM_PSOC(psoc);
if (!pmo_tx_ops.del_wow_pattern) {
pmo_err("del_wow_pattern is null");
status = QDF_STATUS_E_NULL_VALUE;
goto out;
}
status = pmo_tx_ops.del_wow_pattern(vdev, ptrn_id);
if (status) {
status = QDF_STATUS_E_FAILURE;
goto out;
}
if (user)
pmo_decrement_wow_user_ptrn(vdev_ctx);
out:
PMO_EXIT();
return status;
}

12
components/pmo/dispatcher/src/wlan_pmo_ucfg_api.c
View File

@@ -298,6 +298,18 @@ QDF_STATUS pmo_ucfg_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
return pmo_core_psoc_suspend_target(psoc, disable_target_intr);
}
QDF_STATUS pmo_ucfg_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
struct pmo_wow_add_pattern *ptrn)
{
return pmo_core_add_wow_user_pattern(vdev, ptrn);
}
QDF_STATUS pmo_ucfg_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
uint8_t pattern_id)
{
return pmo_core_del_wow_user_pattern(vdev, pattern_id);
}
QDF_STATUS pmo_ucfg_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
enum qdf_suspend_type type)
{

3
components/target_if/pmo/inc/target_if_pmo.h
View File

@@ -69,6 +69,9 @@ QDF_STATUS target_if_pmo_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
uint8_t ptrn_offset, const uint8_t *mask,
uint8_t mask_len, bool user);
QDF_STATUS target_if_pmo_del_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
uint8_t ptrn_id);
/**
* target_if_pmo_send_enhance_mc_offload_req() - send enhance mc offload req
* @vdev: objmgr vdev

2
components/target_if/pmo/src/target_if_pmo_main.c
View File

@@ -43,6 +43,8 @@ void target_if_pmo_register_tx_ops(struct wlan_pmo_tx_ops *pmo_tx_ops)
target_if_pmo_disable_wow_wakeup_event;
pmo_tx_ops->send_add_wow_pattern =
target_if_pmo_send_wow_patterns_to_fw;
pmo_tx_ops->del_wow_pattern =
target_if_pmo_del_wow_patterns_to_fw;
pmo_tx_ops->send_enhance_mc_offload_req =
target_if_pmo_send_enhance_mc_offload_req;
pmo_tx_ops->send_set_mc_filter_req =

26
components/target_if/pmo/src/target_if_pmo_wow.c
View File

@@ -112,3 +112,29 @@ QDF_STATUS target_if_pmo_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
return status;
}
QDF_STATUS target_if_pmo_del_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
uint8_t ptrn_id)
{
uint8_t vdev_id;
struct wlan_objmgr_psoc *psoc;
QDF_STATUS status;
if (!vdev) {
target_if_err("vdev ptr passed is NULL");
return QDF_STATUS_E_INVAL;
}
psoc = wlan_vdev_get_psoc(vdev);
vdev_id = wlan_vdev_get_id(vdev);
if (!psoc) {
target_if_err("psoc handle is NULL");
return QDF_STATUS_E_INVAL;
}
status = wmi_unified_wow_delete_pattern_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), ptrn_id,
vdev_id);
return status;
}

47
core/hdd/src/wlan_hdd_wowl.c
View File

@@ -35,6 +35,7 @@
#include <wlan_hdd_includes.h>
#include <wlan_hdd_wowl.h>
#include <wlan_pmo_wow_public_struct.h>
/* Preprocessor Definitions and Constants */
#define WOWL_INTER_PTRN_TOKENIZER ';'
@@ -78,7 +79,7 @@ static void hdd_wowl_wake_indication_callback(void *pContext,
*
* Return: none
*/
static void dump_hdd_wowl_ptrn(struct wow_add_pattern *ptrn)
static void dump_hdd_wowl_ptrn(struct pmo_wow_add_pattern *ptrn)
{
int i;
@@ -104,11 +105,10 @@ static void dump_hdd_wowl_ptrn(struct wow_add_pattern *ptrn)
*/
bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
{
struct wow_add_pattern localPattern;
struct pmo_wow_add_pattern localPattern;
int i, first_empty_slot, len, offset;
QDF_STATUS qdf_ret_status;
const char *temp;
tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
uint8_t sessionId = adapter->session_id;
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
@@ -166,7 +166,7 @@ bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
(hex_to_bin(ptrn[3]) * 0x10) +
hex_to_bin(ptrn[4]);
if (localPattern.pattern_size > SIR_WOWL_BCAST_PATTERN_MAX_SIZE
if (localPattern.pattern_size > PMO_WOWL_BCAST_PATTERN_MAX_SIZE
|| localPattern.pattern_mask_size >
WOWL_PTRN_MASK_MAX_SIZE) {
hdd_err("Invalid length specified. Skip!");
@@ -229,9 +229,8 @@ bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
localPattern.session_id = sessionId;
/* Register the pattern downstream */
qdf_ret_status =
sme_wow_add_pattern(hHal, &localPattern,
sessionId);
qdf_ret_status = pmo_ucfg_add_wow_user_pattern(
adapter->hdd_vdev, &localPattern);
if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
/* Add failed, so invalidate the local storage */
hdd_err("sme_wowl_add_bcast_pattern failed with error code (%d)",
@@ -264,12 +263,9 @@ next_ptrn:
*/
bool hdd_del_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
{
struct wow_delete_pattern delPattern;
unsigned char id;
tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
bool patternFound = false;
QDF_STATUS qdf_ret_status;
uint8_t sessionId = adapter->session_id;
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
/* Detect pattern */
@@ -284,11 +280,8 @@ bool hdd_del_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
/* If pattern present, remove it from downstream */
if (patternFound) {
delPattern.pattern_id = id;
delPattern.session_id = sessionId;
qdf_ret_status =
sme_wow_delete_pattern(hHal, &delPattern,
sessionId);
qdf_ret_status = pmo_ucfg_del_wow_user_pattern(
adapter->hdd_vdev, id);
if (QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
/* Remove from local storage as well */
hdd_err("Deleted pattern with id %d [%s]", id,
@@ -317,9 +310,8 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
uint8_t pattern_offset, char *pattern_buf,
char *pattern_mask)
{
struct wow_add_pattern localPattern;
struct pmo_wow_add_pattern localPattern;
QDF_STATUS qdf_ret_status;
tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
uint8_t session_id = adapter->session_id;
uint16_t pattern_len, mask_len, i;
@@ -352,10 +344,10 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
localPattern.pattern_size = pattern_len;
localPattern.session_id = session_id;
if (localPattern.pattern_size > SIR_WOWL_BCAST_PATTERN_MAX_SIZE) {
if (localPattern.pattern_size > PMO_WOWL_BCAST_PATTERN_MAX_SIZE) {
hdd_err("WoW pattern size (%d) greater than max (%d)",
localPattern.pattern_size,
SIR_WOWL_BCAST_PATTERN_MAX_SIZE);
PMO_WOWL_BCAST_PATTERN_MAX_SIZE);
return false;
}
/* Extract the pattern */
@@ -397,11 +389,10 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
}
/* Register the pattern downstream */
qdf_ret_status =
sme_wow_add_pattern(hHal, &localPattern, session_id);
qdf_ret_status = pmo_ucfg_add_wow_user_pattern(
adapter->hdd_vdev, &localPattern);
if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
hdd_err("sme_wowl_add_bcast_pattern failed with error code (%d).",
hdd_err("pmo_wow_user_pattern failed with error code (%d).",
qdf_ret_status);
return false;
@@ -429,10 +420,7 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
bool hdd_del_wowl_ptrn_debugfs(struct hdd_adapter *adapter,
uint8_t pattern_idx)
{
struct wow_delete_pattern delPattern;
tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
QDF_STATUS qdf_ret_status;
uint8_t sessionId = adapter->session_id;
if (pattern_idx > (WOWL_MAX_PTRNS_ALLOWED - 1)) {
hdd_err("WoW pattern index %d is not in the range (0 ~ %d).",
@@ -448,11 +436,8 @@ bool hdd_del_wowl_ptrn_debugfs(struct hdd_adapter *adapter,
return false;
}
delPattern.pattern_id = pattern_idx;
delPattern.session_id = sessionId;
qdf_ret_status = sme_wow_delete_pattern(hHal, &delPattern,
sessionId);
qdf_ret_status = pmo_ucfg_del_wow_user_pattern(
adapter->hdd_vdev, pattern_idx);
if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
hdd_err("sme_wowl_del_bcast_pattern failed with error code (%d).",
qdf_ret_status);

34
core/mac/inc/sir_api.h
View File

@@ -2384,40 +2384,6 @@ typedef struct sSmeCsaOffloadInd {
struct qdf_mac_addr bssid; /* BSSID */
} tSmeCsaOffloadInd, *tpSmeCsaOffloadInd;
/* WOW related structures */
#define SIR_WOWL_BCAST_PATTERN_MAX_SIZE 146
/**
* struct wow_add_pattern - wow pattern add structure
* @pattern_id: pattern id
* @pattern_byte_offset: pattern byte offset from beginning of the 802.11
* packet to start of the wake-up pattern
* @pattern_size: pattern size
* @pattern: pattern byte stream
* @pattern_mask_size: pattern mask size
* @pattern_mask: pattern mask
* @session_id: session id
*/
struct wow_add_pattern {
uint8_t pattern_id;
uint8_t pattern_byte_offset;
uint8_t pattern_size;
uint8_t pattern[SIR_WOWL_BCAST_PATTERN_MAX_SIZE];
uint8_t pattern_mask_size;
uint8_t pattern_mask[SIR_WOWL_BCAST_PATTERN_MAX_SIZE];
uint8_t session_id;
};
/**
* struct wow_delete_patern - wow pattern delete structure
* @pattern_id: pattern id of wake up pattern to be deleted
* @session_id: session id
*/
struct wow_delete_pattern {
uint8_t pattern_id;
uint8_t session_id;
};
/* SME->PE: Enter WOWLAN parameters */
typedef struct sSirSmeWowlEnterParams {
uint8_t sessionId;

5
core/sme/inc/sme_api.h
View File

@@ -412,11 +412,6 @@ static inline void sme_deregister_oem_data_rsp_callback(tHalHandle h_hal)
#endif
extern QDF_STATUS sme_wow_add_pattern(tHalHandle hHal,
struct wow_add_pattern *pattern, uint8_t sessionId);
extern QDF_STATUS sme_wow_delete_pattern(tHalHandle hHal,
struct wow_delete_pattern *pattern, uint8_t sessionId);
void sme_register_ftm_msg_processor(tHalHandle hal,
hdd_ftm_msg_processor callback);

87
core/sme/src/common/sme_api.c
View File

@@ -4197,93 +4197,6 @@ void sme_register_ftm_msg_processor(tHalHandle hal,
mac_ctx->ftm_msg_processor_callback = callback;
}
/**
* sme_wow_add_pattern() - add a wow pattern in fw
* @hHal: handle returned by mac_open
* @pattern: pointer to input pattern
*
* Add a pattern for Pattern Byte Matching in WoW mode. Firmware will
* do a pattern match on these patterns when WoW is enabled during system
* suspend.
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_wow_add_pattern(tHalHandle hal,
struct wow_add_pattern *pattern,
uint8_t session_id)
{
tpAniSirGlobal pMac = PMAC_STRUCT(hal);
struct wow_add_pattern *ptrn;
tSirRetStatus ret_code = eSIR_SUCCESS;
struct scheduler_msg msg_q = {0};
MTRACE(qdf_trace(QDF_MODULE_ID_SME,
TRACE_CODE_SME_RX_HDD_WOWL_ADDBCAST_PATTERN, session_id,
0));
ptrn = qdf_mem_malloc(sizeof(*ptrn));
if (NULL == ptrn) {
sme_err("Fail to allocate memory for WoWLAN Add Bcast Pattern");
return QDF_STATUS_E_NOMEM;
}
(void)qdf_mem_copy(ptrn, pattern, sizeof(*ptrn));
msg_q.type = WMA_WOW_ADD_PTRN;
msg_q.reserved = 0;
msg_q.bodyptr = ptrn;
msg_q.bodyval = 0;
sme_debug("Sending WMA_WOWL_ADD_BCAST_PTRN to HAL");
ret_code = wma_post_ctrl_msg(pMac, &msg_q);
if (eSIR_SUCCESS != ret_code) {
sme_err("Posting WMA_WOWL_ADD_BCAST_PTRN failed, reason: %X",
ret_code);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* sme_wow_delete_pattern() - delete user configured wow pattern in target
* @hHal: handle returned by mac_open.
* @pattern: pointer to delete pattern parameter
* @sessionId: session id
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_wow_delete_pattern(tHalHandle hal,
struct wow_delete_pattern *pattern, uint8_t sessionId)
{
tpAniSirGlobal pMac = PMAC_STRUCT(hal);
struct wow_delete_pattern *delete_ptrn;
tSirRetStatus ret_code = eSIR_SUCCESS;
struct scheduler_msg msg_q = {0};
MTRACE(qdf_trace(QDF_MODULE_ID_SME,
TRACE_CODE_SME_RX_HDD_WOWL_DELBCAST_PATTERN, sessionId,
0));
delete_ptrn = qdf_mem_malloc(sizeof(*delete_ptrn));
if (NULL == delete_ptrn) {
sme_err("Allocation failed for WoWLAN Delete Bcast Pattern");
return QDF_STATUS_E_NOMEM;
}
(void)qdf_mem_copy(delete_ptrn, pattern, sizeof(*delete_ptrn));
msg_q.type = WMA_WOW_DEL_PTRN;
msg_q.reserved = 0;
msg_q.bodyptr = delete_ptrn;
msg_q.bodyval = 0;
sme_debug("Sending WMA_WOWL_DEL_BCAST_PTRN");
ret_code = wma_post_ctrl_msg(pMac, &msg_q);
if (eSIR_SUCCESS != ret_code) {
sme_err("Posting WMA_WOWL_DEL_BCAST_PTRN failed, reason: %X",
ret_code);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* sme_enter_wowl(): SME API exposed to HDD to request enabling of WOWL mode.
* @hal_ctx - The handle returned by mac_open.

6
core/wma/inc/wma_internal.h
View File

@@ -997,12 +997,6 @@ int wma_wow_wakeup_host_event(void *handle, uint8_t *event,
uint32_t len);
int wma_pdev_resume_event_handler(void *handle, uint8_t *event, uint32_t len);
QDF_STATUS wma_wow_add_pattern(tp_wma_handle wma,
struct wow_add_pattern *ptrn);
QDF_STATUS wma_wow_delete_user_pattern(tp_wma_handle wma,
struct wow_delete_pattern *pattern);
QDF_STATUS wma_wow_enter(tp_wma_handle wma, tpSirHalWowlEnterParams info);
QDF_STATUS wma_wow_exit(tp_wma_handle wma, tpSirHalWowlExitParams info);

37
core/wma/src/wma_features.c
View File

@@ -2846,43 +2846,6 @@ static inline void wma_set_wow_bus_suspend(tp_wma_handle wma, int val)
wmi_set_is_wow_bus_suspended(wma->wmi_handle, val);
}
/**
* wma_wow_add_pattern() - add wow pattern in target
* @wma: wma handle
* @ptrn: wow pattern
*
* This function does following:
* 1) Delete all default patterns of the vdev
* 2) Add received wow patterns for given vdev in target.
*
* Target is responsible for caching wow patterns accross multiple
* suspend/resumes until the pattern is deleted by user
*
* Return: QDF status
*/
QDF_STATUS wma_wow_add_pattern(tp_wma_handle wma, struct wow_add_pattern *ptrn)
{
return QDF_STATUS_SUCCESS;
}
/**
* wma_wow_delete_user_pattern() - delete user configured wow pattern in target
* @wma: wma handle
* @ptrn: wow pattern
*
* This function does following:
* 1) Deletes a particular user configured wow pattern in target
* 2) After deleting all user wow patterns add default wow patterns
* specific to that vdev.
*
* Return: QDF status
*/
QDF_STATUS wma_wow_delete_user_pattern(tp_wma_handle wma,
struct wow_delete_pattern *pattern)
{
return QDF_STATUS_SUCCESS;
}
/**
* wma_wow_enter() - store enable/disable status for pattern
* @wma: wma handle

10
core/wma/src/wma_main.c
View File

@@ -7437,16 +7437,6 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
wma_aggr_qos_req(wma_handle, (tAggrAddTsParams *) msg->bodyptr);
break;
case WMA_WOW_ADD_PTRN:
wma_wow_add_pattern(wma_handle,
(struct wow_add_pattern *) msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case WMA_WOW_DEL_PTRN:
wma_wow_delete_user_pattern(wma_handle,
(struct wow_delete_pattern *) msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case WMA_WOWL_ENTER_REQ:
wma_wow_enter(wma_handle,
(tpSirHalWowlEnterParams) msg->bodyptr);