samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Rozštěpit 0
Zdrojový kód Úkoly Pull requesty Akce Balíčky Projekty Vydání Wiki Aktivita

qcacld-3.0: Move CLD components outside core folder

Procházet zdrojové kódy 
Core is legacy module folder in CLD. Hence move MCL specific
components folder outside core.

Change-Id: Iba3f9fdb06ad10dc4a5b19f3ff1ffa23f7372605
CRs-Fixed: 2077963
Tento commit je obsažen v:
Rajeev Kumar
2017-07-17 17:48:16 -07:00
odevzdal snandini
revize e3005cac45
61 změnil soubory, kde provedl 13623 přidání a 0 odebrání
Stáhněte soubor záplaty Stáhněte rozdílový soubor Rozbalit všechny soubory Sbalit všechny soubory

61
target_if/pmo/src/target_if_pmo_arp.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,61 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_arp.c
*
* Target interface file for pmo component to
* send arp offload related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
QDF_STATUS target_if_pmo_send_arp_offload_req(
struct wlan_objmgr_vdev *vdev,
struct pmo_arp_offload_params *arp_offload_req,
struct pmo_ns_offload_params *ns_offload_req)
{
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_enable_arp_ns_offload_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
arp_offload_req,
ns_offload_req,
vdev_id);
if (status != QDF_STATUS_SUCCESS)
target_if_err("Failed to enable ARP NDP/NSffload");
return status;
}

137
target_if/pmo/src/target_if_pmo_gtk.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,137 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_gtk.c
*
* Target interface file for pmo component to
* send gtk offload related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
QDF_STATUS target_if_pmo_send_gtk_offload_req(struct wlan_objmgr_vdev *vdev,
struct pmo_gtk_req *gtk_req)
{
uint8_t vdev_id;
QDF_STATUS status;
uint32_t gtk_offload_opcode;
struct wlan_objmgr_psoc *psoc;
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;
}
if (gtk_req->flags == PMO_GTK_OFFLOAD_ENABLE)
gtk_offload_opcode = GTK_OFFLOAD_ENABLE_OPCODE;
else
gtk_offload_opcode = GTK_OFFLOAD_DISABLE_OPCODE;
status = wmi_unified_send_gtk_offload_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
vdev_id,
gtk_req,
gtk_req->flags,
gtk_offload_opcode);
if (status)
target_if_err("Failed to send gtk offload cmd to fw");
return status;
}
QDF_STATUS target_if_pmo_send_gtk_response_req(struct wlan_objmgr_vdev *vdev)
{
uint8_t vdev_id;
struct wlan_objmgr_psoc *psoc;
QDF_STATUS status = QDF_STATUS_SUCCESS;
uint32_t offload_req_opcode;
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;
}
/* Request for GTK offload status */
offload_req_opcode = GTK_OFFLOAD_REQUEST_STATUS_OPCODE;
/* send the wmi command */
status = wmi_unified_process_gtk_offload_getinfo_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
vdev_id, offload_req_opcode);
return status;
}
int target_if_pmo_gtk_offload_status_event(void *scn_handle,
uint8_t *event, uint32_t len)
{
struct pmo_gtk_rsp_params *gtk_rsp_param;
struct wlan_objmgr_psoc *psoc;
QDF_STATUS ret;
TARGET_IF_ENTER();
psoc = target_if_get_psoc_from_scn_hdl(scn_handle);
if (!psoc) {
target_if_err("psoc ptr is NULL");
ret = -EINVAL;
goto out;
}
gtk_rsp_param = qdf_mem_malloc(sizeof(*gtk_rsp_param));
if (!gtk_rsp_param) {
target_if_err("memory allocation failed");
ret = -ENOMEM;
goto out;
}
if (wmi_extract_gtk_rsp_event(GET_WMI_HDL_FROM_PSOC(psoc),
event, gtk_rsp_param, len) != QDF_STATUS_SUCCESS) {
target_if_err("Extraction of gtk rsp event failed");
qdf_mem_free(gtk_rsp_param);
ret = -EINVAL;
goto out;
}
ret = pmo_tgt_gtk_rsp_evt(psoc, (void *)gtk_rsp_param);
if (ret != QDF_STATUS_SUCCESS) {
target_if_err("Failed to rx_gtk_rsp_event");
ret = -EINVAL;
}
qdf_mem_free(gtk_rsp_param);
out:
TARGET_IF_EXIT();
return ret;
}

