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

Move target_if/p2p to components/target_if/p2p

Browse Source 
Change-Id: I1ea8a2cc9f31223407fac0925b74e3c5a37bc6e5
This commit is contained in:
Linux Build Service Account
2018-12-04 15:34:44 +05:30
commit 0acb61069b
2 changed files with 614 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
target_if/p2p/inc/target_if_p2p.h Normal file
View File

@@ -0,0 +1,140 @@
/*
* Copyright (c) 2017-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: offload lmac interface APIs for P2P
*/
#ifndef _TARGET_IF_P2P_H_
#define _TARGET_IF_P2P_H_
#include <qdf_types.h>
struct wlan_objmgr_psoc;
struct p2p_ps_config;
struct p2p_lo_start;
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
/**
* target_if_p2p_register_lo_event_handler() - Register lo event handler
* @psoc: soc object
* @arg: additional argument
*
* Target interface API to register P2P listen offload event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_register_lo_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg);
/**
* target_if_p2p_unregister_lo_event_handler() - Unregister lo event handler
* @psoc: soc object
* @arg: additional argument
*
* Target interface API to unregister P2P listen offload event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_unregister_lo_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg);
/**
* target_if_p2p_lo_start() - Start listen offload
* @psoc: soc object
* @lo_start: lo start information
*
* Target interface API to start listen offload.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_lo_start(struct wlan_objmgr_psoc *psoc,
struct p2p_lo_start *lo_start);
/**
* target_if_p2p_lo_stop() - Stop listen offload
* @psoc: soc object
* @vdev_id: vdev id
*
* Target interface API to stop listen offload.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_lo_stop(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id);
#endif
/**
* target_if_p2p_register_tx_ops() - Register P2P component TX OPS
* @tx_ops: lmac if transmit ops
*
* Return: None
*/
void target_if_p2p_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops);
/**
* target_if_p2p_register_noa_event_handler() - Register noa event handler
* @psoc: soc object
* @arg: additional argument
*
* Target interface API to register P2P noa event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_register_noa_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg);
/**
* target_if_p2p_unregister_noa_event_handler() - Unregister noa event handler
* @psoc: soc object
* @arg: additional argument
*
* Target interface API to unregister P2P listen offload event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_unregister_noa_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg);
/**
* target_if_p2p_set_ps() - Set power save
* @psoc: soc object
* @arg: additional argument
*
* Target interface API to set power save.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_set_ps(struct wlan_objmgr_psoc *psoc,
struct p2p_ps_config *ps_config);
/**
* target_if_p2p_set_noa() - Disable / Enable NOA
* @psoc: soc object
* @vdev_id: vdev id
* @disable_noa: TRUE - Disable NoA, FALSE - Enable NoA
*
* Target interface API to Disable / Enable P2P NOA.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS target_if_p2p_set_noa(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, bool disable_noa);
#endif /* _TARGET_IF_P2P_H_ */

474
target_if/p2p/src/target_if_p2p.c Normal file
View File

