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-09 13:49:24 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacmn: Private commands and wmi events for P2P

Browse source 
Deliver private commands for P2P component. Registers and unregisters
wmi events by target interface. Handles wmi events from target
interface.

Change-Id: Ic25f1c22ae1650f2b059b3fb428daa1b2e66b93c
CRs-Fixed: 2015115
This commit is contained in:
Wu Gao 2017-03-06 14:00:02 +08:00 • committed by Sandeep Puligilla
commit 930869e013
5 changed files with 504 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -100,13 +100,13 @@ static QDF_STATUS p2p_psoc_obj_create_notification(
struct p2p_soc_priv_obj *p2p_soc_obj;
QDF_STATUS status;
if (soc == NULL) {
if (!soc) {
p2p_err("psoc context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_soc_obj = qdf_mem_malloc(sizeof(*p2p_soc_obj));
if (p2p_soc_obj == NULL) {
if (!p2p_soc_obj) {
p2p_err("Failed to allocate p2p soc private object");
return QDF_STATUS_E_NOMEM;
}
@ -122,7 +122,7 @@ static QDF_STATUS p2p_psoc_obj_create_notification(
return status;
}
p2p_info("p2p soc object create successful, %p", p2p_soc_obj);
p2p_debug("p2p soc object create successful, %p", p2p_soc_obj);
return QDF_STATUS_SUCCESS;
}
@ -143,14 +143,14 @@ static QDF_STATUS p2p_psoc_obj_destroy_notification(
struct p2p_soc_priv_obj *p2p_soc_obj;
QDF_STATUS status;
if (soc == NULL) {
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 == NULL) {
if (!p2p_soc_obj) {
p2p_err("p2p soc private object is NULL");
return QDF_STATUS_E_FAILURE;
}
@ -164,7 +164,7 @@ static QDF_STATUS p2p_psoc_obj_destroy_notification(
return status;
}
p2p_info("destroy p2p soc object, %p", p2p_soc_obj);
p2p_debug("destroy p2p soc object, %p", p2p_soc_obj);
qdf_mem_free(p2p_soc_obj);
@ -186,14 +186,25 @@ static QDF_STATUS p2p_vdev_obj_create_notification(
{
struct p2p_vdev_priv_obj *p2p_vdev_obj;
QDF_STATUS status;
enum tQDF_ADAPTER_MODE mode;
if (vdev == NULL) {
if (!vdev) {
p2p_err("vdev context passed is NULL");
return QDF_STATUS_E_INVAL;
}
p2p_vdev_obj = qdf_mem_malloc(sizeof(*p2p_vdev_obj));
if (p2p_vdev_obj == NULL) {
wlan_vdev_obj_lock(vdev);
mode = wlan_vdev_mlme_get_opmode(vdev);
wlan_vdev_obj_unlock(vdev);
p2p_debug("vdev mode:%d", mode);
if (mode != QDF_P2P_GO_MODE) {
p2p_debug("won't create p2p vdev private object if it is not GO");
return QDF_STATUS_SUCCESS;
}
p2p_vdev_obj =
qdf_mem_malloc(sizeof(*p2p_vdev_obj));
if (!p2p_vdev_obj) {
p2p_err("Failed to allocate p2p vdev object");
return QDF_STATUS_E_NOMEM;
}
@ -210,7 +221,7 @@ static QDF_STATUS p2p_vdev_obj_create_notification(
return status;
}
p2p_info("p2p vdev object create successful, %p", p2p_vdev_obj);
p2p_debug("p2p vdev object create successful, %p", p2p_vdev_obj);
return QDF_STATUS_SUCCESS;
}
@ -230,17 +241,27 @@ static QDF_STATUS p2p_vdev_obj_destroy_notification(
{
struct p2p_vdev_priv_obj *p2p_vdev_obj;
QDF_STATUS status;
enum tQDF_ADAPTER_MODE mode;
if (vdev == NULL) {
if (!vdev) {
p2p_err("vdev context passed is NULL");
return QDF_STATUS_E_INVAL;
}
wlan_vdev_obj_lock(vdev);
mode = wlan_vdev_mlme_get_opmode(vdev);
wlan_vdev_obj_unlock(vdev);
p2p_debug("vdev mode:%d", mode);
if (mode != QDF_P2P_GO_MODE) {
p2p_debug("no p2p vdev private object if it is not GO");
return QDF_STATUS_SUCCESS;
}
p2p_vdev_obj = wlan_objmgr_vdev_get_comp_private_obj(vdev,
WLAN_UMAC_COMP_P2P);
if (p2p_vdev_obj == NULL) {
p2p_err("p2p vdev object is NULL");
return QDF_STATUS_E_FAILURE;
if (!p2p_vdev_obj) {
p2p_debug("p2p vdev object is NULL");
return QDF_STATUS_SUCCESS;
}
p2p_vdev_obj->vdev = NULL;
@ -252,7 +273,7 @@ static QDF_STATUS p2p_vdev_obj_destroy_notification(
return status;
}
p2p_info("destroy p2p vdev object, p2p vdev obj:%p, noa info:%p",
p2p_debug("destroy p2p vdev object, p2p vdev obj:%p, noa info:%p",
p2p_vdev_obj, p2p_vdev_obj->noa_info);
if (p2p_vdev_obj->noa_info)
@ -263,6 +284,69 @@ static QDF_STATUS p2p_vdev_obj_destroy_notification(
return QDF_STATUS_SUCCESS;
}
/**
* p2p_send_noa_to_pe() - send noa information to pe
* @noa_info: vdev context
*
* This function sends noa information to pe since MCL layer need noa
* event.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_send_noa_to_pe(struct p2p_noa_info *noa_info)
{
struct p2p_noa_attr *noa_attr;
struct scheduler_msg msg;
if (!noa_info) {
p2p_err("noa info is null");
return QDF_STATUS_E_INVAL;
}
noa_attr = qdf_mem_malloc(sizeof(*noa_attr));
if (!noa_attr) {
p2p_err("Failed to allocate memory for tSirP2PNoaAttr");
return QDF_STATUS_E_NOMEM;
}
noa_attr->index = noa_info->index;
noa_attr->opps_ps = noa_info->opps_ps;
noa_attr->ct_win = noa_info->ct_window;
if (!noa_info->num_desc) {
p2p_debug("Zero noa descriptors");
} else {
p2p_debug("%d noa descriptors", noa_info->num_desc);
noa_attr->noa1_count =
noa_info->noa_desc[0].type_count;
noa_attr->noa1_duration =
noa_info->noa_desc[0].duration;
noa_attr->noa1_interval =
noa_info->noa_desc[0].interval;
noa_attr->noa1_start_time =
noa_info->noa_desc[0].start_time;
if (noa_info->num_desc > 1) {
noa_attr->noa2_count =
noa_info->noa_desc[1].type_count;
noa_attr->noa2_duration =
noa_info->noa_desc[1].duration;
noa_attr->noa2_interval =
noa_info->noa_desc[1].interval;
noa_attr->noa2_start_time =
noa_info->noa_desc[1].start_time;
}
}
p2p_debug("Sending P2P_NOA_ATTR_IND to pe");
msg.type = P2P_NOA_ATTR_IND;
msg.bodyval = 0;
msg.bodyptr = noa_attr;
scheduler_post_msg(QDF_MODULE_ID_PE, &msg);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS p2p_component_init(void)
{
QDF_STATUS status;
@ -373,14 +457,14 @@ QDF_STATUS p2p_psoc_object_open(struct wlan_objmgr_psoc *soc)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
if (soc == NULL) {
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 == NULL) {
if (!p2p_soc_obj) {
p2p_err("p2p soc priviate object is NULL");
return QDF_STATUS_E_FAILURE;
}
@ -389,7 +473,6 @@ QDF_STATUS p2p_psoc_object_open(struct wlan_objmgr_psoc *soc)
qdf_list_create(&p2p_soc_obj->tx_q_roc, MAX_QUEUE_LENGTH);
qdf_list_create(&p2p_soc_obj->tx_q_ack, MAX_QUEUE_LENGTH);
qdf_event_create(&p2p_soc_obj->cancel_roc_done);
/*TODO, register scan event, wmi lo and noa event */
p2p_debug("p2p psoc object open successful");
@ -400,22 +483,22 @@ QDF_STATUS p2p_psoc_object_close(struct wlan_objmgr_psoc *soc)
{
struct p2p_soc_priv_obj *p2p_soc_obj;
if (soc == NULL) {
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 == NULL) {
if (!p2p_soc_obj) {
p2p_err("p2p soc object is NULL");
return QDF_STATUS_E_FAILURE;
}
qdf_list_destroy(&p2p_soc_obj->roc_q);
qdf_list_destroy(&p2p_soc_obj->tx_q_roc);
qdf_event_destroy(&p2p_soc_obj->cancel_roc_done);
qdf_list_destroy(&p2p_soc_obj->tx_q_ack);
/*TODO, ucfg_scan_clear_requestor_id(soc, p2p_soc_obj->scan_req_id);*/
qdf_list_destroy(&p2p_soc_obj->tx_q_roc);
qdf_list_destroy(&p2p_soc_obj->roc_q);
p2p_debug("p2p psoc object close successful");
@ -428,20 +511,20 @@ QDF_STATUS p2p_psoc_start(struct wlan_objmgr_psoc *soc,
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_start_param *start_param;
if (soc == NULL) {
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 == NULL) {
if (!p2p_soc_obj) {
p2p_err("P2P soc object is NULL");
return QDF_STATUS_E_FAILURE;
}
start_param = qdf_mem_malloc(sizeof(*start_param));
if (start_param == NULL) {
if (!start_param) {
p2p_err("Failed to allocate start params");
return QDF_STATUS_E_NOMEM;
}
@ -455,6 +538,10 @@ QDF_STATUS p2p_psoc_start(struct wlan_objmgr_psoc *soc,
start_param->lo_event_cb_data = req->lo_event_cb_data;
p2p_soc_obj->start_param = start_param;
/* register p2p lo stop and noa event */
tgt_p2p_register_lo_ev_handler(soc);
tgt_p2p_register_noa_ev_handler(soc);
p2p_debug("p2p psoc start successful");
return QDF_STATUS_SUCCESS;
@ -465,25 +552,29 @@ QDF_STATUS p2p_psoc_stop(struct wlan_objmgr_psoc *soc)
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_start_param *start_param;
if (soc == NULL) {
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 == NULL) {
if (!p2p_soc_obj) {
p2p_err("P2P soc object is NULL");
return QDF_STATUS_E_FAILURE;
}
start_param = p2p_soc_obj->start_param;
p2p_soc_obj->start_param = NULL;
if (start_param == NULL) {
if (!start_param) {
p2p_err("start parameters is NULL");
return QDF_STATUS_E_FAILURE;
}
/* unregister p2p lo stop and noa event */
tgt_p2p_unregister_lo_ev_handler(soc);
tgt_p2p_unregister_noa_ev_handler(soc);
start_param->rx_cb = NULL;
start_param->rx_cb_data = NULL;
start_param->event_cb = NULL;
@ -501,10 +592,10 @@ QDF_STATUS p2p_process_cmd(struct scheduler_msg *msg)
{
QDF_STATUS status;
p2p_info("msg type %d, %s", msg->type,
p2p_debug("msg type %d, %s", msg->type,
p2p_get_cmd_type_str(msg->type));
if (msg->bodyptr == NULL) {
if (!(msg->bodyptr)) {
p2p_err("Invalid message body");
return QDF_STATUS_E_INVAL;
}
@ -546,10 +637,10 @@ QDF_STATUS p2p_process_evt(struct scheduler_msg *msg)
{
QDF_STATUS status;
p2p_info("msg type %d, %s", msg->type,
p2p_debug("msg type %d, %s", msg->type,
p2p_get_event_type_str(msg->type));
if (msg->bodyptr == NULL) {
if (!(msg->bodyptr)) {
p2p_err("Invalid message body");
return QDF_STATUS_E_INVAL;
}
@ -591,10 +682,96 @@ QDF_STATUS p2p_process_evt(struct scheduler_msg *msg)
QDF_STATUS p2p_process_lo_stop(
struct p2p_lo_stop_event *lo_stop_event)
{
struct p2p_lo_event *lo_evt;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_start_param *start_param;
if (!lo_stop_event) {
p2p_err("invalid lo stop event");
return QDF_STATUS_E_INVAL;
}
lo_evt = lo_stop_event->lo_event;
p2p_soc_obj = lo_stop_event->p2p_soc_obj;
p2p_debug("vdev_id %d, reason %d",
lo_evt->vdev_id, lo_evt->reason_code);
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->lo_event_cb)
start_param->lo_event_cb(
start_param->lo_event_cb_data, lo_evt);
else
p2p_err("Invalid p2p soc obj or hdd lo event callback");
qdf_mem_free(lo_evt);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS p2p_process_noa(struct p2p_noa_event *noa_event)
{
return QDF_STATUS_SUCCESS;
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct p2p_noa_info *noa_info;
struct p2p_vdev_priv_obj *p2p_vdev_obj;
struct p2p_soc_priv_obj *p2p_soc_obj;
struct wlan_objmgr_vdev *vdev;
struct wlan_objmgr_psoc *psoc;
enum tQDF_ADAPTER_MODE mode;
if (!noa_event) {
p2p_err("invalid noa event");
return QDF_STATUS_E_INVAL;
}
noa_info = noa_event->noa_info;
p2p_soc_obj = noa_event->p2p_soc_obj;
psoc = p2p_soc_obj->soc;
p2p_debug("psoc:%p, index:%d, opps_ps:%d, ct_window:%d, num_desc:%d, vdev_id:%d",
psoc, noa_info->index, noa_info->opps_ps,
noa_info->ct_window, noa_info->num_desc,
noa_info->vdev_id);
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
noa_info->vdev_id, WLAN_P2P_ID);
if (!vdev) {
p2p_err("vdev obj is NULL");
qdf_mem_free(noa_event->noa_info);
return QDF_STATUS_E_INVAL;
}
wlan_vdev_obj_lock(vdev);
mode = wlan_vdev_mlme_get_opmode(vdev);
wlan_vdev_obj_unlock(vdev);
p2p_debug("vdev mode:%d", mode);
if (mode != QDF_P2P_GO_MODE) {
p2p_err("invalid p2p vdev mode:%d", mode);
status = QDF_STATUS_E_INVAL;
goto fail;
}
/* must send noa to pe since of limitation*/
p2p_send_noa_to_pe(noa_info);
p2p_vdev_obj = wlan_objmgr_vdev_get_comp_private_obj(vdev,
WLAN_UMAC_COMP_P2P);
if (!(p2p_vdev_obj->noa_info)) {
p2p_vdev_obj->noa_info =
qdf_mem_malloc(sizeof(struct p2p_noa_info));
if (!(p2p_vdev_obj->noa_info)) {
p2p_err("Failed to allocate p2p noa info");
status = QDF_STATUS_E_NOMEM;
goto fail;
}
}
qdf_mem_copy(p2p_vdev_obj->noa_info, noa_info,
sizeof(struct p2p_noa_info));
fail:
qdf_mem_free(noa_event->noa_info);
wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
return status;
}

35
umac/p2p/core/src/wlan_p2p_main.h
View file

@ -28,6 +28,7 @@
#include <qdf_event.h>
#define MAX_QUEUE_LENGTH 20
#define P2P_NOA_ATTR_IND 0x1090
#define P2P_MODULE_NAME "P2P"
#define p2p_log(level, args...) \
@ -154,6 +155,40 @@ struct p2p_vdev_priv_obj {
struct p2p_noa_info *noa_info;
};
/**
* struct p2p_noa_attr - p2p noa attribute
* @rsvd1: reserved bits 1
* @opps_ps: opps ps state of the AP
* @ct_win: ct window in TUs
* @index: identifies instance of NOA su element
* @rsvd2: reserved bits 2
* @noa1_count: interval count of noa1
* @noa1_duration: absent period duration of noa1
* @noa1_interval: absent period interval of noa1
* @noa1_start_time: 32 bit tsf time of noa1
* @rsvd3: reserved bits 3
* @noa2_count: interval count of noa2
* @noa2_duration: absent period duration of noa2
* @noa2_interval: absent period interval of noa2
* @noa2_start_time: 32 bit tsf time of noa2
*/
struct p2p_noa_attr {
uint32_t rsvd1:16;
uint32_t ct_win:7;
uint32_t opps_ps:1;
uint32_t index:8;
uint32_t rsvd2:24;
uint32_t noa1_count:8;
uint32_t noa1_duration;
uint32_t noa1_interval;
uint32_t noa1_start_time;
uint32_t rsvd3:24;
uint32_t noa2_count:8;
uint32_t noa2_duration;
uint32_t noa2_interval;
uint32_t noa2_start_time;
};
/**
* p2p_component_init() - P2P component initialization
*

44
umac/p2p/dispatcher/inc/wlan_p2p_tgt_api.h
View file

@ -33,6 +33,50 @@ struct p2p_lo_event;
struct mgmt_rx_event_params;
enum mgmt_frame_type;
/**
* tgt_p2p_register_lo_ev_handler() - register lo event
* @psoc: soc object
*
* p2p tgt api to register listen offload event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_register_lo_ev_handler(
struct wlan_objmgr_psoc *psoc);
/**
* tgt_p2p_register_noa_ev_handler() - register noa event
* @psoc: soc object
*
* p2p tgt api to register noa event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_register_noa_ev_handler(
struct wlan_objmgr_psoc *psoc);
/**
* tgt_p2p_unregister_lo_ev_handler() - unregister lo event
* @psoc: soc object
*
* p2p tgt api to unregister listen offload event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_unregister_lo_ev_handler(
struct wlan_objmgr_psoc *psoc);
/**
* tgt_p2p_unregister_noa_ev_handler() - unregister noa event
* @psoc: soc object
*
* p2p tgt api to unregister noa event handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_unregister_noa_ev_handler(
struct wlan_objmgr_psoc *psoc);
/**
* tgt_p2p_scan_event_cb() - Callback for scan event
* @vdev: vdev object

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

@ -27,6 +27,72 @@
#include "wlan_p2p_public_struct.h"
#include "../../core/src/wlan_p2p_main.h"
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);
}
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_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_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_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)
{
@ -55,11 +121,93 @@ QDF_STATUS tgt_p2p_mgmt_frame_rx_cb(struct wlan_objmgr_psoc *psoc,
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;
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_debug("soc:%p, event_info:%p", 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;
scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
return QDF_STATUS_SUCCESS;
}
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;
struct p2p_soc_priv_obj *p2p_soc_obj;
p2p_debug("soc:%p, event_info:%p", 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;
scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
return QDF_STATUS_SUCCESS;
}

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

@ -27,6 +27,12 @@
#include "wlan_p2p_public_struct.h"
#include "../../core/src/wlan_p2p_main.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);
}
QDF_STATUS ucfg_p2p_init(void)
{
return p2p_component_init();
@ -85,17 +91,74 @@ QDF_STATUS ucfg_p2p_mgmt_tx_cancel(struct wlan_objmgr_psoc *soc,
QDF_STATUS ucfg_p2p_set_ps(struct wlan_objmgr_psoc *soc,
struct p2p_ps_config *ps_config)
{
return QDF_STATUS_SUCCESS;
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_debug("soc:%p, 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;
}
p2p_ops = ucfg_p2p_psoc_get_tx_ops(soc);
if (p2p_ops->set_ps) {
status = p2p_ops->set_ps(soc, ps_config);
p2p_debug("p2p set ps, status:%d", status);
}
return status;
}
QDF_STATUS ucfg_p2p_lo_start(struct wlan_objmgr_psoc *soc,
struct p2p_lo_start *p2p_lo_start)
{
return QDF_STATUS_SUCCESS;
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_debug("soc:%p, vdev_id:%d, ctl_flags:%d, freq:%d, period:%d, interval:%d, count:%d, dev_types_len:%d, probe_resp_len:%d, device_types:%p, probe_resp_tmplt:%p",
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)
{
return QDF_STATUS_SUCCESS;
struct wlan_lmac_if_p2p_tx_ops *p2p_ops;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
p2p_debug("soc:%p, 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;
}