48
target_if/pmo/src/target_if_pmo_hw_filter.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,48 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_non_arp_bcast_fltr.c
*
* Target interface file for pmo component to
* send non arp hw bcast filtering related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
#include "wlan_pmo_hw_filter_public_struct.h"
QDF_STATUS target_if_pmo_conf_hw_filter(struct wlan_objmgr_psoc *psoc,
struct pmo_hw_filter_params *req)
{
QDF_STATUS status;
if (!psoc) {
target_if_err("psoc is NULL");
return QDF_STATUS_E_INVAL;
}
status = wmi_unified_conf_hw_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
req);
if (QDF_IS_STATUS_ERROR(status))
target_if_err("Failed to configure HW Filter");
return status;
}

304
target_if/pmo/src/target_if_pmo_lphb.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,304 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_lphb.c
*
* Target interface file for pmo component to
* send lphb offload related cmd and process event.
*/
#ifdef FEATURE_WLAN_LPHB
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_pmo_api.h"
QDF_STATUS target_if_pmo_send_lphb_enable(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_enable_req *ts_lphb_enable)
{
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
wmi_hb_set_enable_cmd_fixed_param hb_enable_fp;
if (ts_lphb_enable == NULL) {
target_if_err("LPHB Enable configuration is NULL");
return QDF_STATUS_E_FAILURE;
}
target_if_info("PMO_HB_SET_ENABLE enable=%d, item=%d, session=%d",
ts_lphb_enable->enable,
ts_lphb_enable->item, ts_lphb_enable->session);
if ((ts_lphb_enable->item != 1) && (ts_lphb_enable->item != 2)) {
target_if_err("LPHB configuration wrong item %d",
ts_lphb_enable->item);
return QDF_STATUS_E_FAILURE;
}
/* fill in values */
hb_enable_fp.vdev_id = ts_lphb_enable->session;
hb_enable_fp.enable = ts_lphb_enable->enable;
hb_enable_fp.item = ts_lphb_enable->item;
hb_enable_fp.session = ts_lphb_enable->session;
status = wmi_unified_lphb_config_hbenable_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
&hb_enable_fp);
if (status != EOK) {
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
return QDF_STATUS_SUCCESS;
error:
return qdf_status;
}
QDF_STATUS target_if_pmo_send_lphb_tcp_params(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_tcp_params *ts_lphb_tcp_param)
{
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
wmi_hb_set_tcp_params_cmd_fixed_param hb_tcp_params_fp = {0};
if (ts_lphb_tcp_param == NULL) {
target_if_err("TCP params LPHB configuration is NULL");
return QDF_STATUS_E_FAILURE;
}
target_if_info("PMO --> WMI_HB_SET_TCP_PARAMS srv_ip=%08x, "
"dev_ip=%08x, src_port=%d, dst_port=%d, timeout=%d, "
"session=%d, gateway_mac= %pM, time_period_sec=%d,"
"tcp_sn=%d", ts_lphb_tcp_param->srv_ip,
ts_lphb_tcp_param->dev_ip, ts_lphb_tcp_param->src_port,
ts_lphb_tcp_param->dst_port, ts_lphb_tcp_param->timeout,
ts_lphb_tcp_param->session,
ts_lphb_tcp_param->gateway_mac.bytes,
ts_lphb_tcp_param->time_period_sec, ts_lphb_tcp_param->tcp_sn);
/* fill in values */
hb_tcp_params_fp.vdev_id = ts_lphb_tcp_param->session;
hb_tcp_params_fp.srv_ip = ts_lphb_tcp_param->srv_ip;
hb_tcp_params_fp.dev_ip = ts_lphb_tcp_param->dev_ip;
hb_tcp_params_fp.seq = ts_lphb_tcp_param->tcp_sn;
hb_tcp_params_fp.src_port = ts_lphb_tcp_param->src_port;
hb_tcp_params_fp.dst_port = ts_lphb_tcp_param->dst_port;
hb_tcp_params_fp.interval = ts_lphb_tcp_param->time_period_sec;
hb_tcp_params_fp.timeout = ts_lphb_tcp_param->timeout;
hb_tcp_params_fp.session = ts_lphb_tcp_param->session;
WMI_CHAR_ARRAY_TO_MAC_ADDR(ts_lphb_tcp_param->gateway_mac.bytes,
&hb_tcp_params_fp.gateway_mac);
status = wmi_unified_lphb_config_tcp_params_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
&hb_tcp_params_fp);
if (status != EOK) {
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
return QDF_STATUS_SUCCESS;
error:
return qdf_status;
}
QDF_STATUS target_if_pmo_send_lphb_tcp_pkt_filter(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_tcp_filter_req *ts_lphb_tcp_filter)
{
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
wmi_hb_set_tcp_pkt_filter_cmd_fixed_param hb_tcp_filter_fp = {0};
if (ts_lphb_tcp_filter == NULL) {
target_if_err("TCP PKT FILTER LPHB configuration is NULL");
return QDF_STATUS_E_FAILURE;
}
target_if_info("SET_TCP_PKT_FILTER length=%d, offset=%d, session=%d, "
"filter=%2x:%2x:%2x:%2x:%2x:%2x ...",
ts_lphb_tcp_filter->length, ts_lphb_tcp_filter->offset,
ts_lphb_tcp_filter->session, ts_lphb_tcp_filter->filter[0],
ts_lphb_tcp_filter->filter[1], ts_lphb_tcp_filter->filter[2],
ts_lphb_tcp_filter->filter[3], ts_lphb_tcp_filter->filter[4],
ts_lphb_tcp_filter->filter[5]);
/* fill in values */
hb_tcp_filter_fp.vdev_id = ts_lphb_tcp_filter->session;
hb_tcp_filter_fp.length = ts_lphb_tcp_filter->length;
hb_tcp_filter_fp.offset = ts_lphb_tcp_filter->offset;
hb_tcp_filter_fp.session = ts_lphb_tcp_filter->session;
memcpy((void *)&hb_tcp_filter_fp.filter,
(void *)&ts_lphb_tcp_filter->filter,
WMI_WLAN_HB_MAX_FILTER_SIZE);
status = wmi_unified_lphb_config_tcp_pkt_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
&hb_tcp_filter_fp);
if (status != EOK) {
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
return QDF_STATUS_SUCCESS;
error:
return qdf_status;
}
QDF_STATUS target_if_pmo_send_lphb_udp_params(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_udp_params *ts_lphb_udp_param)
{
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
wmi_hb_set_udp_params_cmd_fixed_param hb_udp_params_fp = {0};
if (ts_lphb_udp_param == NULL) {
target_if_err("UDP param for LPHB configuration is NULL");
return QDF_STATUS_E_FAILURE;
}
target_if_info("HB_SET_UDP_PARAMS srv_ip=%d, dev_ip=%d, src_port=%d, "
"dst_port=%d, interval=%d, timeout=%d, session=%d, "
"gateway_mac= %pM",
ts_lphb_udp_param->srv_ip, ts_lphb_udp_param->dev_ip,
ts_lphb_udp_param->src_port, ts_lphb_udp_param->dst_port,
ts_lphb_udp_param->interval, ts_lphb_udp_param->timeout,
ts_lphb_udp_param->session,
ts_lphb_udp_param->gateway_mac.bytes);
/* fill in values */
hb_udp_params_fp.vdev_id = ts_lphb_udp_param->session;
hb_udp_params_fp.srv_ip = ts_lphb_udp_param->srv_ip;
hb_udp_params_fp.dev_ip = ts_lphb_udp_param->dev_ip;
hb_udp_params_fp.src_port = ts_lphb_udp_param->src_port;
hb_udp_params_fp.dst_port = ts_lphb_udp_param->dst_port;
hb_udp_params_fp.interval = ts_lphb_udp_param->interval;
hb_udp_params_fp.timeout = ts_lphb_udp_param->timeout;
hb_udp_params_fp.session = ts_lphb_udp_param->session;
WMI_CHAR_ARRAY_TO_MAC_ADDR(ts_lphb_udp_param->gateway_mac.bytes,
&hb_udp_params_fp.gateway_mac);
status = wmi_unified_lphb_config_udp_params_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
&hb_udp_params_fp);
if (status != EOK) {
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
return QDF_STATUS_SUCCESS;
error:
return qdf_status;
}
/**
* target_if_pmo_lphb_send_udp_pkt_filter() - Send LPHB udp pkt filter req
* @psoc: objmgr psoc handle
* @ts_lphb_udp_filter: lphb udp filter request which needs to configure in fwr
*
* Return: QDF status
*/
QDF_STATUS target_if_pmo_send_lphb_udp_pkt_filter(struct wlan_objmgr_psoc *psoc,
struct pmo_lphb_udp_filter_req *ts_lphb_udp_filter)
{
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
wmi_hb_set_udp_pkt_filter_cmd_fixed_param hb_udp_filter_fp = {0};
if (ts_lphb_udp_filter == NULL) {
target_if_err("LPHB UDP packet filter configuration is NULL");
return QDF_STATUS_E_FAILURE;
}
target_if_info("SET_UDP_PKT_FILTER length=%d, offset=%d, session=%d, "
"filter=%2x:%2x:%2x:%2x:%2x:%2x ...",
ts_lphb_udp_filter->length, ts_lphb_udp_filter->offset,
ts_lphb_udp_filter->session, ts_lphb_udp_filter->filter[0],
ts_lphb_udp_filter->filter[1], ts_lphb_udp_filter->filter[2],
ts_lphb_udp_filter->filter[3], ts_lphb_udp_filter->filter[4],
ts_lphb_udp_filter->filter[5]);
/* fill in values */
hb_udp_filter_fp.vdev_id = ts_lphb_udp_filter->session;
hb_udp_filter_fp.length = ts_lphb_udp_filter->length;
hb_udp_filter_fp.offset = ts_lphb_udp_filter->offset;
hb_udp_filter_fp.session = ts_lphb_udp_filter->session;
qdf_mem_copy((void *)&hb_udp_filter_fp.filter,
(void *)&ts_lphb_udp_filter->filter,
WMI_WLAN_HB_MAX_FILTER_SIZE);
status = wmi_unified_lphb_config_udp_pkt_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
&hb_udp_filter_fp);
if (status != EOK) {
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
return QDF_STATUS_SUCCESS;
error:
return qdf_status;
}
QDF_STATUS target_if_pmo_lphb_evt_handler(struct wlan_objmgr_psoc *psoc,
uint8_t *event)
{
wmi_hb_ind_event_fixed_param *hb_fp;
struct pmo_lphb_rsp *slphb_indication = NULL;
QDF_STATUS qdf_status;
TARGET_IF_ENTER();
if (!psoc) {
target_if_err("psoc ptr is NULL");
qdf_status = QDF_STATUS_E_NULL_VALUE;
goto out;
}
hb_fp = (wmi_hb_ind_event_fixed_param *) event;
if (!hb_fp) {
target_if_err("Invalid wmi_hb_ind_event_fixed_param buffer");
qdf_status = QDF_STATUS_E_INVAL;
goto out;
}
target_if_debug("lphb indication received with\n"
"vdev_id=%d, session=%d, reason=%d",
hb_fp->vdev_id, hb_fp->session, hb_fp->reason);
slphb_indication = (struct pmo_lphb_rsp *)qdf_mem_malloc(
sizeof(struct pmo_lphb_rsp));
if (!slphb_indication) {
target_if_err("Invalid LPHB indication buffer");
qdf_status = QDF_STATUS_E_NOMEM;
goto out;
}
slphb_indication->session_idx = hb_fp->session;
slphb_indication->protocol_type = hb_fp->reason;
slphb_indication->event_reason = hb_fp->reason;
qdf_status = pmo_tgt_lphb_rsp_evt(psoc, slphb_indication);
if (qdf_status != QDF_STATUS_SUCCESS)
target_if_err("Failed to lphb_rsp_event");
out:
if (slphb_indication)
qdf_mem_free(slphb_indication);
return qdf_status;
}
#endif

