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

Move umac/p2p to components/p2p

Browse Source 
Change-Id: I8ca4c55470674422eca2dc80dd269cf45d4942ea
This commit is contained in:
Linux Build Service Account
2018-12-04 15:32:54 +05:30
parent 43520acbbf
commit 11a56702a8
14 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
components/p2p/dispatcher/src/wlan_p2p_cfg.c Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright (c) 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: This file contains p2p configures interface definitions
*/
#include <wlan_objmgr_psoc_obj.h>
#include "wlan_p2p_public_struct.h"
#include "wlan_p2p_cfg_api.h"
#include "../../core/src/wlan_p2p_main.h"
static inline struct p2p_soc_priv_obj *
wlan_psoc_get_p2p_object(struct wlan_objmgr_psoc *psoc)
{
return wlan_objmgr_psoc_get_comp_private_obj(psoc,
WLAN_UMAC_COMP_P2P);
}
QDF_STATUS
cfg_p2p_get_go_keepalive_period(struct wlan_objmgr_psoc *psoc,
uint32_t *period)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_soc_obj = wlan_psoc_get_p2p_object(psoc);
if (!p2p_soc_obj) {
*period = 0;
p2p_err("p2p psoc null");
return QDF_STATUS_E_INVAL;
}
*period = p2p_soc_obj->param.go_keepalive_period;
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
cfg_p2p_get_go_link_monitor_period(struct wlan_objmgr_psoc *psoc,
uint32_t *period)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_soc_obj = wlan_psoc_get_p2p_object(psoc);
if (!p2p_soc_obj) {
*period = 0;
p2p_err("p2p psoc null");
return QDF_STATUS_E_INVAL;
}
*period = p2p_soc_obj->param.go_link_monitor_period;
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
cfg_p2p_get_device_addr_admin(struct wlan_objmgr_psoc *psoc,
bool *enable)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_soc_obj = wlan_psoc_get_p2p_object(psoc);
if (!p2p_soc_obj) {
*enable = false;
p2p_err("p2p psoc null");
return QDF_STATUS_E_INVAL;
}
*enable = p2p_soc_obj->param.p2p_device_addr_admin;
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
cfg_p2p_get_skip_dfs_channel_p2p_search(struct wlan_objmgr_psoc *psoc,
bool *enable)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_soc_obj = wlan_psoc_get_p2p_object(psoc);
if (!p2p_soc_obj) {
*enable = false;
p2p_err("p2p psoc null");
return QDF_STATUS_E_INVAL;
}
*enable = p2p_soc_obj->param.skip_dfs_channel_p2p_search;
return QDF_STATUS_SUCCESS;
}

432
components/p2p/dispatcher/src/wlan_p2p_tgt_api.c Normal file
View File