@@ -0,0 +1,474 @@
/*
* Copyright (c) 2017-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: offload lmac interface APIs definitions for P2P
*/
#include <wmi_unified_api.h>
#include <wlan_p2p_public_struct.h>
#include "target_if.h"
#include "target_if_p2p.h"
#include "init_deinit_lmac.h"
static inline struct wlan_lmac_if_p2p_rx_ops *
target_if_psoc_get_p2p_rx_ops(struct wlan_objmgr_psoc *psoc)
{
return &(psoc->soc_cb.rx_ops.p2p);
}
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
static inline void
target_if_p2p_lo_register_tx_ops(struct wlan_lmac_if_p2p_tx_ops *p2p_tx_ops)
{
p2p_tx_ops->lo_start = target_if_p2p_lo_start;
p2p_tx_ops->lo_stop = target_if_p2p_lo_stop;
p2p_tx_ops->reg_lo_ev_handler =
target_if_p2p_register_lo_event_handler;
p2p_tx_ops->unreg_lo_ev_handler =
target_if_p2p_unregister_lo_event_handler;
}
/**
* target_p2p_lo_event_handler() - WMI callback for lo stop event
* @scn: pointer to scn
* @event_buf: event buffer
* @len: buffer length
*
* This function gets called from WMI when triggered wmi event
* wmi_p2p_lo_stop_event_id.
*
* Return: 0 - success
* others - failure
*/
static int target_p2p_lo_event_handler(ol_scn_t scn, uint8_t *data,
uint32_t datalen)
{
struct wlan_objmgr_psoc *psoc;
struct wmi_unified *wmi_handle;
struct p2p_lo_event *event_info;
struct wlan_lmac_if_p2p_rx_ops *p2p_rx_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
target_if_debug("scn:%pK, data:%pK, datalen:%d", scn, data, datalen);
if (!scn || !data) {
target_if_err("scn: 0x%pK, data: 0x%pK", scn, data);
return -EINVAL;
}
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
target_if_err("null psoc");
return -EINVAL;
}
wmi_handle = get_wmi_unified_hdl_from_psoc(psoc);
if (!wmi_handle) {
target_if_err("null wmi handle");
return -EINVAL;
}
event_info = qdf_mem_malloc(sizeof(*event_info));
if (!event_info) {
target_if_err("Failed to allocate p2p lo event");
return -ENOMEM;
}
if (wmi_extract_p2p_lo_stop_ev_param(wmi_handle, data,
event_info)) {
target_if_err("Failed to extract wmi p2p lo stop event");
qdf_mem_free(event_info);
return -EINVAL;
}
p2p_rx_ops = target_if_psoc_get_p2p_rx_ops(psoc);
if (p2p_rx_ops->lo_ev_handler) {
status = p2p_rx_ops->lo_ev_handler(psoc, event_info);
target_if_debug("call lo event handler, status:%d",
status);
} else {
qdf_mem_free(event_info);
target_if_debug("no valid lo event handler");
}
return qdf_status_to_os_return(status);
}
QDF_STATUS target_if_p2p_register_lo_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg)
{
int status;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
target_if_debug("psoc:%pK, arg:%pK", psoc, arg);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
status = wmi_unified_register_event(wmi_handle,
wmi_p2p_lo_stop_event_id,
target_p2p_lo_event_handler);
target_if_debug("wmi register lo event handle, status:%d", status);
return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
}
QDF_STATUS target_if_p2p_unregister_lo_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg)
{
int status;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
target_if_debug("psoc:%pK, arg:%pK", psoc, arg);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
status = wmi_unified_unregister_event(wmi_handle,
wmi_p2p_lo_stop_event_id);
target_if_debug("wmi unregister lo event handle, status:%d", status);
return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
}
QDF_STATUS target_if_p2p_lo_start(struct wlan_objmgr_psoc *psoc,
struct p2p_lo_start *lo_start)
{
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
if (!lo_start) {
target_if_err("lo start parameters is null");
return QDF_STATUS_E_INVAL;
}
target_if_debug("psoc:%pK, vdev_id:%d", psoc, lo_start->vdev_id);
return wmi_unified_p2p_lo_start_cmd(wmi_handle, lo_start);
}
QDF_STATUS target_if_p2p_lo_stop(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id)
{
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
target_if_debug("psoc:%pK, vdev_id:%d", psoc, vdev_id);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
return wmi_unified_p2p_lo_stop_cmd(wmi_handle,
(uint8_t)vdev_id);
}
#else
static inline void
target_if_p2p_lo_register_tx_ops(struct wlan_lmac_if_p2p_tx_ops *p2p_tx_ops)
{
}
#endif /* FEATURE_P2P_LISTEN_OFFLOAD */
/**
* target_p2p_noa_event_handler() - WMI callback for noa event
* @scn: pointer to scn
* @event_buf: event buffer
* @len: buffer length
*
* This function gets called from WMI when triggered WMI event
* wmi_p2p_noa_event_id.
*
* Return: 0 - success
* others - failure
*/
static int target_p2p_noa_event_handler(ol_scn_t scn, uint8_t *data,
uint32_t datalen)
{
struct wlan_objmgr_psoc *psoc;
struct wmi_unified *wmi_handle;
struct p2p_noa_info *event_info;
struct wlan_lmac_if_p2p_rx_ops *p2p_rx_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
target_if_debug("scn:%pK, data:%pK, datalen:%d", scn, data, datalen);
if (!scn || !data) {
target_if_err("scn: 0x%pK, data: 0x%pK", scn, data);
return -EINVAL;
}
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
target_if_err("null psoc");
return -EINVAL;
}
wmi_handle = get_wmi_unified_hdl_from_psoc(psoc);
if (!wmi_handle) {
target_if_err("null wmi handle");
return -EINVAL;
}
event_info = qdf_mem_malloc(sizeof(*event_info));
if (!event_info) {
target_if_err("failed to allocate p2p noa information");
return -ENOMEM;
}
if (wmi_extract_p2p_noa_ev_param(wmi_handle, data,
event_info)) {
target_if_err("failed to extract wmi p2p noa event");
qdf_mem_free(event_info);
return -EINVAL;
}
p2p_rx_ops = target_if_psoc_get_p2p_rx_ops(psoc);
if (p2p_rx_ops->noa_ev_handler) {
status = p2p_rx_ops->noa_ev_handler(psoc, event_info);
target_if_debug("call noa event handler, status:%d",
status);
} else {
qdf_mem_free(event_info);
target_if_debug("no valid noa event handler");
}
return qdf_status_to_os_return(status);
}
QDF_STATUS target_if_p2p_register_noa_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg)
{
int status;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
target_if_debug("psoc:%pK, arg:%pK", psoc, arg);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
status = wmi_unified_register_event(wmi_handle,
wmi_p2p_noa_event_id,
target_p2p_noa_event_handler);
target_if_debug("wmi register noa event handle, status:%d",
status);
return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
}
QDF_STATUS target_if_p2p_unregister_noa_event_handler(
struct wlan_objmgr_psoc *psoc, void *arg)
{
int status;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
target_if_debug("psoc:%pK, arg:%pK", psoc, arg);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
status = wmi_unified_unregister_event(wmi_handle,
wmi_p2p_noa_event_id);
target_if_debug("wmi unregister noa event handle, status:%d",
status);
return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
}
QDF_STATUS target_if_p2p_set_ps(struct wlan_objmgr_psoc *psoc,
struct p2p_ps_config *ps_config)
{
struct p2p_ps_params cmd;
QDF_STATUS status;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
if (!ps_config) {
target_if_err("ps config parameters is null");
return QDF_STATUS_E_INVAL;
}
target_if_debug("psoc:%pK, vdev_id:%d, opp_ps:%d", psoc,
ps_config->vdev_id, ps_config->opp_ps);
cmd.opp_ps = ps_config->opp_ps;
cmd.ctwindow = ps_config->ct_window;
cmd.count = ps_config->count;
cmd.duration = ps_config->duration;
cmd.interval = ps_config->interval;
cmd.single_noa_duration = ps_config->single_noa_duration;
cmd.ps_selection = ps_config->ps_selection;
cmd.session_id = ps_config->vdev_id;
if (ps_config->opp_ps)
status = wmi_unified_set_p2pgo_oppps_req(wmi_handle,
&cmd);
else
status = wmi_unified_set_p2pgo_noa_req_cmd(wmi_handle,
&cmd);
if (status != QDF_STATUS_SUCCESS)
target_if_err("Failed to send set uapsd param, %d",
status);
return status;
}
QDF_STATUS target_if_p2p_set_noa(struct wlan_objmgr_psoc *psoc,
uint32_t vdev_id, bool disable_noa)
{
struct vdev_set_params param;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
target_if_debug("psoc:%pK, vdev_id:%d disable_noa:%d",
psoc, vdev_id, disable_noa);
param.if_id = vdev_id;
param.param_id = WMI_VDEV_PARAM_DISABLE_NOA_P2P_GO;
param.param_value = (uint32_t)disable_noa;
return wmi_unified_vdev_set_param_send(wmi_handle, &param);
}
static int target_p2p_mac_rx_filter_event_handler(ol_scn_t scn, uint8_t *data,
uint32_t datalen)
{
struct wlan_objmgr_psoc *psoc;
struct wmi_unified *wmi_handle;
struct p2p_set_mac_filter_evt event_info;
struct wlan_lmac_if_p2p_rx_ops *p2p_rx_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
if (!scn || !data) {
target_if_err("scn: 0x%pK, data: 0x%pK", scn, data);
return -EINVAL;
}
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
target_if_err("null psoc");
return -EINVAL;
}
wmi_handle = get_wmi_unified_hdl_from_psoc(psoc);
if (!wmi_handle) {
target_if_err("null wmi handle");
return -EINVAL;
}
if (wmi_extract_mac_addr_rx_filter_evt_param(wmi_handle, data,
&event_info)) {
target_if_err("failed to extract wmi p2p noa event");
return -EINVAL;
}
target_if_debug("vdev_id %d status %d", event_info.vdev_id,
event_info.status);
p2p_rx_ops = target_if_psoc_get_p2p_rx_ops(psoc);
if (p2p_rx_ops && p2p_rx_ops->add_mac_addr_filter_evt_handler)
status = p2p_rx_ops->add_mac_addr_filter_evt_handler(
psoc, &event_info);
else
target_if_debug("no add mac addr filter event handler");
return qdf_status_to_os_return(status);
}
static QDF_STATUS target_if_p2p_register_macaddr_rx_filter_evt_handler(
struct wlan_objmgr_psoc *psoc, bool reg)
{
int status;
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
target_if_debug("psoc:%pK, register %d mac addr rx evt", psoc, reg);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
if (reg)
status = wmi_unified_register_event(
wmi_handle,
wmi_vdev_add_macaddr_rx_filter_event_id,
target_p2p_mac_rx_filter_event_handler);
else
status = wmi_unified_unregister_event(
wmi_handle,
wmi_vdev_add_macaddr_rx_filter_event_id);
return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
}
static QDF_STATUS target_if_p2p_set_mac_addr_rx_filter_cmd(
struct wlan_objmgr_psoc *psoc, struct p2p_set_mac_filter *param)
{
wmi_unified_t wmi_handle = lmac_get_wmi_unified_hdl(psoc);
if (!wmi_handle) {
target_if_err("Invalid wmi handle");
return QDF_STATUS_E_INVAL;
}
return wmi_send_set_mac_addr_rx_filter_cmd(wmi_handle, param);
}
void target_if_p2p_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_tx_ops;
if (!tx_ops) {
target_if_err("lmac tx_ops is null");
return;
}
p2p_tx_ops = &tx_ops->p2p;
p2p_tx_ops->set_ps = target_if_p2p_set_ps;
p2p_tx_ops->set_noa = target_if_p2p_set_noa;
p2p_tx_ops->reg_noa_ev_handler =
target_if_p2p_register_noa_event_handler;
p2p_tx_ops->unreg_noa_ev_handler =
target_if_p2p_unregister_noa_event_handler;
p2p_tx_ops->reg_mac_addr_rx_filter_handler =
target_if_p2p_register_macaddr_rx_filter_evt_handler;
p2p_tx_ops->set_mac_addr_rx_filter_cmd =
target_if_p2p_set_mac_addr_rx_filter_cmd;
/* register P2P listen offload callbacks */
target_if_p2p_lo_register_tx_ops(p2p_tx_ops);
}