100
target_if/pmo/src/target_if_pmo_main.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,100 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: Target interface file for pmo component to
* Implement api's which shall be used by pmo component
* in target if internally.
*/
#include "target_if_pmo.h"
#include "wlan_pmo_common_public_struct.h"
void target_if_pmo_register_tx_ops(struct wlan_pmo_tx_ops *pmo_tx_ops)
{
if (!pmo_tx_ops) {
target_if_err("pmo_tx_ops is null");
return;
}
pmo_tx_ops->send_arp_offload_req =
target_if_pmo_send_arp_offload_req;
pmo_tx_ops->send_conf_hw_filter_req =
target_if_pmo_conf_hw_filter;
pmo_tx_ops->send_ns_offload_req =
target_if_pmo_send_ns_offload_req;
pmo_tx_ops->send_enable_wow_wakeup_event_req =
target_if_pmo_enable_wow_wakeup_event;
pmo_tx_ops->send_disable_wow_wakeup_event_req =
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->send_enhance_mc_offload_req =
target_if_pmo_send_enhance_mc_offload_req;
pmo_tx_ops->send_set_mc_filter_req =
target_if_pmo_set_mc_filter_req;
pmo_tx_ops->send_clear_mc_filter_req =
target_if_pmo_clear_mc_filter_req;
pmo_tx_ops->send_ra_filter_req =
target_if_pmo_send_ra_filter_req;
pmo_tx_ops->send_gtk_offload_req =
target_if_pmo_send_gtk_offload_req;
pmo_tx_ops->send_get_gtk_rsp_cmd =
target_if_pmo_send_gtk_response_req;
pmo_tx_ops->send_action_frame_pattern_req =
target_if_pmo_send_action_frame_patterns;
pmo_tx_ops->send_lphb_enable =
target_if_pmo_send_lphb_enable;
pmo_tx_ops->send_lphb_tcp_params =
target_if_pmo_send_lphb_tcp_params;
pmo_tx_ops->send_lphb_tcp_filter_req =
target_if_pmo_send_lphb_tcp_pkt_filter;
pmo_tx_ops->send_lphb_upd_params =
target_if_pmo_send_lphb_udp_params;
pmo_tx_ops->send_lphb_udp_filter_req =
target_if_pmo_send_lphb_udp_pkt_filter;
pmo_tx_ops->send_vdev_param_update_req =
target_if_pmo_send_vdev_update_param_req;
pmo_tx_ops->send_vdev_sta_ps_param_req =
target_if_pmo_send_vdev_ps_param_req;
pmo_tx_ops->psoc_update_wow_bus_suspend =
target_if_pmo_psoc_update_bus_suspend;
pmo_tx_ops->psoc_get_host_credits =
target_if_pmo_psoc_get_host_credits;
pmo_tx_ops->psoc_get_pending_cmnds =
target_if_pmo_psoc_get_pending_cmnds;
pmo_tx_ops->update_target_suspend_flag =
target_if_pmo_update_target_suspend_flag;
pmo_tx_ops->psoc_send_wow_enable_req =
target_if_pmo_psoc_send_wow_enable_req;
pmo_tx_ops->psoc_send_supend_req =
target_if_pmo_psoc_send_suspend_req;
pmo_tx_ops->psoc_set_runtime_pm_in_progress =
target_if_pmo_set_runtime_pm_in_progress;
pmo_tx_ops->psoc_get_runtime_pm_in_progress =
target_if_pmo_get_runtime_pm_in_progress;
pmo_tx_ops->psoc_send_host_wakeup_ind =
target_if_pmo_psoc_send_host_wakeup_ind;
pmo_tx_ops->psoc_send_target_resume_req =
target_if_pmo_psoc_send_target_resume_req;
pmo_tx_ops->send_set_pkt_filter =
target_if_pmo_send_pkt_filter_req;
pmo_tx_ops->send_clear_pkt_filter =
target_if_pmo_clear_pkt_filter_req;
}