@@ -0,0 +1,432 @@
/*
* 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: This file contains p2p south bound interface definitions
*/
#include <wlan_objmgr_psoc_obj.h>
#include <wlan_mgmt_txrx_utils_api.h>
#include <scheduler_api.h>
#include <wlan_objmgr_psoc_obj.h>
#include <wlan_objmgr_global_obj.h>
#include <wlan_objmgr_pdev_obj.h>
#include <wlan_objmgr_vdev_obj.h>
#include <wlan_objmgr_peer_obj.h>
#include "wlan_p2p_tgt_api.h"
#include "wlan_p2p_public_struct.h"
#include "../../core/src/wlan_p2p_main.h"
#include "../../core/src/wlan_p2p_roc.h"
#include "../../core/src/wlan_p2p_off_chan_tx.h"
#define IEEE80211_FC0_TYPE_MASK 0x0c
#define P2P_NOISE_FLOOR_DBM_DEFAULT (-96)
static inline struct wlan_lmac_if_p2p_tx_ops *
wlan_psoc_get_p2p_tx_ops(struct wlan_objmgr_psoc *psoc)
{
return &(psoc->soc_cb.tx_ops.p2p);
}
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
QDF_STATUS tgt_p2p_register_lo_ev_handler(
struct wlan_objmgr_psoc *psoc)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_ops = wlan_psoc_get_p2p_tx_ops(psoc);
if (p2p_ops && p2p_ops->reg_lo_ev_handler) {
status = p2p_ops->reg_lo_ev_handler(psoc, NULL);
p2p_debug("register lo event, status:%d", status);
}
return status;
}
QDF_STATUS tgt_p2p_unregister_lo_ev_handler(
struct wlan_objmgr_psoc *psoc)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_ops = wlan_psoc_get_p2p_tx_ops(psoc);
if (p2p_ops && p2p_ops->unreg_lo_ev_handler) {
status = p2p_ops->unreg_lo_ev_handler(psoc, NULL);
p2p_debug("unregister lo event, status:%d", status);
}
return status;
}
QDF_STATUS tgt_p2p_lo_event_cb(struct wlan_objmgr_psoc *psoc,
struct p2p_lo_event *event_info)
{
struct p2p_lo_stop_event *lo_stop_event;
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
QDF_STATUS status;
p2p_debug("soc:%pK, event_info:%pK", psoc, event_info);
if (!psoc) {
p2p_err("psoc context passed is NULL");
if (event_info)
qdf_mem_free(event_info);
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p soc object is NULL");
if (event_info)
qdf_mem_free(event_info);
return QDF_STATUS_E_INVAL;
}
if (!event_info) {
p2p_err("invalid lo stop event information");
return QDF_STATUS_E_INVAL;
}
lo_stop_event = qdf_mem_malloc(sizeof(*lo_stop_event));
if (!lo_stop_event) {
p2p_err("Failed to allocate p2p lo stop event");
qdf_mem_free(event_info);
return QDF_STATUS_E_NOMEM;
}
lo_stop_event->p2p_soc_obj = p2p_soc_obj;
lo_stop_event->lo_event = event_info;
msg.type = P2P_EVENT_LO_STOPPED;
msg.bodyptr = lo_stop_event;
msg.callback = p2p_process_evt;
msg.flush_callback = p2p_event_flush_callback;
status = scheduler_post_message(QDF_MODULE_ID_P2P,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_TARGET_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(lo_stop_event->lo_event);
qdf_mem_free(lo_stop_event);
p2p_err("post msg fail:%d", status);
}
return status;
}
#endif /* FEATURE_P2P_LISTEN_OFFLOAD */
QDF_STATUS
tgt_p2p_add_mac_addr_status_event_cb(struct wlan_objmgr_psoc *psoc,
struct p2p_set_mac_filter_evt *event_info)
{
struct p2p_mac_filter_rsp *mac_filter_rsp;
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
QDF_STATUS status;
if (!psoc) {
p2p_err("random_mac:psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
if (!event_info) {
p2p_err("random_mac:invalid event_info");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(
psoc, WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("random_mac:p2p soc object is NULL");
return QDF_STATUS_E_INVAL;
}
mac_filter_rsp = qdf_mem_malloc(sizeof(*mac_filter_rsp));
if (!mac_filter_rsp) {
p2p_err("random_mac:Failed to allocate mac_filter_rsp");
return QDF_STATUS_E_NOMEM;
}
mac_filter_rsp->p2p_soc_obj = p2p_soc_obj;
mac_filter_rsp->vdev_id = event_info->vdev_id;
mac_filter_rsp->status = event_info->status;
msg.type = P2P_EVENT_ADD_MAC_RSP;
msg.bodyptr = mac_filter_rsp;
msg.callback = p2p_process_evt;
status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
if (QDF_IS_STATUS_ERROR(status))
qdf_mem_free(mac_filter_rsp);
return status;
}
QDF_STATUS tgt_p2p_register_macaddr_rx_filter_evt_handler(
struct wlan_objmgr_psoc *psoc, bool reg)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_ops = wlan_psoc_get_p2p_tx_ops(psoc);
if (p2p_ops && p2p_ops->reg_mac_addr_rx_filter_handler) {
status = p2p_ops->reg_mac_addr_rx_filter_handler(psoc, reg);
p2p_debug("register mac addr rx filter event, register %d status:%d",
reg, status);
}
return status;
}
QDF_STATUS tgt_p2p_register_noa_ev_handler(
struct wlan_objmgr_psoc *psoc)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_ops = wlan_psoc_get_p2p_tx_ops(psoc);
if (p2p_ops && p2p_ops->reg_noa_ev_handler) {
status = p2p_ops->reg_noa_ev_handler(psoc, NULL);
p2p_debug("register noa event, status:%d", status);
}
return status;
}
QDF_STATUS tgt_p2p_unregister_noa_ev_handler(
struct wlan_objmgr_psoc *psoc)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_ops = wlan_psoc_get_p2p_tx_ops(psoc);
if (p2p_ops && p2p_ops->unreg_noa_ev_handler) {
status = p2p_ops->unreg_noa_ev_handler(psoc, NULL);
p2p_debug("unregister noa event, status:%d", status);
}
return status;
}
void tgt_p2p_scan_event_cb(struct wlan_objmgr_vdev *vdev,
struct scan_event *event, void *arg)
{
p2p_scan_event_cb(vdev, event, arg);
}
QDF_STATUS tgt_p2p_mgmt_download_comp_cb(void *context,
qdf_nbuf_t buf, bool free)
{
p2p_debug("conext:%pK, buf:%pK, free:%d", context,
qdf_nbuf_data(buf), free);
qdf_nbuf_free(buf);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS tgt_p2p_mgmt_ota_comp_cb(void *context, qdf_nbuf_t buf,
uint32_t status, void *tx_compl_params)
{
struct p2p_tx_conf_event *tx_conf_event;
struct scheduler_msg msg = {0};
QDF_STATUS ret;
p2p_debug("context:%pK, buf:%pK, status:%d, tx complete params:%pK",
context, buf, status, tx_compl_params);
if (!context) {
p2p_err("invalid context");
qdf_nbuf_free(buf);
return QDF_STATUS_E_INVAL;
}
tx_conf_event = qdf_mem_malloc(sizeof(*tx_conf_event));
if (!tx_conf_event) {
p2p_err("Failed to allocate tx cnf event");
qdf_nbuf_free(buf);
return QDF_STATUS_E_NOMEM;
}
tx_conf_event->status = status;
tx_conf_event->nbuf = buf;
tx_conf_event->p2p_soc_obj = (struct p2p_soc_priv_obj *)context;
msg.type = P2P_EVENT_MGMT_TX_ACK_CNF;
msg.bodyptr = tx_conf_event;
msg.callback = p2p_process_evt;
msg.flush_callback = p2p_event_flush_callback;
ret = scheduler_post_message(QDF_MODULE_ID_P2P,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_TARGET_IF,
&msg);
if (QDF_IS_STATUS_ERROR(ret)) {
qdf_mem_free(tx_conf_event);
qdf_nbuf_free(buf);
p2p_err("post msg fail:%d", status);
}
return ret;
}
QDF_STATUS tgt_p2p_mgmt_frame_rx_cb(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_peer *peer, qdf_nbuf_t buf,
struct mgmt_rx_event_params *mgmt_rx_params,
enum mgmt_frame_type frm_type)
{
struct p2p_rx_mgmt_frame *rx_mgmt;
struct p2p_rx_mgmt_event *rx_mgmt_event;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct scheduler_msg msg = {0};
struct wlan_objmgr_vdev *vdev;
uint32_t vdev_id;
uint8_t *pdata;
QDF_STATUS status;
p2p_debug("psoc:%pK, peer:%pK, type:%d", psoc, peer, frm_type);
if (!mgmt_rx_params) {
p2p_err("mgmt rx params is NULL");
qdf_nbuf_free(buf);
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p ctx is NULL, drop this frame");
qdf_nbuf_free(buf);
return QDF_STATUS_E_FAILURE;
}
if (!peer) {
if (p2p_soc_obj->cur_roc_vdev_id == P2P_INVALID_VDEV_ID) {
p2p_err("vdev id of current roc invalid");
qdf_nbuf_free(buf);
return QDF_STATUS_E_FAILURE;
} else {
vdev_id = p2p_soc_obj->cur_roc_vdev_id;
}
} else {
vdev = wlan_peer_get_vdev(peer);
if (!vdev) {
p2p_err("vdev is NULL in peer, drop this frame");
qdf_nbuf_free(buf);
return QDF_STATUS_E_FAILURE;
}
vdev_id = wlan_vdev_get_id(vdev);
}
rx_mgmt_event = qdf_mem_malloc(sizeof(*rx_mgmt_event));
if (!rx_mgmt_event) {
p2p_err("Failed to allocate rx mgmt event");
qdf_nbuf_free(buf);
return QDF_STATUS_E_NOMEM;
}
rx_mgmt = qdf_mem_malloc(sizeof(*rx_mgmt) +
mgmt_rx_params->buf_len);
if (!rx_mgmt) {
p2p_err("Failed to allocate rx mgmt frame");
qdf_nbuf_free(buf);
return QDF_STATUS_E_NOMEM;
}
pdata = (uint8_t *)qdf_nbuf_data(buf);
rx_mgmt->frame_len = mgmt_rx_params->buf_len;
rx_mgmt->rx_chan = mgmt_rx_params->channel;
rx_mgmt->vdev_id = vdev_id;
rx_mgmt->frm_type = frm_type;
rx_mgmt->rx_rssi = mgmt_rx_params->snr +
P2P_NOISE_FLOOR_DBM_DEFAULT;
rx_mgmt_event->rx_mgmt = rx_mgmt;
rx_mgmt_event->p2p_soc_obj = p2p_soc_obj;
qdf_mem_copy(rx_mgmt->buf, pdata, mgmt_rx_params->buf_len);
msg.type = P2P_EVENT_RX_MGMT;
msg.bodyptr = rx_mgmt_event;
msg.callback = p2p_process_evt;
msg.flush_callback = p2p_event_flush_callback;
status = scheduler_post_message(QDF_MODULE_ID_P2P,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_TARGET_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(rx_mgmt_event->rx_mgmt);
qdf_mem_free(rx_mgmt_event);
p2p_err("post msg fail:%d", status);
}
qdf_nbuf_free(buf);
return status;
}
QDF_STATUS tgt_p2p_noa_event_cb(struct wlan_objmgr_psoc *psoc,
struct p2p_noa_info *event_info)
{
struct p2p_noa_event *noa_event;
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
QDF_STATUS status;
p2p_debug("soc:%pK, event_info:%pK", psoc, event_info);
if (!psoc) {
p2p_err("psoc context passed is NULL");
if (event_info)
qdf_mem_free(event_info);
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p soc object is NULL");
if (event_info)
qdf_mem_free(event_info);
return QDF_STATUS_E_INVAL;
}
if (!event_info) {
p2p_err("invalid noa event information");
return QDF_STATUS_E_INVAL;
}
noa_event = qdf_mem_malloc(sizeof(*noa_event));
if (!noa_event) {
p2p_err("Failed to allocate p2p noa event");
qdf_mem_free(event_info);
return QDF_STATUS_E_NOMEM;
}
noa_event->p2p_soc_obj = p2p_soc_obj;
noa_event->noa_info = event_info;
msg.type = P2P_EVENT_NOA;
msg.bodyptr = noa_event;
msg.callback = p2p_process_evt;
msg.flush_callback = p2p_event_flush_callback;
status = scheduler_post_message(QDF_MODULE_ID_P2P,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_TARGET_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(noa_event->noa_info);
qdf_mem_free(noa_event);
p2p_err("post msg fail:%d", status);
}
return status;
}

652
components/p2p/dispatcher/src/wlan_p2p_ucfg_api.c Normal file
View File

@@ -0,0 +1,652 @@
/*
* 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: This file contains p2p north bound interface definitions
*/
#include <wmi_unified_api.h>
#include <wlan_objmgr_psoc_obj.h>
#include <wlan_objmgr_vdev_obj.h>
#include <scheduler_api.h>
#include "wlan_p2p_public_struct.h"
#include "wlan_p2p_ucfg_api.h"
#include "../../core/src/wlan_p2p_main.h"
#include "../../core/src/wlan_p2p_roc.h"
#include "../../core/src/wlan_p2p_off_chan_tx.h"
static inline struct wlan_lmac_if_p2p_tx_ops *
ucfg_p2p_psoc_get_tx_ops(struct wlan_objmgr_psoc *psoc)
{
return &(psoc->soc_cb.tx_ops.p2p);
}
/**
* is_p2p_ps_allowed() - If P2P power save is allowed or not
* @vdev: vdev object
* @id: umac component id
*
* This function returns TRUE if P2P power-save is allowed
* else returns FALSE.
*
* Return: bool
*/
static bool is_p2p_ps_allowed(struct wlan_objmgr_vdev *vdev,
enum wlan_umac_comp_id id)
{
struct p2p_vdev_priv_obj *p2p_vdev_obj;
uint8_t is_p2pgo = 0;
if (!vdev) {
p2p_err("vdev:%pK", vdev);
return true;
}
p2p_vdev_obj = wlan_objmgr_vdev_get_comp_private_obj(vdev,
WLAN_UMAC_COMP_P2P);
if (wlan_vdev_mlme_get_opmode(vdev) == QDF_P2P_GO_MODE)
is_p2pgo = 1;
if (!p2p_vdev_obj || !is_p2pgo) {
p2p_err("p2p_vdev_obj:%pK is_p2pgo:%u",
p2p_vdev_obj, is_p2pgo);
return false;
}
if (p2p_vdev_obj->non_p2p_peer_count &&
p2p_vdev_obj->noa_status == false) {
p2p_debug("non_p2p_peer_count: %u, noa_status: %d",
p2p_vdev_obj->non_p2p_peer_count,
p2p_vdev_obj->noa_status);
return false;
}
return true;
}
QDF_STATUS ucfg_p2p_init(void)
{
return p2p_component_init();
}
QDF_STATUS ucfg_p2p_deinit(void)
{
return p2p_component_deinit();
}
QDF_STATUS ucfg_p2p_psoc_open(struct wlan_objmgr_psoc *soc)
{
return p2p_psoc_object_open(soc);
}
QDF_STATUS ucfg_p2p_psoc_close(struct wlan_objmgr_psoc *soc)
{
return p2p_psoc_object_close(soc);
}
QDF_STATUS ucfg_p2p_psoc_start(struct wlan_objmgr_psoc *soc,
struct p2p_start_param *req)
{
return p2p_psoc_start(soc, req);
}
QDF_STATUS ucfg_p2p_psoc_stop(struct wlan_objmgr_psoc *soc)
{
return p2p_psoc_stop(soc);
}
QDF_STATUS ucfg_p2p_roc_req(struct wlan_objmgr_psoc *soc,
struct p2p_roc_req *roc_req, uint64_t *cookie)
{
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_roc_context *roc_ctx;
QDF_STATUS status;
int32_t id;
p2p_debug("soc:%pK, vdev_id:%d, chan:%d, phy_mode:%d, duration:%d",
soc, roc_req->vdev_id, roc_req->chan,
roc_req->phy_mode, roc_req->duration);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(soc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("P2P soc object is NULL");
return QDF_STATUS_E_FAILURE;
}
roc_ctx = qdf_mem_malloc(sizeof(*roc_ctx));
if (!roc_ctx) {
p2p_err("failed to allocate p2p roc context");
return QDF_STATUS_E_NOMEM;
}
status = qdf_idr_alloc(&p2p_soc_obj->p2p_idr, roc_ctx, &id);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(roc_ctx);
p2p_err("failed to alloc idr, status %d", status);
return status;
}
*cookie = (uint64_t)id;
roc_ctx->p2p_soc_obj = p2p_soc_obj;
roc_ctx->vdev_id = roc_req->vdev_id;
roc_ctx->chan = roc_req->chan;
roc_ctx->phy_mode = roc_req->phy_mode;
roc_ctx->duration = roc_req->duration;
roc_ctx->roc_state = ROC_STATE_IDLE;
roc_ctx->roc_type = USER_REQUESTED;
roc_ctx->id = id;
msg.type = P2P_ROC_REQ;
msg.bodyptr = roc_ctx;
msg.callback = p2p_process_cmd;
status = scheduler_post_message(QDF_MODULE_ID_HDD,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_OS_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(roc_ctx);
qdf_idr_remove(&p2p_soc_obj->p2p_idr, id);
p2p_err("post msg fail:%d", status);
}
p2p_debug("cookie = 0x%llx", *cookie);
return status;
}
QDF_STATUS ucfg_p2p_roc_cancel_req(struct wlan_objmgr_psoc *soc,
uint64_t cookie)
{
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
struct cancel_roc_context *cancel_roc;
void *roc_ctx = NULL;
QDF_STATUS status;
p2p_debug("soc:%pK, cookie:0x%llx", soc, cookie);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(soc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p soc context is NULL");
return QDF_STATUS_E_FAILURE;
}
status = qdf_idr_find(&p2p_soc_obj->p2p_idr,
cookie, &roc_ctx);
if (QDF_IS_STATUS_ERROR(status)) {
p2p_err("invalid id");
return QDF_STATUS_E_INVAL;
}
cancel_roc = qdf_mem_malloc(sizeof(*cancel_roc));
if (!cancel_roc) {
p2p_err("failed to allocate cancel p2p roc");
return QDF_STATUS_E_NOMEM;
}
cancel_roc->p2p_soc_obj = p2p_soc_obj;
cancel_roc->cookie = (uintptr_t)roc_ctx;
msg.type = P2P_CANCEL_ROC_REQ;
msg.bodyptr = cancel_roc;
msg.callback = p2p_process_cmd;
status = scheduler_post_message(QDF_MODULE_ID_HDD,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_OS_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(cancel_roc);
p2p_err("post msg fail:%d", status);
}
return status;
}
QDF_STATUS ucfg_p2p_cleanup_roc_by_vdev(struct wlan_objmgr_vdev *vdev)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
struct wlan_objmgr_psoc *psoc;
p2p_debug("vdev:%pK", vdev);
if (!vdev) {
p2p_err("null vdev");
return QDF_STATUS_E_INVAL;
}
psoc = wlan_vdev_get_psoc(vdev);
if (!psoc) {
p2p_err("null psoc");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p soc context is NULL");
return QDF_STATUS_E_FAILURE;
}
return p2p_cleanup_roc_sync(p2p_soc_obj, vdev);
}
QDF_STATUS ucfg_p2p_cleanup_roc_by_psoc(struct wlan_objmgr_psoc *psoc)
{
struct p2p_soc_priv_obj *obj;
if (!psoc) {
p2p_err("null psoc");
return QDF_STATUS_E_INVAL;
}
obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, WLAN_UMAC_COMP_P2P);
if (!obj) {
p2p_err("null p2p soc obj");
return QDF_STATUS_E_FAILURE;
}
return p2p_cleanup_roc_sync(obj, NULL);
}
QDF_STATUS ucfg_p2p_cleanup_tx_by_vdev(struct wlan_objmgr_vdev *vdev)
{
struct p2p_soc_priv_obj *obj;
struct wlan_objmgr_psoc *psoc;
if (!vdev) {
p2p_err("null vdev");
return QDF_STATUS_E_INVAL;
}
psoc = wlan_vdev_get_psoc(vdev);
if (!psoc) {
p2p_err("null psoc");
return QDF_STATUS_E_INVAL;
}
obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, WLAN_UMAC_COMP_P2P);
if (!obj) {
p2p_err("null p2p soc obj");
return QDF_STATUS_E_FAILURE;
}
p2p_del_all_rand_mac_vdev(vdev);
return p2p_cleanup_tx_sync(obj, vdev);
}
QDF_STATUS ucfg_p2p_cleanup_tx_by_psoc(struct wlan_objmgr_psoc *psoc)
{
struct p2p_soc_priv_obj *obj;
if (!psoc) {
p2p_err("null psoc");
return QDF_STATUS_E_INVAL;
}
obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, WLAN_UMAC_COMP_P2P);
if (!obj) {
p2p_err("null p2p soc obj");
return QDF_STATUS_E_FAILURE;
}
p2p_del_all_rand_mac_soc(psoc);
return p2p_cleanup_tx_sync(obj, NULL);
}
QDF_STATUS ucfg_p2p_mgmt_tx(struct wlan_objmgr_psoc *soc,
struct p2p_mgmt_tx *mgmt_frm, uint64_t *cookie)
{
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
struct tx_action_context *tx_action;
QDF_STATUS status;
int32_t id;
p2p_debug("soc:%pK, vdev_id:%d, chan:%d, wait:%d, buf_len:%d, cck:%d, no ack:%d, off chan:%d",
soc, mgmt_frm->vdev_id, mgmt_frm->chan,
mgmt_frm->wait, mgmt_frm->len, mgmt_frm->no_cck,
mgmt_frm->dont_wait_for_ack, mgmt_frm->off_chan);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(soc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("P2P soc context is NULL");
return QDF_STATUS_E_FAILURE;
}
tx_action = qdf_mem_malloc(sizeof(*tx_action));
if (!tx_action) {
p2p_err("Failed to allocate tx action context");
return QDF_STATUS_E_NOMEM;
}
/* return cookie just for ota ack frames */
if (mgmt_frm->dont_wait_for_ack)
id = 0;
else {
status = qdf_idr_alloc(&p2p_soc_obj->p2p_idr,
tx_action, &id);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(tx_action);
p2p_err("failed to alloc idr, status :%d", status);
return status;
}
}
*cookie = (uint64_t)id;
tx_action->p2p_soc_obj = p2p_soc_obj;
tx_action->vdev_id = mgmt_frm->vdev_id;
tx_action->chan = mgmt_frm->chan;
tx_action->duration = mgmt_frm->wait;
tx_action->buf_len = mgmt_frm->len;
tx_action->no_cck = mgmt_frm->no_cck;
tx_action->no_ack = mgmt_frm->dont_wait_for_ack;
tx_action->off_chan = mgmt_frm->off_chan;
tx_action->buf = qdf_mem_malloc(tx_action->buf_len);
if (!(tx_action->buf)) {
p2p_err("Failed to allocate buffer for action frame");
qdf_mem_free(tx_action);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(tx_action->buf, mgmt_frm->buf, tx_action->buf_len);
tx_action->nbuf = NULL;
tx_action->id = id;
p2p_rand_mac_tx(tx_action);
msg.type = P2P_MGMT_TX;
msg.bodyptr = tx_action;
msg.callback = p2p_process_cmd;
msg.flush_callback = p2p_msg_flush_callback;
status = scheduler_post_message(QDF_MODULE_ID_HDD,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_OS_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
if (id)
qdf_idr_remove(&p2p_soc_obj->p2p_idr, id);
qdf_mem_free(tx_action->buf);
qdf_mem_free(tx_action);
p2p_err("post msg fail:%d", status);
}
return status;
}
QDF_STATUS ucfg_p2p_mgmt_tx_cancel(struct wlan_objmgr_psoc *soc,
struct wlan_objmgr_vdev *vdev, uint64_t cookie)
{
struct scheduler_msg msg = {0};
struct p2p_soc_priv_obj *p2p_soc_obj;
struct cancel_roc_context *cancel_tx;
void *tx_ctx;
QDF_STATUS status;
p2p_debug("soc:%pK, cookie:0x%llx", soc, cookie);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(soc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p soc context is NULL");
return QDF_STATUS_E_FAILURE;
}
status = qdf_idr_find(&p2p_soc_obj->p2p_idr,
(int32_t)cookie, &tx_ctx);
if (QDF_IS_STATUS_ERROR(status)) {
p2p_debug("invalid id");
return QDF_STATUS_E_INVAL;
}
p2p_del_random_mac(soc, wlan_vdev_get_id(vdev), cookie, 20);
cancel_tx = qdf_mem_malloc(sizeof(*cancel_tx));
if (!cancel_tx) {
p2p_err("Failed to allocate cancel p2p roc");
return QDF_STATUS_E_NOMEM;
}
cancel_tx->p2p_soc_obj = p2p_soc_obj;
cancel_tx->cookie = (uintptr_t)tx_ctx;
msg.type = P2P_MGMT_TX_CANCEL;
msg.bodyptr = cancel_tx;
msg.callback = p2p_process_cmd;
status = scheduler_post_message(QDF_MODULE_ID_HDD,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_OS_IF,
&msg);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(cancel_tx);
p2p_err("post msg fail: %d", status);
}
return status;
}
bool ucfg_p2p_check_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
uint8_t *random_mac_addr)
{
return p2p_check_random_mac(soc, vdev_id, random_mac_addr);
}
QDF_STATUS ucfg_p2p_set_ps(struct wlan_objmgr_psoc *soc,
struct p2p_ps_config *ps_config)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
uint16_t obj_id;
struct wlan_objmgr_vdev *vdev;
struct p2p_ps_config go_ps_config;
p2p_debug("soc:%pK, vdev_id:%d, opp_ps:%d, ct_window:%d, count:%d, duration:%d, duration:%d, ps_selection:%d",
soc, ps_config->vdev_id, ps_config->opp_ps,
ps_config->ct_window, ps_config->count,
ps_config->duration, ps_config->single_noa_duration,
ps_config->ps_selection);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
for (obj_id = 0; obj_id < WLAN_UMAC_PSOC_MAX_VDEVS; obj_id++) {
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(soc, obj_id,
WLAN_P2P_ID);
if (vdev) {
if (is_p2p_ps_allowed(vdev, WLAN_UMAC_COMP_P2P)) {
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
break;
}
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
p2p_debug("skip p2p set ps vdev %d, NoA is disabled as legacy STA is connected to GO.",
obj_id);
}
}
if (obj_id >= WLAN_UMAC_PSOC_MAX_VDEVS) {
p2p_debug("No GO found!");
return QDF_STATUS_E_INVAL;
}
go_ps_config = *ps_config;
go_ps_config.vdev_id = obj_id;
p2p_ops = ucfg_p2p_psoc_get_tx_ops(soc);
if (p2p_ops->set_ps) {
status = p2p_ops->set_ps(soc, &go_ps_config);
p2p_debug("p2p set ps vdev %d, status:%d", obj_id, status);
}
return status;
}
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
QDF_STATUS ucfg_p2p_lo_start(struct wlan_objmgr_psoc *soc,
struct p2p_lo_start *p2p_lo_start)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_debug("soc:%pK, vdev_id:%d, ctl_flags:%d, freq:%d, period:%d, interval:%d, count:%d, dev_types_len:%d, probe_resp_len:%d, device_types:%pK, probe_resp_tmplt:%pK",
soc, p2p_lo_start->vdev_id, p2p_lo_start->ctl_flags,
p2p_lo_start->freq, p2p_lo_start->period,
p2p_lo_start->interval, p2p_lo_start->count,
p2p_lo_start->dev_types_len, p2p_lo_start->probe_resp_len,
p2p_lo_start->device_types, p2p_lo_start->probe_resp_tmplt);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_ops = ucfg_p2p_psoc_get_tx_ops(soc);
if (p2p_ops->lo_start) {
status = p2p_ops->lo_start(soc, p2p_lo_start);
p2p_debug("p2p lo start, status:%d", status);
}
return status;
}
QDF_STATUS ucfg_p2p_lo_stop(struct wlan_objmgr_psoc *soc,
uint32_t vdev_id)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_debug("soc:%pK, vdev_id:%d", soc, vdev_id);
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_ops = ucfg_p2p_psoc_get_tx_ops(soc);
if (p2p_ops->lo_stop) {
status = p2p_ops->lo_stop(soc, vdev_id);
p2p_debug("p2p lo stop, status:%d", status);
}
return status;
}
#endif
QDF_STATUS ucfg_p2p_set_noa(struct wlan_objmgr_psoc *soc,
uint32_t vdev_id, bool disable_noa)
{
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_INVAL;
p2p_ops = ucfg_p2p_psoc_get_tx_ops(soc);
if (p2p_ops->set_noa) {
status = p2p_ops->set_noa(soc, vdev_id, disable_noa);
p2p_debug("p2p set noa, status:%d", status);
}
return status;
}
QDF_STATUS ucfg_p2p_register_callbacks(struct wlan_objmgr_psoc *soc,
struct p2p_protocol_callbacks *cb_obj)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
if (!soc || !cb_obj) {
p2p_err("psoc %pM cb_obj %pM context passed is NULL", soc,
cb_obj);
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = wlan_objmgr_psoc_get_comp_private_obj(soc,
WLAN_UMAC_COMP_P2P);
if (!p2p_soc_obj) {
p2p_err("p2p soc private object is NULL");
return QDF_STATUS_E_FAILURE;
}
p2p_soc_obj->p2p_cb = *cb_obj;
return QDF_STATUS_SUCCESS;
}
QDF_STATUS ucfg_p2p_status_scan(struct wlan_objmgr_vdev *vdev)
{
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
return p2p_status_scan(vdev);
}
QDF_STATUS ucfg_p2p_status_connect(struct wlan_objmgr_vdev *vdev)
{
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
return p2p_status_connect(vdev);
}
QDF_STATUS ucfg_p2p_status_disconnect(struct wlan_objmgr_vdev *vdev)
{
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
return p2p_status_disconnect(vdev);
}
QDF_STATUS ucfg_p2p_status_start_bss(struct wlan_objmgr_vdev *vdev)
{
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
return p2p_status_start_bss(vdev);
}
QDF_STATUS ucfg_p2p_status_stop_bss(struct wlan_objmgr_vdev *vdev)
{
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
return p2p_status_stop_bss(vdev);
}