A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-10 14:19:09 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacmn: remain on channel

Browse source 
Handles roc request, cancel roc reuqest and scan event in P2P
component.

Change-Id: I47085ddc3551e76ef042e9d72dc4b29de6c2b118
CRs-Fixed: 2006262
This commit is contained in:
Wu Gao 2017-03-15 17:27:59 +08:00 • committed by Sandeep Puligilla
commit 26781f65dc
5 changed files with 845 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

20
umac/p2p/core/src/wlan_p2p_main.c
View file

@ -26,6 +26,7 @@
#include <wlan_objmgr_pdev_obj.h>
#include <wlan_objmgr_vdev_obj.h>
#include <wlan_objmgr_peer_obj.h>
#include <wlan_scan_ucfg_api.h>
#include "wlan_p2p_public_struct.h"
#include "wlan_p2p_ucfg_api.h"
#include "wlan_p2p_tgt_api.h"
@ -542,7 +543,13 @@ QDF_STATUS p2p_psoc_start(struct wlan_objmgr_psoc *soc,
tgt_p2p_register_lo_ev_handler(soc);
tgt_p2p_register_noa_ev_handler(soc);
p2p_debug("p2p psoc start successful");
/* register scan request id */
p2p_soc_obj->scan_req_id = ucfg_scan_register_requester(
soc, P2P_MODULE_NAME, tgt_p2p_scan_event_cb,
p2p_soc_obj);
p2p_debug("p2p psoc start successful, scan request id:%d",
p2p_soc_obj->scan_req_id);
return QDF_STATUS_SUCCESS;
}
@ -571,6 +578,12 @@ QDF_STATUS p2p_psoc_stop(struct wlan_objmgr_psoc *soc)
return QDF_STATUS_E_FAILURE;
}
/* clean up queue of p2p psoc private object */
p2p_cleanup_roc_queue(p2p_soc_obj);
/* unrgister scan request id*/
ucfg_scan_unregister_requester(soc, p2p_soc_obj->scan_req_id);
/* unregister p2p lo stop and noa event */
tgt_p2p_unregister_lo_ev_handler(soc);
tgt_p2p_unregister_noa_ev_handler(soc);
@ -609,6 +622,7 @@ QDF_STATUS p2p_process_cmd(struct scheduler_msg *msg)
status = p2p_process_cancel_roc_req(
(struct cancel_roc_context *)
msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case P2P_MGMT_TX:
status = p2p_process_mgmt_tx(
@ -619,6 +633,7 @@ QDF_STATUS p2p_process_cmd(struct scheduler_msg *msg)
status = p2p_process_mgmt_tx_cancel(
(struct cancel_roc_context *)
msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
default:
p2p_err("drop unexpected message received %d",
@ -627,9 +642,6 @@ QDF_STATUS p2p_process_cmd(struct scheduler_msg *msg)
break;
}
qdf_mem_free(msg->bodyptr);
msg->bodyptr = NULL;
return status;
}

714
umac/p2p/core/src/wlan_p2p_roc.c
View file

@ -20,20 +20,730 @@
* DOC: This file contains RoC API definitions
*/
#include <wlan_mgmt_txrx_utils_api.h>
#include <wlan_scan_public_structs.h>
#include <wlan_scan_ucfg_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_policy_mgr_api.h>
#include <wlan_utility.h>
#include "wlan_p2p_public_struct.h"
#include "wlan_p2p_tgt_api.h"
#include "wlan_p2p_ucfg_api.h"
#include "wlan_p2p_roc.h"
#include "wlan_p2p_main.h"
#include "wlan_p2p_off_chan_tx.h"
/**
* p2p_mgmt_rx_ops() - register or unregister rx callback
* @psoc: psoc object
* @isregister: register if true, unregister if false
*
* This function registers or unregisters rx callback to mgmt txrx
* component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_mgmt_rx_ops(struct wlan_objmgr_psoc *psoc,
bool isregister)
{
struct mgmt_txrx_mgmt_frame_cb_info frm_cb_info;
QDF_STATUS status;
p2p_debug("psoc:%p, is register rx:%d", psoc, isregister);
frm_cb_info.frm_type = MGMT_PROBE_REQ;
frm_cb_info.mgmt_rx_cb = (mgmt_frame_rx_callback)
tgt_p2p_mgmt_frame_rx_cb;
if (isregister)
status = wlan_mgmt_txrx_register_rx_cb(psoc,
WLAN_UMAC_COMP_P2P, &frm_cb_info, 1);
else
status = wlan_mgmt_txrx_deregister_rx_cb(psoc,
WLAN_UMAC_COMP_P2P, &frm_cb_info, 1);
return status;
}
/**
* p2p_scan_start() - Start scan
* @roc_ctx: remain on channel request
*
* This function trigger a start scan request to scan component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_scan_start(struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status;
struct scan_start_request *req;
struct wlan_objmgr_vdev *vdev;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(
p2p_soc_obj->soc, roc_ctx->vdev_id,
WLAN_P2P_ID);
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
p2p_err("failed to alloc scan start request");
status = QDF_STATUS_E_NOMEM;
goto fail;
}
ucfg_scan_init_default_params(vdev, req);
roc_ctx->scan_id = ucfg_scan_get_scan_id(p2p_soc_obj->soc);
req->vdev = vdev;
req->scan_req.scan_id = roc_ctx->scan_id;
req->scan_req.scan_req_id = p2p_soc_obj->scan_req_id;
req->scan_req.num_chan = 1;
req->scan_req.chan_list[0] = wlan_chan_to_freq(roc_ctx->chan);
req->scan_req.dwell_time_passive = roc_ctx->duration;
req->scan_req.dwell_time_active = 0;
qdf_set_macaddr_broadcast(&req->scan_req.bssid_list[0]);
status = ucfg_scan_start(req);
p2p_debug("start scan, scan req id:%d, scan id:%d, status:%d",
p2p_soc_obj->scan_req_id, roc_ctx->scan_id, status);
fail:
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
return status;
}
/**
* p2p_scan_abort() - Abort scan
* @roc_ctx: remain on channel request
*
* This function trigger an abort scan request to scan component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_scan_abort(struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status;
struct scan_cancel_request *req;
struct wlan_objmgr_vdev *vdev;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
p2p_debug("abort scan, scan req id:%d, scan id:%d",
p2p_soc_obj->scan_req_id, roc_ctx->scan_id);
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(
p2p_soc_obj->soc, roc_ctx->vdev_id,
WLAN_P2P_ID);
if (!vdev) {
p2p_err("vdev is NULL");
return QDF_STATUS_E_INVAL;
}
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
p2p_err("failed to alloc scan cancel request");
status = QDF_STATUS_E_NOMEM;
goto fail;
}
req->vdev = vdev;
req->cancel_req.requester = p2p_soc_obj->scan_req_id;
req->cancel_req.scan_id = roc_ctx->scan_id;
req->cancel_req.vdev_id = roc_ctx->vdev_id;
req->cancel_req.req_type = WLAN_SCAN_CANCEL_SINGLE;
status = ucfg_scan_cancel(req);
p2p_debug("abort scan, scan req id:%d, scan id:%d, status:%d",
p2p_soc_obj->scan_req_id, roc_ctx->scan_id, status);
fail:
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
return status;
}
/**
* p2p_execute_cancel_roc_req() - Execute cancel roc request
* @roc_ctx: remain on channel request
*
* This function stop roc timer, abort scan and unregister mgmt rx
* callbak.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_execute_cancel_roc_req(
struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
roc_ctx->roc_state = ROC_STATE_CANCEL_IN_PROG;
qdf_event_reset(&p2p_soc_obj->cancel_roc_done);
status = qdf_mc_timer_stop(&roc_ctx->roc_timer);
if (status != QDF_STATUS_SUCCESS)
p2p_err("Failed to stop roc timer, roc %p", roc_ctx);
status = p2p_scan_abort(roc_ctx);
if (status != QDF_STATUS_SUCCESS) {
p2p_err("Failed to abort scan, status:%d", status);
}
return QDF_STATUS_SUCCESS;
}
/**
* p2p_roc_timeout() - Callback for roc timeout
* @pdata: pointer to p2p soc private object
*
* This function is callback for roc time out.
*
* Return: None
*/
static void p2p_roc_timeout(void *pdata)
{
struct p2p_roc_context *roc_ctx;
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_debug("p2p soc obj:%p", pdata);
p2p_soc_obj = pdata;
if (!p2p_soc_obj) {
p2p_err("Invalid p2p soc object");
return;
}
roc_ctx = p2p_find_current_roc_ctx(p2p_soc_obj);
if (!roc_ctx) {
p2p_debug("No P2P roc is pending");
return;
}
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
roc_ctx->p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
if (roc_ctx->roc_state == ROC_STATE_CANCEL_IN_PROG) {
p2p_err("Cancellation already in progress");
return;
}
p2p_execute_cancel_roc_req(roc_ctx);
}
/**
* p2p_execute_roc_req() - Execute roc request
* @roc_ctx: remain on channel request
*
* This function init roc timer, start scan and register mgmt rx
* callbak.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_execute_roc_req(struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status;
uint32_t go_num;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
status = qdf_mc_timer_init(&roc_ctx->roc_timer,
QDF_TIMER_TYPE_SW, p2p_roc_timeout,
p2p_soc_obj);
if (status != QDF_STATUS_SUCCESS)
return status;
roc_ctx->roc_state = ROC_STATE_REQUESTED;
go_num = policy_mgr_mode_specific_connection_count(
p2p_soc_obj->soc, PM_P2P_GO_MODE, NULL);
p2p_debug("present go number:%d", go_num);
if (go_num)
roc_ctx->duration *= P2P_ROC_DURATION_MULTI_GO_PRESENT;
else
roc_ctx->duration *= P2P_ROC_DURATION_MULTI_GO_ABSENT;
status = p2p_scan_start(roc_ctx);
if (status != QDF_STATUS_SUCCESS) {
p2p_err("Failed to start scan, status:%d", status);
}
status = p2p_mgmt_rx_ops(roc_ctx->p2p_soc_obj->soc, true);
if (status != QDF_STATUS_SUCCESS)
p2p_err("Failed to register mgmt rx callback, status:%d",
status);
return status;
}
/**
* p2p_find_roc_ctx() - Find out roc context by cookie
* @p2p_soc_obj: p2p psoc private object
* @cookie: cookie is the key to find out roc context
*
* This function find out roc context by cookie from p2p psoc private
* object
*
* Return: Pointer to roc context - success
* NULL - failure
*/
static struct p2p_roc_context *p2p_find_roc_ctx(
struct p2p_soc_priv_obj *p2p_soc_obj, uint64_t cookie)
{
struct p2p_roc_context *curr_roc_ctx;
qdf_list_node_t *tmp, *pos;
p2p_debug("p2p soc obj:%p, cookie:%llx", p2p_soc_obj, cookie);
list_for_each_safe(pos, tmp, &p2p_soc_obj->roc_q.anchor) {
curr_roc_ctx = list_entry(pos, struct p2p_roc_context,
node);
if ((uintptr_t) curr_roc_ctx == cookie)
return curr_roc_ctx;
}
return NULL;
}
/**
* p2p_send_roc_event() - Send roc event
* @roc_ctx: remain on channel request
* @evt: roc event information
*
* This function send out roc event to up layer.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_send_roc_event(
struct p2p_roc_context *roc_ctx, enum p2p_roc_event evt)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_event p2p_evt;
struct p2p_start_param *start_param;
p2p_soc_obj = roc_ctx->p2p_soc_obj;
if (!p2p_soc_obj || !(p2p_soc_obj->start_param)) {
p2p_err("Invalid p2p soc object or start parameters");
return QDF_STATUS_E_INVAL;
}
start_param = p2p_soc_obj->start_param;
if (!(start_param->event_cb)) {
p2p_err("Invalid p2p event callback to up layer");
return QDF_STATUS_E_INVAL;
}
p2p_evt.vdev_id = roc_ctx->vdev_id;
p2p_evt.roc_event = evt;
p2p_evt.cookie = (uintptr_t)roc_ctx;
p2p_evt.chan = roc_ctx->chan;
p2p_evt.duration = roc_ctx->duration;
p2p_debug("p2p soc_obj:%p, roc_ctx:%p, vdev_id:%d, roc_event:"
"%d, cookie:%llx, chan:%d, duration:%d", p2p_soc_obj,
roc_ctx, p2p_evt.vdev_id, p2p_evt.roc_event,
p2p_evt.cookie, p2p_evt.chan, p2p_evt.duration);
start_param->event_cb(start_param->event_cb_data, &p2p_evt);
return QDF_STATUS_SUCCESS;
}
/**
* p2p_process_scan_start_evt() - Process scan start event
* @roc_ctx: remain on channel request
*
* This function process scan start event.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_process_scan_start_evt(
struct p2p_roc_context *roc_ctx)
{
roc_ctx->roc_state = ROC_STATE_STARTED;
p2p_debug("scan started, roc ctx:%p, scan id:%d",
roc_ctx, roc_ctx->scan_id);
return QDF_STATUS_SUCCESS;
}
/**
* p2p_process_ready_on_channel_evt() - Process ready on channel event
* @roc_ctx: remain on channel request
*
* This function process ready on channel event. Starts roc timer.
* Indicates this event to up layer if this is user request roc. Sends
* mgmt frame if this is off channel rx roc.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_process_ready_on_channel_evt(
struct p2p_roc_context *roc_ctx)
{
uint64_t cookie;
struct p2p_soc_priv_obj *p2p_soc_obj;
QDF_STATUS status;
p2p_soc_obj = roc_ctx->p2p_soc_obj;
roc_ctx->roc_state = ROC_STATE_ON_CHAN;
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
status = qdf_mc_timer_start(&roc_ctx->roc_timer,
(roc_ctx->duration + P2P_EVENT_PROPOGATE_TIME));
if (status != QDF_STATUS_SUCCESS)
p2p_err("Remain on Channel timer start failed");
if (roc_ctx->roc_type == USER_REQUESTED) {
p2p_debug("user required roc, send roc event");
status = p2p_send_roc_event(roc_ctx,
ROC_EVENT_READY_ON_CHAN);
} else {
p2p_debug("roc for off chan tx, ready to send frame");
cookie = (uintptr_t)roc_ctx;
/* ready to tx frame */
}
return status;
}
/**
* p2p_process_scan_complete_evt() - Process scan complete event
* @roc_ctx: remain on channel request
*
* This function process scan complete event.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_process_scan_complete_evt(
struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status;
qdf_list_node_t *next_node;
uint32_t size;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
status = qdf_mc_timer_stop(&roc_ctx->roc_timer);
if (status != QDF_STATUS_SUCCESS)
p2p_err("Failed to stop roc timer");
status = qdf_mc_timer_destroy(&roc_ctx->roc_timer);
if (status != QDF_STATUS_SUCCESS)
p2p_err("Failed to destroy roc timer");
status = p2p_mgmt_rx_ops(p2p_soc_obj->soc, false);
if (status != QDF_STATUS_SUCCESS)
p2p_err("Failed to deregister mgmt rx callback");
if (roc_ctx->roc_type == USER_REQUESTED)
status = p2p_send_roc_event(roc_ctx,
ROC_EVENT_COMPLETED);
status = qdf_list_remove_node(&p2p_soc_obj->roc_q,
(qdf_list_node_t *)roc_ctx);
if (QDF_STATUS_SUCCESS != status)
p2p_err("Failed to remove roc req, status %d", status);
qdf_mem_free(roc_ctx);
qdf_event_set(&p2p_soc_obj->cancel_roc_done);
size = qdf_list_size(&p2p_soc_obj->roc_q);
p2p_debug("P2P roc queue size is %d", status);
if (size > 0) {
status = qdf_list_peek_front(&p2p_soc_obj->roc_q,
&next_node);
if (QDF_STATUS_SUCCESS != status) {
p2p_err("Failed to peek roc req from front, status %d",
status);
return status;
}
roc_ctx = qdf_container_of(next_node,
struct p2p_roc_context, node);
status = p2p_execute_roc_req(roc_ctx);
}
return status;
}
/**
* p2p_process_scan_dequeue() - Process scan dequeue
* @roc_ctx: remain on channel request
*
* This function process scan dequeued event.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_process_scan_dequeue(
struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
if (roc_ctx->roc_state != ROC_STATE_CANCEL_IN_PROG) {
p2p_debug("invalid roc state, %d", roc_ctx->roc_state);
return QDF_STATUS_E_INVAL;
}
if (QDF_TIMER_STATE_RUNNING !=
qdf_mc_timer_get_current_state(&roc_ctx->roc_timer)) {
qdf_mc_timer_stop(&roc_ctx->roc_timer);
}
status = qdf_mc_timer_destroy(&roc_ctx->roc_timer);
if (status != QDF_STATUS_SUCCESS)
p2p_err("failed to destroy roc timer, roc ctx:%p, status:%d",
roc_ctx, status);
status = qdf_list_remove_node(&p2p_soc_obj->roc_q,
(qdf_list_node_t *)roc_ctx);
if (status != QDF_STATUS_SUCCESS)
p2p_err("failed to remove roc context, roc ctx:%p, status:%d",
roc_ctx, status);
qdf_mem_free(roc_ctx);
return status;
}
struct p2p_roc_context *p2p_find_current_roc_ctx(
struct p2p_soc_priv_obj *p2p_soc_obj)
{
struct p2p_roc_context *roc_ctx;
qdf_list_node_t *tmp, *pos;
list_for_each_safe(pos, tmp, &p2p_soc_obj->roc_q.anchor) {
roc_ctx = list_entry(pos, struct p2p_roc_context,
node);
if (roc_ctx->roc_state != ROC_STATE_IDLE) {
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id"
":%d, scan_id:%d, cookie:%llx, chan:"
"%d, phy_mode:%d, duration:%d, "
"roc_type:%d, roc_state:%d",
roc_ctx->p2p_soc_obj, roc_ctx,
roc_ctx->vdev_id, roc_ctx->scan_id,
roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
return roc_ctx;
}
}
return NULL;
}
QDF_STATUS p2p_restart_roc_timer(struct p2p_roc_context *roc_ctx)
{
QDF_STATUS status = QDF_STATUS_E_FAILURE;
if (QDF_TIMER_STATE_RUNNING ==
qdf_mc_timer_get_current_state(&roc_ctx->roc_timer)) {
p2p_debug("roc timer is running");
status = qdf_mc_timer_stop(&roc_ctx->roc_timer);
if (status != QDF_STATUS_SUCCESS) {
p2p_err("Failed to stop roc timer");
return status;
}
status = qdf_mc_timer_start(&roc_ctx->roc_timer,
roc_ctx->duration);
if (status != QDF_STATUS_SUCCESS)
p2p_err("Remain on Channel timer start failed");
}
return status;
}
QDF_STATUS p2p_cleanup_roc_queue(struct p2p_soc_priv_obj *p2p_soc_obj)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct p2p_roc_context *roc_ctx;
qdf_list_node_t *tmp, *pos;
unsigned long rc = 0;
p2p_debug("clean up idle roc request, roc queue size:%d",
qdf_list_size(&p2p_soc_obj->roc_q));
list_for_each_safe(pos, tmp, &p2p_soc_obj->roc_q.anchor) {
roc_ctx = list_entry(pos, struct p2p_roc_context,
node);
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
roc_ctx->p2p_soc_obj, roc_ctx,
roc_ctx->vdev_id, roc_ctx->scan_id,
roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
if (roc_ctx->roc_state == ROC_STATE_IDLE) {
status = qdf_list_remove_node(
&p2p_soc_obj->roc_q,
(qdf_list_node_t *)roc_ctx);
if (status == QDF_STATUS_SUCCESS)
qdf_mem_free(roc_ctx);
else
p2p_err("Failed to remove roc ctx from queue");
}
}
p2p_debug("clean up started roc request, roc queue size:%d",
qdf_list_size(&p2p_soc_obj->roc_q));
list_for_each_safe(pos, tmp, &p2p_soc_obj->roc_q.anchor) {
roc_ctx = list_entry(pos, struct p2p_roc_context,
node);
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
roc_ctx->p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
if (roc_ctx->roc_state != ROC_STATE_IDLE) {
if (roc_ctx->roc_state !=
ROC_STATE_CANCEL_IN_PROG)
p2p_execute_cancel_roc_req(roc_ctx);
rc = qdf_wait_single_event(
&p2p_soc_obj->cancel_roc_done,
msecs_to_jiffies(P2P_WAIT_CANCEL_ROC));
if (!rc)
p2p_err("Timeout occurred while waiting for RoC cancellation");
}
}
if (status != QDF_STATUS_SUCCESS || rc) {
p2p_err("failed to cleanup roc queue, status:%d, rc:%ld",
status, rc);
status = QDF_STATUS_E_FAILURE;
}
return status;
}
QDF_STATUS p2p_process_roc_req(struct p2p_roc_context *roc_ctx)
{
return QDF_STATUS_SUCCESS;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_roc_context *curr_roc_ctx;
QDF_STATUS status;
uint32_t size;
p2p_soc_obj = roc_ctx->p2p_soc_obj;
p2p_debug("p2p soc obj:%p, roc ctx:%p, vdev_id:%d, scan_id:%d, cookie:%llx, chan:%d, phy_mode:%d, duration:%d, roc_type:%d, roc_state:%d",
p2p_soc_obj, roc_ctx, roc_ctx->vdev_id,
roc_ctx->scan_id, roc_ctx->cookie, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
status = qdf_list_insert_back(&p2p_soc_obj->roc_q,
&roc_ctx->node);
if (QDF_STATUS_SUCCESS != status) {
qdf_mem_free(roc_ctx);
p2p_err("Failed to insert roc req, status %d", status);
return status;
}
size = qdf_list_size(&p2p_soc_obj->roc_q);
if (size == 1) {
status = p2p_execute_roc_req(roc_ctx);
} else if (size > 1) {
curr_roc_ctx = p2p_find_current_roc_ctx(p2p_soc_obj);
/*TODO, to handle extend roc */
}
return status;
}
QDF_STATUS p2p_process_cancel_roc_req(
struct cancel_roc_context *cancel_roc_ctx)
{
return QDF_STATUS_SUCCESS;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_roc_context *curr_roc_ctx;
QDF_STATUS status;
p2p_soc_obj = cancel_roc_ctx->p2p_soc_obj;
curr_roc_ctx = p2p_find_roc_ctx(p2p_soc_obj,
cancel_roc_ctx->cookie);
p2p_debug("p2p soc obj:%p, cookie:%llx, roc ctx:%p",
p2p_soc_obj, cancel_roc_ctx->cookie, curr_roc_ctx);
if (!curr_roc_ctx) {
p2p_err("Failed to find roc req by cookie, cookie %llx",
cancel_roc_ctx->cookie);
return QDF_STATUS_E_INVAL;
}
if (curr_roc_ctx->roc_state == ROC_STATE_IDLE) {
status = qdf_list_remove_node(&p2p_soc_obj->roc_q,
(qdf_list_node_t *)curr_roc_ctx);
if (status == QDF_STATUS_SUCCESS)
qdf_mem_free(curr_roc_ctx);
else
p2p_err("Failed to remove roc req, status %d", status);
} else if (curr_roc_ctx->roc_state ==
ROC_STATE_CANCEL_IN_PROG) {
p2p_debug("Receive cancel roc req when roc req is canceling, cookie %llx",
cancel_roc_ctx->cookie);
status = QDF_STATUS_SUCCESS;
} else {
status = p2p_execute_cancel_roc_req(curr_roc_ctx);
}
return status;
}
void p2p_scan_event_cb(struct wlan_objmgr_vdev *vdev,
struct scan_event *event, void *arg)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_roc_context *curr_roc_ctx;
p2p_debug("soc:%p, scan event:%d", arg, event->type);
p2p_soc_obj = (struct p2p_soc_priv_obj *)arg;
if (!p2p_soc_obj) {
p2p_err("Invalid P2P context");
return;
}
curr_roc_ctx = p2p_find_current_roc_ctx(p2p_soc_obj);
if (!curr_roc_ctx) {
p2p_err("Failed to find valid P2P roc context");
return;
}
switch (event->type) {
case SCAN_EVENT_TYPE_STARTED:
p2p_process_scan_start_evt(curr_roc_ctx);
break;
case SCAN_EVENT_TYPE_FOREIGN_CHANNEL:
p2p_process_ready_on_channel_evt(curr_roc_ctx);
break;
case SCAN_EVENT_TYPE_COMPLETED:
p2p_process_scan_complete_evt(curr_roc_ctx);
break;
case SCAN_EVENT_TYPE_DEQUEUED:
p2p_process_scan_dequeue(curr_roc_ctx);
break;
default:
p2p_err("invalid scan event, %d", event->type);
}
}