91
target_if/pmo/src/target_if_pmo_mc_addr_filtering.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,91 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_mc_addr_filtering.c
*
* Target interface file for pmo component to
* send mc address filtering offload related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
QDF_STATUS target_if_pmo_set_mc_filter_req(
struct wlan_objmgr_vdev *vdev,
struct qdf_mac_addr multicast_addr)
{
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_add_clear_mcbc_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
vdev_id,
multicast_addr, false);
if (status)
target_if_err("Failed to send add/clear mcbc filter cmd");
return status;
}
QDF_STATUS target_if_pmo_clear_mc_filter_req(
struct wlan_objmgr_vdev *vdev,
struct qdf_mac_addr multicast_addr)
{
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_add_clear_mcbc_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
vdev_id,
multicast_addr, true);
if (status)
target_if_err("Failed to send add/clear mcbc filter cmd");
return status;
}

60
target_if/pmo/src/target_if_pmo_ns.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,60 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_ns.c
*
* Target interface file for pmo component to
* send ns offload related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
QDF_STATUS target_if_pmo_send_ns_offload_req(
struct wlan_objmgr_vdev *vdev,
struct pmo_arp_offload_params *arp_offload_req,
struct pmo_ns_offload_params *ns_offload_req)
{
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_enable_arp_ns_offload_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
arp_offload_req,
ns_offload_req,
vdev_id);
if (status != QDF_STATUS_SUCCESS)
target_if_err("Failed to enable ARP NDP/NSffload");
return status;
}

97
target_if/pmo/src/target_if_pmo_pkt_filter.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,97 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_pkt_filter.c
*
* Target interface file for pmo component to
* send packet filter related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_pmo_api.h"
#include "wlan_pmo_pkt_filter_public_struct.h"
QDF_STATUS target_if_pmo_send_pkt_filter_req(struct wlan_objmgr_vdev *vdev,
struct pmo_rcv_pkt_fltr_cfg *rcv_filter_param)
{
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;
}
/* send the command along with data */
status = wmi_unified_config_packet_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), vdev_id,
rcv_filter_param,
rcv_filter_param->filter_id, true);
if (status) {
target_if_err("Failed to send pkt_filter cmd");
return QDF_STATUS_E_INVAL;
}
/* Enable packet filter */
status = wmi_unified_enable_disable_packet_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
vdev_id, true);
if (status)
target_if_err("Failed to send packet filter wmi cmd to fw");
return status;
}
QDF_STATUS target_if_pmo_clear_pkt_filter_req(struct wlan_objmgr_vdev *vdev,
struct pmo_rcv_pkt_fltr_clear_param *rcv_clear_param)
{
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;
}
/* send the command along with data */
status = wmi_unified_config_packet_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), vdev_id,
NULL, rcv_clear_param->filter_id, false);
if (status)
target_if_err("Failed to clear filter cmd");
return status;
}