44
umac/p2p/core/src/wlan_p2p_roc.h
View file

@ -27,6 +27,15 @@
#include <qdf_mc_timer.h>
#define P2P_EVENT_PROPOGATE_TIME 10
#define P2P_WAIT_CANCEL_ROC 1000
#ifdef QCA_WIFI_3_0_EMU
#define P2P_ROC_DURATION_MULTI_GO_PRESENT 2
#define P2P_ROC_DURATION_MULTI_GO_ABSENT 3
#else
#define P2P_ROC_DURATION_MULTI_GO_PRESENT 2
#define P2P_ROC_DURATION_MULTI_GO_ABSENT 5
#endif
struct wlan_objmgr_vdev;
struct scan_event;
@ -97,6 +106,41 @@ struct cancel_roc_context {
uint64_t cookie;
};
/**
* p2p_find_current_roc_ctx() - Find out roc context in progressing
* @p2p_soc_obj: p2p psoc private object
*
* This function find out roc context in progressing from p2p psoc
* private object
*
* Return: Pointer to roc context - success
* NULL - failure
*/
struct p2p_roc_context *p2p_find_current_roc_ctx(
struct p2p_soc_priv_obj *p2p_soc_obj);
/**
* p2p_restart_roc_timer() - Restarts roc timer
* @roc_ctx: remain on channel context
*
* This function restarts roc timer with updated duration.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_restart_roc_timer(struct p2p_roc_context *roc_ctx);
/**
* p2p_cleanup_roc_queue() - Cleanup roc context in queue
* @p2p_soc_obj: p2p psoc private object
*
* This function cleanup roc context in queue, include the roc
* context in progressing.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_cleanup_roc_queue(
struct p2p_soc_priv_obj *p2p_soc_obj);
/**
* p2p_process_roc_req() - Process roc request
* @roc_ctx: roc request context

2
umac/p2p/dispatcher/src/wlan_p2p_tgt_api.c
View file

@ -26,6 +26,7 @@
#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"
static inline struct wlan_lmac_if_p2p_tx_ops *
wlan_psoc_get_p2p_tx_ops(struct wlan_objmgr_psoc *psoc)
@ -96,6 +97,7 @@ QDF_STATUS tgt_p2p_unregister_noa_ev_handler(
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,

71
umac/p2p/dispatcher/src/wlan_p2p_ucfg_api.c
View file

@ -26,6 +26,7 @@
#include "wlan_p2p_ucfg_api.h"
#include "wlan_p2p_public_struct.h"
#include "../../core/src/wlan_p2p_main.h"
#include "../../core/src/wlan_p2p_roc.h"
static inline struct wlan_lmac_if_p2p_tx_ops *
ucfg_p2p_psoc_get_tx_ops(struct wlan_objmgr_psoc *psoc)
@ -67,12 +68,82 @@ QDF_STATUS ucfg_p2p_psoc_stop(struct wlan_objmgr_psoc *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;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_roc_context *roc_ctx;
p2p_debug("soc:%p, 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;
}
*cookie = (uintptr_t)roc_ctx;
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;
msg.type = P2P_ROC_REQ;
msg.bodyptr = roc_ctx;
msg.callback = p2p_process_cmd;
scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS ucfg_p2p_roc_cancel_req(struct wlan_objmgr_psoc *soc,
uint64_t cookie)
{
struct scheduler_msg msg;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct cancel_roc_context *cancel_roc;
p2p_debug("soc:%p, 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;
}
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 = cookie;
msg.type = P2P_CANCEL_ROC_REQ;
msg.bodyptr = cancel_roc;
msg.callback = p2p_process_cmd;
scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg);
return QDF_STATUS_SUCCESS;
}