113
target_if/pmo/src/target_if_pmo_static_config.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,113 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_static.c
*
* Target interface file for pmo component to
* send wow related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
QDF_STATUS target_if_pmo_send_ra_filter_req(struct wlan_objmgr_vdev *vdev,
uint8_t default_pattern, uint16_t rate_limit_interval)
{
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_sta_ra_filter_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), vdev_id,
default_pattern, rate_limit_interval);
if (status)
target_if_err("Failed to send RA rate limit to fw");
return status;
}
QDF_STATUS target_if_pmo_send_action_frame_patterns(
struct wlan_objmgr_vdev *vdev,
struct pmo_action_wakeup_set_params *ip_cmd)
{
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_action_frame_patterns_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), ip_cmd);
if (status != QDF_STATUS_SUCCESS)
target_if_err("Failed to config wow action frame map, ret %d",
status);
return status;
}
QDF_STATUS target_if_pmo_send_enhance_mc_offload_req(
struct wlan_objmgr_vdev *vdev, bool enable)
{
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_enable_enhance_multicast_offload_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), vdev_id, enable);
if (status)
target_if_err("Failed to config wow wakeup event");
return status;
}

185
target_if/pmo/src/target_if_pmo_suspend_resume.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,185 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_static.c
*
* Target interface file for pmo component to
* send suspend / resume related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
#define TGT_WILDCARD_PDEV_ID 0x0
QDF_STATUS target_if_pmo_send_vdev_update_param_req(
struct wlan_objmgr_vdev *vdev,
uint32_t param_id, uint32_t param_value)
{
uint8_t vdev_id;
struct wlan_objmgr_psoc *psoc;
struct vdev_set_params param = {0};
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;
}
switch (param_id) {
case pmo_vdev_param_listen_interval:
param_id = WMI_VDEV_PARAM_LISTEN_INTERVAL;
break;
case pmo_vdev_param_dtim_policy:
param_id = WMI_VDEV_PARAM_DTIM_POLICY;
break;
default:
target_if_err("invalid vdev param id %d", param_id);
return QDF_STATUS_E_INVAL;
}
param.if_id = vdev_id;
param.param_id = param_id;
param.param_value = param_value;
target_if_info("set vdev param vdev_id: %d value: %d for param_id: %d",
vdev_id, param_value, param_id);
return wmi_unified_vdev_set_param_send(GET_WMI_HDL_FROM_PSOC(psoc),
&param);
}
QDF_STATUS target_if_pmo_send_vdev_ps_param_req(
struct wlan_objmgr_vdev *vdev,
uint32_t param_id,
uint32_t param_value)
{
uint8_t vdev_id;
struct wlan_objmgr_psoc *psoc;
QDF_STATUS status;
struct sta_ps_params sta_ps_param = {0};
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;
}
switch (param_id) {
case pmo_sta_ps_enable_qpower:
param_id = WMI_STA_PS_ENABLE_QPOWER;
break;
default:
target_if_err("invalid vdev param id %d", param_id);
return QDF_STATUS_E_INVAL;
}
sta_ps_param.vdev_id = vdev_id;
sta_ps_param.param = param_id;
sta_ps_param.value = param_value;
target_if_info("set vdev param vdev_id: %d value: %d for param_id: %d",
vdev_id, param_value, param_id);
status = wmi_unified_sta_ps_cmd_send(GET_WMI_HDL_FROM_PSOC(psoc),
&sta_ps_param);
if (QDF_IS_STATUS_ERROR(status))
return status;
return status;
}
void target_if_pmo_psoc_update_bus_suspend(struct wlan_objmgr_psoc *psoc,
uint8_t value)
{
wmi_set_is_wow_bus_suspended(GET_WMI_HDL_FROM_PSOC(psoc), value);
}
int target_if_pmo_psoc_get_host_credits(struct wlan_objmgr_psoc *psoc)
{
return wmi_get_host_credits(GET_WMI_HDL_FROM_PSOC(psoc));
}
int target_if_pmo_psoc_get_pending_cmnds(struct wlan_objmgr_psoc *psoc)
{
return wmi_get_pending_cmds(GET_WMI_HDL_FROM_PSOC(psoc));
}
void target_if_pmo_update_target_suspend_flag(struct wlan_objmgr_psoc *psoc,
uint8_t value)
{
wmi_set_target_suspend(GET_WMI_HDL_FROM_PSOC(psoc), value);
}
QDF_STATUS target_if_pmo_psoc_send_wow_enable_req(
struct wlan_objmgr_psoc *psoc,
struct pmo_wow_cmd_params *param)
{
return wmi_unified_wow_enable_send(GET_WMI_HDL_FROM_PSOC(psoc),
(struct wow_cmd_params *)param,
TGT_WILDCARD_PDEV_ID);
}
QDF_STATUS target_if_pmo_psoc_send_suspend_req(
struct wlan_objmgr_psoc *psoc,
struct pmo_suspend_params *param)
{
return wmi_unified_suspend_send(GET_WMI_HDL_FROM_PSOC(psoc),
(struct suspend_params *) param,
TGT_WILDCARD_PDEV_ID);
}
void target_if_pmo_set_runtime_pm_in_progress(struct wlan_objmgr_psoc *psoc,
bool value)
{
return wmi_set_runtime_pm_inprogress(GET_WMI_HDL_FROM_PSOC(psoc),
value);
}
bool target_if_pmo_get_runtime_pm_in_progress(
struct wlan_objmgr_psoc *psoc)
{
return wmi_get_runtime_pm_inprogress(GET_WMI_HDL_FROM_PSOC(psoc));
}
QDF_STATUS target_if_pmo_psoc_send_host_wakeup_ind(
struct wlan_objmgr_psoc *psoc)
{
return wmi_unified_host_wakeup_ind_to_fw_cmd(
GET_WMI_HDL_FROM_PSOC(psoc));
}
QDF_STATUS target_if_pmo_psoc_send_target_resume_req(
struct wlan_objmgr_psoc *psoc)
{
return wmi_unified_resume_send(GET_WMI_HDL_FROM_PSOC(psoc),
TGT_WILDCARD_PDEV_ID);
}

114
target_if/pmo/src/target_if_pmo_wow.c Normální soubor
Zobrazit soubor

@@ -0,0 +1,114 @@
/*
* Copyright (c) 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.
*/
/**
* DOC: target_if_pmo_wow.c
*
* Target interface file for pmo component to
* send wow related cmd and process event.
*/
#include "target_if.h"
#include "target_if_pmo.h"
#include "wmi_unified_api.h"
QDF_STATUS target_if_pmo_enable_wow_wakeup_event(struct wlan_objmgr_vdev *vdev,
uint32_t *bitmap)
{
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_add_wow_wakeup_event_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), vdev_id, bitmap, true);
if (status)
target_if_err("Failed to config wow wakeup event");
return status;
}
QDF_STATUS target_if_pmo_disable_wow_wakeup_event(struct wlan_objmgr_vdev *vdev,
uint32_t *bitmap)
{
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_add_wow_wakeup_event_cmd(
GET_WMI_HDL_FROM_PSOC(psoc), vdev_id, bitmap, false);
if (status)
target_if_err("Failed to config wow wakeup event");
return status;
}
QDF_STATUS target_if_pmo_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
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 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_patterns_to_fw_cmd(
GET_WMI_HDL_FROM_PSOC(psoc),
vdev_id, ptrn_id, ptrn,
ptrn_len, ptrn_offset, mask,
mask_len, user, 0);
return status;
}