samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull-Requests Actions Pakete Projekte Releases Wiki Aktivität

Merge branch 'wlan-cmn.driver.lnx.2.0' of ../qca-wifi-host-cmn into HEAD

Quellcode durchsuchen
Dieser Commit ist enthalten in:
Linux Build Service Account
2018-12-04 16:05:56 +05:30
Ursprung cdd24e47d0 9369bcaa55
Commit b51065eae0
14 geänderte Dateien mit 8888 neuen und 0 gelöschten Zeilen
Patch-Datei herunterladen Vergleichs-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

1460
p2p/core/src/wlan_p2p_main.c Normale Datei
Datei anzeigen

Datei-Diff unterdrückt, da er zu groß ist Diff laden

574
p2p/core/src/wlan_p2p_main.h Normale Datei
Datei anzeigen

@@ -0,0 +1,574 @@
/*
* 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: Defines main P2P functions & structures
*/
#ifndef _WLAN_P2P_MAIN_H_
#define _WLAN_P2P_MAIN_H_
#include <qdf_trace.h>
#include <qdf_types.h>
#include <qdf_event.h>
#include <qdf_list.h>
#include <qdf_lock.h>
#include <qdf_idr.h>
#define MAX_QUEUE_LENGTH 20
#define P2P_NOA_ATTR_IND 0x1090
#define P2P_MODULE_NAME "P2P"
#define P2P_INVALID_VDEV_ID 0xFFFFFFFF
#define MAX_RANDOM_MAC_ADDRS 4
#define p2p_debug(params ...) \
QDF_TRACE_DEBUG(QDF_MODULE_ID_P2P, params)
#define p2p_info(params ...) \
QDF_TRACE_INFO(QDF_MODULE_ID_P2P, params)
#define p2p_warn(params ...) \
QDF_TRACE_WARN(QDF_MODULE_ID_P2P, params)
#define p2p_err(params ...) \
QDF_TRACE_ERROR(QDF_MODULE_ID_P2P, params)
#define p2p_alert(params ...) \
QDF_TRACE_FATAL(QDF_MODULE_ID_P2P, params)
#define p2p_nofl_debug(params ...) \
QDF_TRACE_DEBUG_NO_FL(QDF_MODULE_ID_P2P, params)
#define p2p_nofl_info(params ...) \
QDF_TRACE_INFO_NO_FL(QDF_MODULE_ID_P2P, params)
#define p2p_nofl_warn(params ...) \
QDF_TRACE_WARN_NO_FL(QDF_MODULE_ID_P2P, params)
#define p2p_nofl_err(params ...) \
QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_P2P, params)
#define p2p_nofl_alert(params ...) \
QDF_TRACE_FATAL_NO_FL(QDF_MODULE_ID_P2P, params)
struct scheduler_msg;
struct p2p_tx_cnf;
struct p2p_rx_mgmt_frame;
struct p2p_lo_event;
struct p2p_start_param;
struct p2p_noa_info;
struct tx_action_context;
/**
* enum p2p_cmd_type - P2P request type
* @P2P_ROC_REQ: P2P roc request
* @P2P_CANCEL_ROC_REQ: Cancel P2P roc request
* @P2P_MGMT_TX: P2P tx action frame request
* @P2P_MGMT_TX_CANCEL: Cancel tx action frame request
* @P2P_CLEANUP_ROC: Cleanup roc queue
* @P2P_CLEANUP_TX: Cleanup tx mgmt queue
* @P2P_SET_RANDOM_MAC: Set Random MAC addr filter request
*/
enum p2p_cmd_type {
P2P_ROC_REQ = 0,
P2P_CANCEL_ROC_REQ,
P2P_MGMT_TX,
P2P_MGMT_TX_CANCEL,
P2P_CLEANUP_ROC,
P2P_CLEANUP_TX,
P2P_SET_RANDOM_MAC,
};
/**
* enum p2p_event_type - P2P event type
* @P2P_EVENT_SCAN_EVENT: P2P scan event
* @P2P_EVENT_MGMT_TX_ACK_CNF: P2P mgmt tx confirm frame
* @P2P_EVENT_RX_MGMT: P2P rx mgmt frame
* @P2P_EVENT_LO_STOPPED: P2P listen offload stopped event
* @P2P_EVENT_NOA: P2P noa event
* @P2P_EVENT_ADD_MAC_RSP: Set Random MAC addr event
*/
enum p2p_event_type {
P2P_EVENT_SCAN_EVENT = 0,
P2P_EVENT_MGMT_TX_ACK_CNF,
P2P_EVENT_RX_MGMT,
P2P_EVENT_LO_STOPPED,
P2P_EVENT_NOA,
P2P_EVENT_ADD_MAC_RSP,
};
/**
* struct p2p_tx_conf_event - p2p tx confirm event
* @p2p_soc_obj: p2p soc private object
* @buf: buffer address
* @status: tx status
*/
struct p2p_tx_conf_event {
struct p2p_soc_priv_obj *p2p_soc_obj;
qdf_nbuf_t nbuf;
uint32_t status;
};
/**
* struct p2p_rx_mgmt_event - p2p rx mgmt frame event
* @p2p_soc_obj: p2p soc private object
* @rx_mgmt: p2p rx mgmt frame structure
*/
struct p2p_rx_mgmt_event {
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_rx_mgmt_frame *rx_mgmt;
};
/**
* struct p2p_lo_stop_event - p2p listen offload stop event
* @p2p_soc_obj: p2p soc private object
* @lo_event: p2p lo stop structure
*/
struct p2p_lo_stop_event {
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_lo_event *lo_event;
};
/**
* struct p2p_noa_event - p2p noa event
* @p2p_soc_obj: p2p soc private object
* @noa_info: p2p noa information structure
*/
struct p2p_noa_event {
struct p2p_soc_priv_obj *p2p_soc_obj;
struct p2p_noa_info *noa_info;
};
/**
* struct p2p_mac_filter_rsp - p2p set mac filter respone
* @p2p_soc_obj: p2p soc private object
* @vdev_id: vdev id
* @status: successfully(1) or not (0)
*/
struct p2p_mac_filter_rsp {
struct p2p_soc_priv_obj *p2p_soc_obj;
uint32_t vdev_id;
uint32_t status;
};
#ifdef WLAN_FEATURE_P2P_DEBUG
/**
* enum p2p_connection_status - p2p connection status
* @P2P_NOT_ACTIVE: P2P not active status
* @P2P_GO_NEG_PROCESS: P2P GO negotiation in process
* @P2P_GO_NEG_COMPLETED: P2P GO negotiation complete
* @P2P_CLIENT_CONNECTING_STATE_1: P2P client connecting state 1
* @P2P_GO_COMPLETED_STATE: P2P GO complete state
* @P2P_CLIENT_CONNECTED_STATE_1: P2P client connected state 1
* @P2P_CLIENT_DISCONNECTED_STATE: P2P client disconnected state
* @P2P_CLIENT_CONNECTING_STATE_2: P2P client connecting state 2
* @P2P_CLIENT_COMPLETED_STATE: P2P client complete state
*/
enum p2p_connection_status {
P2P_NOT_ACTIVE,
P2P_GO_NEG_PROCESS,
P2P_GO_NEG_COMPLETED,
P2P_CLIENT_CONNECTING_STATE_1,
P2P_GO_COMPLETED_STATE,
P2P_CLIENT_CONNECTED_STATE_1,
P2P_CLIENT_DISCONNECTED_STATE,
P2P_CLIENT_CONNECTING_STATE_2,
P2P_CLIENT_COMPLETED_STATE
};
#endif
/**
* struct p2p_param - p2p parameters to be used
* @go_keepalive_period: P2P GO keep alive period
* @go_link_monitor_period: period where link is idle and
* where we send NULL frame
* @p2p_device_addr_admin: enable/disable to derive the P2P
* MAC address from the primary MAC address
* @skip_dfs_channel_p2p_search: kip DFS Channel in case of P2P Search
* @ignore_dynamic_dtim_in_p2p_mode:Ignore Dynamic Dtim in case of P2P options
*/
struct p2p_param {
uint32_t go_keepalive_period;
uint32_t go_link_monitor_period;
bool p2p_device_addr_admin;
bool skip_dfs_channel_p2p_search;
bool ignore_dynamic_dtim_in_p2p_mode;
};
/**
* struct p2p_soc_priv_obj - Per SoC p2p private object
* @soc: Pointer to SoC context
* @roc_q: Queue for pending roc requests
* @tx_q_roc: Queue for tx frames waiting for RoC
* @tx_q_ack: Queue for tx frames waiting for ack
* @scan_req_id: Scan requestor id
* @start_param: Start parameters, include callbacks and user
* data to HDD
* @cancel_roc_done: Cancel roc done event
* @cleanup_roc_done: Cleanup roc done event
* @cleanup_tx_done: Cleanup tx done event
* @roc_runtime_lock: Runtime lock for roc request
* @p2p_cb: Callbacks to protocol stack
* @cur_roc_vdev_id: Vdev id of current roc
* @p2p_idr: p2p idr
* @param: p2p parameters to be used
* @connection_status:Global P2P connection status
*/
struct p2p_soc_priv_obj {
struct wlan_objmgr_psoc *soc;
qdf_list_t roc_q;
qdf_list_t tx_q_roc;
qdf_list_t tx_q_ack;
wlan_scan_requester scan_req_id;
struct p2p_start_param *start_param;
qdf_event_t cancel_roc_done;
qdf_event_t cleanup_roc_done;
qdf_event_t cleanup_tx_done;
qdf_runtime_lock_t roc_runtime_lock;
struct p2p_protocol_callbacks p2p_cb;
uint32_t cur_roc_vdev_id;
qdf_idr p2p_idr;
struct p2p_param param;
#ifdef WLAN_FEATURE_P2P_DEBUG
enum p2p_connection_status connection_status;
#endif
};
/**
* struct action_frame_cookie - Action frame cookie item in cookie list
* @cookie_node: qdf_list_node
* @cookie: Cookie value
*/
struct action_frame_cookie {
qdf_list_node_t cookie_node;
uint64_t cookie;
};
/**
* struct action_frame_random_mac - Action Frame random mac addr &
* related attrs
* @p2p_vdev_obj: p2p vdev private obj ptr
* @in_use: Checks whether random mac is in use
* @addr: Contains random mac addr
* @freq: Channel frequency
* @clear_timer: timer to clear random mac filter
* @cookie_list: List of cookies tied with random mac
*/
struct action_frame_random_mac {
struct p2p_vdev_priv_obj *p2p_vdev_obj;
bool in_use;
uint8_t addr[QDF_MAC_ADDR_SIZE];
uint32_t freq;
qdf_mc_timer_t clear_timer;
qdf_list_t cookie_list;
};
/**
* p2p_request_mgr_callback_t() - callback to process set mac filter result
* @result: bool
* @context: callback context.
*
* Return: void
*/
typedef void (*p2p_request_mgr_callback_t)(bool result, void *context);
/**
* struct random_mac_priv - request private data struct
* @result: result of request.
*/
struct random_mac_priv {
bool result;
};
/**
* struct p2p_set_mac_filter_req - set mac addr filter cmd data structure
* @soc: soc object
* @vdev_id: vdev id
* @mac: mac address to be set
* @freq: frequency
* @set: set or clear
* @cb: callback func to be called when the request completion
* @req_cookie: cookie to be used when request completed
*/
struct p2p_set_mac_filter_req {
struct wlan_objmgr_psoc *soc;
uint32_t vdev_id;
uint8_t mac[QDF_MAC_ADDR_SIZE];
uint32_t freq;
bool set;
p2p_request_mgr_callback_t cb;
void *req_cookie;
};
/**
* struct p2p_vdev_priv_obj - Per vdev p2p private object
* @vdev: Pointer to vdev context
* @noa_info: NoA information
* @noa_status: NoA status i.e. Enabled / Disabled (TRUE/FALSE)
* @non_p2p_peer_count: Number of legacy stations connected to this GO
* @random_mac_lock: lock for random_mac list
* @random_mac: active random mac filter lists
* @pending_req: pending set mac filter request.
*/
struct p2p_vdev_priv_obj {
struct wlan_objmgr_vdev *vdev;
struct p2p_noa_info *noa_info;
bool noa_status;
uint16_t non_p2p_peer_count;
/* random address management for management action frames */
qdf_spinlock_t random_mac_lock;
struct action_frame_random_mac random_mac[MAX_RANDOM_MAC_ADDRS];
struct p2p_set_mac_filter_req pending_req;
};
/**
* 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
*
* This function registers psoc/vdev create/delete handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_component_init(void);
/**
* p2p_component_deinit() - P2P component de-init
*
* This function deregisters psoc/vdev create/delete handler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_component_deinit(void);
/**
* p2p_psoc_object_open() - Open P2P component
* @soc: soc context
*
* This function initialize p2p psoc object
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_psoc_object_open(struct wlan_objmgr_psoc *soc);
/**
* p2p_psoc_object_close() - Close P2P component
* @soc: soc context
*
* This function de-init p2p psoc object.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_psoc_object_close(struct wlan_objmgr_psoc *soc);
/**
* p2p_psoc_start() - Start P2P component
* @soc: soc context
* @req: P2P start parameters
*
* This function sets up layer call back in p2p psoc object
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_psoc_start(struct wlan_objmgr_psoc *soc,
struct p2p_start_param *req);
/**
* p2p_psoc_stop() - Stop P2P component
* @soc: soc context
*
* This function clears up layer call back in p2p psoc object.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_psoc_stop(struct wlan_objmgr_psoc *soc);
/**
* p2p_process_cmd() - Process P2P messages in OS interface queue
* @msg: message information
*
* This function is main handler for P2P messages in OS interface
* queue, it gets called by message scheduler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_cmd(struct scheduler_msg *msg);
/**
* p2p_process_evt() - Process P2P messages in target interface queue
* @msg: message information
*
* This function is main handler for P2P messages in target interface
* queue, it gets called by message scheduler.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_evt(struct scheduler_msg *msg);
/**
* p2p_msg_flush_callback() - Callback used to flush P2P messages
* @msg: message information
*
* This callback will be called when scheduler flush some of P2P messages.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_msg_flush_callback(struct scheduler_msg *msg);
/**
* p2p_event_flush_callback() - Callback used to flush P2P events
* @msg: event information
*
* This callback will be called when scheduler flush some of P2P events.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_event_flush_callback(struct scheduler_msg *msg);
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
/**
* p2p_process_lo_stop() - Process lo stop event
* @lo_stop_event: listen offload stop event information
*
* This function handles listen offload stop event and deliver this
* event to HDD layer by registered callback.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_lo_stop(
struct p2p_lo_stop_event *lo_stop_event);
#else
static inline QDF_STATUS p2p_process_lo_stop(
struct p2p_lo_stop_event *lo_stop_event)
{
return QDF_STATUS_SUCCESS;
}
#endif
/**
* p2p_process_noa() - Process noa event
* @noa_event: noa event information
*
* This function handles noa event and save noa information in p2p
* vdev object.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_noa(struct p2p_noa_event *noa_event);
#ifdef WLAN_FEATURE_P2P_DEBUG
/**
* p2p_status_scan() - Update P2P connection status
* @vdev: vdev context
*
* This function updates P2P connection status when scanning
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_status_scan(struct wlan_objmgr_vdev *vdev);
/**
* p2p_status_connect() - Update P2P connection status
* @vdev: vdev context
*
* This function updates P2P connection status when connecting.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_status_connect(struct wlan_objmgr_vdev *vdev);
/**
* p2p_status_disconnect() - Update P2P connection status
* @vdev: vdev context
*
* This function updates P2P connection status when disconnecting.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_status_disconnect(struct wlan_objmgr_vdev *vdev);
/**
* p2p_status_start_bss() - Update P2P connection status
* @vdev: vdev context
*
* This function updates P2P connection status when starting BSS.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_status_start_bss(struct wlan_objmgr_vdev *vdev);
/**
* p2p_status_stop_bss() - Update P2P connection status
* @vdev: vdev context
*
* This function updates P2P connection status when stopping BSS.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_status_stop_bss(struct wlan_objmgr_vdev *vdev);
#else
static inline QDF_STATUS p2p_status_scan(struct wlan_objmgr_vdev *vdev)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS p2p_status_connect(struct wlan_objmgr_vdev *vdev)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS p2p_status_disconnect(struct wlan_objmgr_vdev *vdev)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS p2p_status_start_bss(struct wlan_objmgr_vdev *vdev)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS p2p_status_stop_bss(struct wlan_objmgr_vdev *vdev)
{
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_FEATURE_P2P_DEBUG */
#endif /* _WLAN_P2P_MAIN_H_ */

2955
p2p/core/src/wlan_p2p_off_chan_tx.c Normale Datei
Datei anzeigen

Datei-Diff unterdrückt, da er zu groß ist Diff laden

439
p2p/core/src/wlan_p2p_off_chan_tx.h Normale Datei
Datei anzeigen

@@ -0,0 +1,439 @@
/*
* 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: Defines off channel tx API & structures
*/
#ifndef _WLAN_P2P_OFF_CHAN_TX_H_
#define _WLAN_P2P_OFF_CHAN_TX_H_
#include <qdf_types.h>
#include <qdf_mc_timer.h>
#include <qdf_list.h>
#define P2P_EID_VENDOR 0xdd
#define P2P_ACTION_VENDOR_SPECIFIC_CATEGORY 0x7F
#define P2P_PUBLIC_ACTION_FRAME 0x4
#define P2P_MAC_MGMT_ACTION 0xD
#define P2P_PUBLIC_ACTION_VENDOR_SPECIFIC 0x9
#define P2P_NOA_ATTR 0xC
#define P2P_MAX_NOA_ATTR_LEN 31
#define P2P_IE_HEADER_LEN 6
#define P2P_MAX_IE_LENGTH 255
#define P2P_ACTION_OFFSET 24
#define P2P_PUBLIC_ACTION_FRAME_TYPE_OFFSET 30
#define P2P_ACTION_FRAME_TYPE_OFFSET 29
#define PROBE_RSP_IE_OFFSET 36
#define P2P_TX_PKT_MIN_HEADROOM (64)
#define P2P_OUI "\x50\x6f\x9a\x09"
#define P2P_OUI_SIZE 4
#define P2P_ACTION_FRAME_RSP_WAIT 500
#define P2P_ACTION_FRAME_ACK_WAIT 300
#define P2P_ACTION_FRAME_TX_TIMEOUT 2000
#define DST_MAC_ADDR_OFFSET 4
#define SRC_MAC_ADDR_OFFSET (DST_MAC_ADDR_OFFSET + QDF_MAC_ADDR_SIZE)
#define P2P_NOA_STREAM_ARR_SIZE (P2P_MAX_NOA_ATTR_LEN + (2 * P2P_IE_HEADER_LEN))
#define P2P_GET_TYPE_FRM_FC(__fc__) (((__fc__) & 0x0F) >> 2)
#define P2P_GET_SUBTYPE_FRM_FC(__fc__) (((__fc__) & 0xF0) >> 4)
#define WLAN_WAIT_TIME_SET_RND 100
struct p2p_soc_priv_obj;
struct cancel_roc_context;
struct p2p_tx_conf_event;
struct p2p_rx_mgmt_event;
/**
* enum p2p_frame_type - frame type
* @P2P_FRAME_MGMT: mgmt frame
* @P2P_FRAME_NOT_SUPPORT: not support frame type
*/
enum p2p_frame_type {
P2P_FRAME_MGMT = 0,
P2P_FRAME_NOT_SUPPORT,
};
/**
* enum p2p_frame_sub_type - frame sub type
* @P2P_MGMT_PROBE_REQ: probe request frame
* @P2P_MGMT_PROBE_RSP: probe response frame
* @P2P_MGMT_ACTION: action frame
* @P2P_MGMT_NOT_SUPPORT: not support sub frame type
*/
enum p2p_frame_sub_type {
P2P_MGMT_PROBE_REQ = 4,
P2P_MGMT_PROBE_RSP,
P2P_MGMT_ACTION = 13,
P2P_MGMT_NOT_SUPPORT,
};
/**
* enum p2p_public_action_type - public action frame type
* @P2P_PUBLIC_ACTION_NEG_REQ: go negotiation request frame
* @P2P_PUBLIC_ACTION_NEG_RSP: go negotiation response frame
* @P2P_PUBLIC_ACTION_NEG_CNF: go negotiation confirm frame
* @P2P_PUBLIC_ACTION_INVIT_REQ: p2p invitation request frame
* @P2P_PUBLIC_ACTION_INVIT_RSP: p2p invitation response frame
* @P2P_PUBLIC_ACTION_DEV_DIS_REQ: device discoverability request
* @P2P_PUBLIC_ACTION_DEV_DIS_RSP: device discoverability response
* @P2P_PUBLIC_ACTION_PROV_DIS_REQ: provision discovery request
* @P2P_PUBLIC_ACTION_PROV_DIS_RSP: provision discovery response
* @P2P_PUBLIC_ACTION_GAS_INIT_REQ: gas initial request,
* @P2P_PUBLIC_ACTION_GAS_INIT_RSP: gas initial response
* @P2P_PUBLIC_ACTION_GAS_COMB_REQ: gas comeback request
* @P2P_PUBLIC_ACTION_GAS_COMB_RSP: gas comeback response
* @P2P_PUBLIC_ACTION_NOT_SUPPORT: not support p2p public action frame
*/
enum p2p_public_action_type {
P2P_PUBLIC_ACTION_NEG_REQ = 0,
P2P_PUBLIC_ACTION_NEG_RSP,
P2P_PUBLIC_ACTION_NEG_CNF,
P2P_PUBLIC_ACTION_INVIT_REQ,
P2P_PUBLIC_ACTION_INVIT_RSP,
P2P_PUBLIC_ACTION_DEV_DIS_REQ,
P2P_PUBLIC_ACTION_DEV_DIS_RSP,
P2P_PUBLIC_ACTION_PROV_DIS_REQ,
P2P_PUBLIC_ACTION_PROV_DIS_RSP,
P2P_PUBLIC_ACTION_GAS_INIT_REQ = 10,
P2P_PUBLIC_ACTION_GAS_INIT_RSP,
P2P_PUBLIC_ACTION_GAS_COMB_REQ,
P2P_PUBLIC_ACTION_GAS_COMB_RSP,
P2P_PUBLIC_ACTION_NOT_SUPPORT,
};
/**
* enum p2p_action_type - p2p action frame type
* @P2P_ACTION_PRESENCE_REQ: presence request frame
* @P2P_ACTION_PRESENCE_RSP: presence response frame
* @P2P_ACTION_NOT_SUPPORT: not support action frame type
*/
enum p2p_action_type {
P2P_ACTION_PRESENCE_REQ = 1,
P2P_ACTION_PRESENCE_RSP = 2,
P2P_ACTION_NOT_SUPPORT,
};
struct p2p_frame_info {
enum p2p_frame_type type;
enum p2p_frame_sub_type sub_type;
enum p2p_public_action_type public_action_type;
enum p2p_action_type action_type;
};
/**
* struct tx_action_context - tx action frame context
* @node: Node for next element in the list
* @p2p_soc_obj: Pointer to SoC global p2p private object
* @vdev_id: Vdev id on which this request has come
* @scan_id: Scan id given by scan component for this roc req
* @roc_cookie: Cookie for remain on channel request
* @id: Identifier of this tx context
* @chan: Chan for which this tx has been requested
* @buf: tx buffer
* @buf_len: Length of tx buffer
* @off_chan: Is this off channel tx
* @no_cck: Required cck or not
* @no_ack: Required ack or not
* @duration: Duration for the RoC
* @tx_timer: RoC timer
* @frame_info: Frame type information
*/
struct tx_action_context {
qdf_list_node_t node;
struct p2p_soc_priv_obj *p2p_soc_obj;
int vdev_id;
int scan_id;
uint64_t roc_cookie;
int32_t id;
uint8_t chan;
uint8_t *buf;
int buf_len;
bool off_chan;
bool no_cck;
bool no_ack;
bool rand_mac_tx;
uint32_t duration;
qdf_mc_timer_t tx_timer;
struct p2p_frame_info frame_info;
qdf_nbuf_t nbuf;
};
/**
* p2p_rand_mac_tx_done() - process random mac mgmt tx done
* @soc: soc
* @tx_ctx: tx context
*
* This function will remove the random mac addr filter reference.
*
* Return: void
*/
void
p2p_rand_mac_tx_done(struct wlan_objmgr_psoc *soc,
struct tx_action_context *tx_ctx);
/**
* p2p_clear_mac_filter() - send clear mac addr filter cmd
* @soc: soc
* @vdev_id: vdev id
* @mac: mac addr
* @freq: freq
*
* This function send clear random mac addr filter command to p2p component
* msg core
*
* Return: QDF_STATUS_SUCCESS - if sent successfully.
* otherwise: failed.
*/
QDF_STATUS
p2p_clear_mac_filter(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
uint8_t *mac, uint32_t freq);
/**
* p2p_is_vdev_support_rand_mac() - check vdev type support random mac mgmt
* tx or not
* @vdev: vdev object
*
* Return: true: support random mac mgmt tx
* false: not support random mac mgmt tx.
*/
bool
p2p_is_vdev_support_rand_mac(struct wlan_objmgr_vdev *vdev);
/**
* p2p_dump_tx_queue() - dump tx queue
* @p2p_soc_obj: p2p soc private object
*
* This function dumps tx queue and output details about tx context in
* queue.
*
* Return: None
*/
void p2p_dump_tx_queue(struct p2p_soc_priv_obj *p2p_soc_obj);
/**
* p2p_ready_to_tx_frame() - dump tx queue
* @p2p_soc_obj: p2p soc private object
* @cookie: cookie is pointer to roc
*
* This function find out the tx context in wait for roc queue and tx
* this frame.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_ready_to_tx_frame(struct p2p_soc_priv_obj *p2p_soc_obj,
uint64_t cookie);
/**
* p2p_cleanup_tx_sync() - Cleanup tx queue
* @p2p_soc_obj: p2p psoc private object
* @vdev: vdev object
*
* This function cleanup tx context in queue until cancellation done.
* To avoid deadlock, don't call from scheduler thread.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_cleanup_tx_sync(
struct p2p_soc_priv_obj *p2p_soc_obj,
struct wlan_objmgr_vdev *vdev);
/**
* p2p_process_cleanup_tx_queue() - process the message to cleanup tx
* @param: pointer to cleanup parameters
*
* This function cleanup wait for roc queue and wait for ack queue.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_cleanup_tx_queue(
struct p2p_cleanup_param *param);
/**
* p2p_process_mgmt_tx() - Process mgmt frame tx request
* @tx_ctx: tx context
*
* This function handles mgmt frame tx request. It will call API from
* mgmt txrx component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_mgmt_tx(struct tx_action_context *tx_ctx);
/**
* p2p_process_mgmt_tx_cancel() - Process cancel mgmt frame tx request
* @cancel_tx: cancel tx context
*
* This function cancel mgmt frame tx request by cookie.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_mgmt_tx_cancel(
struct cancel_roc_context *cancel_tx);
/**
* p2p_process_mgmt_tx_ack_cnf() - Process tx ack event
* @tx_cnf_event: tx confirmation event information
*
* This function mgmt frame tx confirmation. It will deliver this
* event to up layer
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_mgmt_tx_ack_cnf(
struct p2p_tx_conf_event *tx_cnf_event);
/**
* p2p_process_rx_mgmt() - Process rx mgmt frame event
* @rx_mgmt_event: rx mgmt frame event information
*
* This function mgmt frame rx mgmt frame event. It will deliver this
* event to up layer
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_rx_mgmt(
struct p2p_rx_mgmt_event *rx_mgmt_event);
/**
* p2p_find_tx_ctx_by_nbuf() - find tx context by nbuf
* @p2p_soc_obj: p2p soc object
* @nbuf: pointer to nbuf
*
* This function finds out tx context by nbuf.
*
* Return: pointer to tx context
*/
struct tx_action_context *p2p_find_tx_ctx_by_nbuf(
struct p2p_soc_priv_obj *p2p_soc_obj, void *nbuf);
#define P2P_80211_FRM_SA_OFFSET 10
/**
* p2p_del_random_mac() - del mac fitler from given vdev rand mac list
* @soc: soc object
* @vdev_id: vdev id
* @rnd_cookie: random mac mgmt tx cookie
* @duration: timeout value to flush the addr in target.
*
* This function will del the mac addr filter from vdev random mac addr list.
* If there is no reference to mac addr, it will set a clear timer to flush it
* in target finally.
*
* Return: QDF_STATUS_SUCCESS - del successfully.
* other : failed to del the mac address entry.
*/
QDF_STATUS
p2p_del_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
uint64_t rnd_cookie, uint32_t duration);
/**
* p2p_check_random_mac() - check random mac addr or not
* @soc: soc context
* @vdev_id: vdev id
* @random_mac_addr: mac addr to be checked
*
* This function check the input addr is random mac addr or not for vdev.
*
* Return: true if addr is random mac address else false.
*/
bool p2p_check_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
uint8_t *random_mac_addr);
/**
* p2p_process_set_rand_mac() - process the set random mac command
* @set_filter_req: request data
*
* This function will process the set mac addr filter command.
*
* Return: QDF_STATUS_SUCCESS: if process successfully
* other: failed.
*/
QDF_STATUS p2p_process_set_rand_mac(
struct p2p_set_mac_filter_req *set_filter_req);
/**
* p2p_process_set_rand_mac_rsp() - process the set random mac response
* @resp: response date
*
* This function will process the set mac addr filter event.
*
* Return: QDF_STATUS_SUCCESS: if process successfully
* other: failed.
*/
QDF_STATUS p2p_process_set_rand_mac_rsp(struct p2p_mac_filter_rsp *resp);
/**
* p2p_del_all_rand_mac_vdev() - del all random mac filter in vdev
* @vdev: vdev object
*
* This function will del all random mac filter in vdev
*
* Return: void
*/
void p2p_del_all_rand_mac_vdev(struct wlan_objmgr_vdev *vdev);
/**
* p2p_del_all_rand_mac_soc() - del all random mac filter in soc
* @soc: soc object
*
* This function will del all random mac filter in all vdev of soc
*
* Return: void
*/
void p2p_del_all_rand_mac_soc(struct wlan_objmgr_psoc *soc);
/**
* p2p_rand_mac_tx() - handle random mac mgmt tx
* @tx_action: tx action context
*
* This function will check whether need to set random mac tx filter for a
* given mgmt tx request and do the mac addr filter process as needed.
*
* Return: void
*/
void p2p_rand_mac_tx(struct tx_action_context *tx_action);
/**
* p2p_init_random_mac_vdev() - Init random mac data for vdev
* @p2p_vdev_obj: p2p vdev private object
*
* This function will init the per vdev random mac data structure.
*
* Return: void
*/
void p2p_init_random_mac_vdev(struct p2p_vdev_priv_obj *p2p_vdev_obj);
/**
* p2p_deinit_random_mac_vdev() - Init random mac data for vdev
* @p2p_vdev_obj: p2p vdev private object
*
* This function will deinit the per vdev random mac data structure.
*
* Return: void
*/
void p2p_deinit_random_mac_vdev(struct p2p_vdev_priv_obj *p2p_vdev_obj);
#endif /* _WLAN_P2P_OFF_CHAN_TX_H_ */

929
p2p/core/src/wlan_p2p_roc.c Normale Datei
Datei anzeigen

@@ -0,0 +1,929 @@
/*
* 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 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:%pK, is register rx:%d", psoc, isregister);
frm_cb_info.frm_type = MGMT_PROBE_REQ;
frm_cb_info.mgmt_rx_cb = 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.p2p_scan_type = SCAN_P2P_LISTEN;
req->scan_req.scan_req_id = p2p_soc_obj->scan_req_id;
req->scan_req.chan_list.num_chan = 1;
req->scan_req.chan_list.chan[0].freq = wlan_chan_to_freq(roc_ctx->chan);
req->scan_req.dwell_time_passive = roc_ctx->duration;
req->scan_req.dwell_time_active = 0;
req->scan_req.scan_priority = SCAN_PRIORITY_HIGH;
req->scan_req.num_bssid = 1;
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;
qdf_mtrace(QDF_MODULE_ID_P2P, QDF_MODULE_ID_SCAN,
req->cancel_req.req_type,
req->vdev->vdev_objmgr.vdev_id, req->cancel_req.scan_id);
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_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 = (uint64_t)roc_ctx->id;
p2p_evt.chan = roc_ctx->chan;
p2p_evt.duration = roc_ctx->duration;
p2p_debug("p2p soc_obj:%pK, roc_ctx:%pK, 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_destroy_roc_ctx() - destroy roc ctx
* @roc_ctx: remain on channel request
* @up_layer_event: if send uplayer event
* @in_roc_queue: if roc context in roc queue
*
* This function destroy roc context.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
static QDF_STATUS p2p_destroy_roc_ctx(struct p2p_roc_context *roc_ctx,
bool up_layer_event, bool in_roc_queue)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct p2p_soc_priv_obj *p2p_soc_obj = roc_ctx->p2p_soc_obj;
p2p_debug("p2p_soc_obj:%pK, roc_ctx:%pK, up_layer_event:%d, in_roc_queue:%d",
p2p_soc_obj, roc_ctx, up_layer_event, in_roc_queue);
if (up_layer_event) {
if (roc_ctx->roc_state < ROC_STATE_ON_CHAN)
p2p_send_roc_event(roc_ctx, ROC_EVENT_READY_ON_CHAN);
p2p_send_roc_event(roc_ctx, ROC_EVENT_COMPLETED);
}
if (in_roc_queue) {
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_idr_remove(&p2p_soc_obj->p2p_idr, roc_ctx->id);
qdf_mem_free(roc_ctx);
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:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, 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 %pK", roc_ctx);
status = p2p_scan_abort(roc_ctx);
if (status != QDF_STATUS_SUCCESS) {
p2p_err("Failed to abort scan, status:%d, destroy roc %pK",
status, roc_ctx);
qdf_mc_timer_destroy(&roc_ctx->roc_timer);
p2p_mgmt_rx_ops(p2p_soc_obj->soc, false);
p2p_destroy_roc_ctx(roc_ctx, true, true);
qdf_event_set(&p2p_soc_obj->cancel_roc_done);
return 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:%pK", 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:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, 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:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
/* prevent runtime suspend */
qdf_runtime_pm_prevent_suspend(&p2p_soc_obj->roc_runtime_lock);
status = qdf_mc_timer_init(&roc_ctx->roc_timer,
QDF_TIMER_TYPE_SW, p2p_roc_timeout,
p2p_soc_obj);
if (status != QDF_STATUS_SUCCESS) {
p2p_err("failed to init roc timer, status:%d", status);
goto fail;
}
roc_ctx->roc_state = ROC_STATE_REQUESTED;
if (roc_ctx->duration < P2P_MAX_ROC_DURATION) {
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;
/* this is to protect too huge value if some customers
* give a higher value from supplicant
*/
if (roc_ctx->duration > P2P_MAX_ROC_DURATION)
roc_ctx->duration = P2P_MAX_ROC_DURATION;
}
status = p2p_scan_start(roc_ctx);
if (status != QDF_STATUS_SUCCESS) {
qdf_mc_timer_destroy(&roc_ctx->roc_timer);
p2p_err("Failed to start scan, status:%d", status);
goto fail;
}
fail:
if (status != QDF_STATUS_SUCCESS) {
p2p_destroy_roc_ctx(roc_ctx, true, true);
qdf_runtime_pm_allow_suspend(
&p2p_soc_obj->roc_runtime_lock);
return status;
}
p2p_soc_obj->cur_roc_vdev_id = roc_ctx->vdev_id;
status = p2p_mgmt_rx_ops(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 *p_node;
QDF_STATUS status;
p2p_debug("p2p soc obj:%pK, cookie:%llx", p2p_soc_obj, cookie);
status = qdf_list_peek_front(&p2p_soc_obj->roc_q, &p_node);
while (QDF_IS_STATUS_SUCCESS(status)) {
curr_roc_ctx = qdf_container_of(p_node,
struct p2p_roc_context, node);
if ((uintptr_t) curr_roc_ctx == cookie)
return curr_roc_ctx;
status = qdf_list_peek_next(&p2p_soc_obj->roc_q,
p_node, &p_node);
}
return NULL;
}
/**
* 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:%pK, 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:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, 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_PROPAGATE_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);
}
cookie = (uintptr_t)roc_ctx;
/* ready to tx frame */
p2p_ready_to_tx_frame(p2p_soc_obj, cookie);
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:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
/* allow runtime suspend */
qdf_runtime_pm_allow_suspend(&p2p_soc_obj->roc_runtime_lock);
if (QDF_TIMER_STATE_RUNNING ==
qdf_mc_timer_get_current_state(&roc_ctx->roc_timer)) {
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);
p2p_soc_obj->cur_roc_vdev_id = P2P_INVALID_VDEV_ID;
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);
p2p_destroy_roc_ctx(roc_ctx, false, true);
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;
}
QDF_STATUS p2p_mgmt_rx_action_ops(struct wlan_objmgr_psoc *psoc,
bool isregister)
{
struct mgmt_txrx_mgmt_frame_cb_info frm_cb_info[2];
QDF_STATUS status;
p2p_debug("psoc:%pK, is register rx:%d", psoc, isregister);
frm_cb_info[0].frm_type = MGMT_ACTION_VENDOR_SPECIFIC;
frm_cb_info[0].mgmt_rx_cb = tgt_p2p_mgmt_frame_rx_cb;
frm_cb_info[1].frm_type = MGMT_ACTION_CATEGORY_VENDOR_SPECIFIC;
frm_cb_info[1].mgmt_rx_cb = tgt_p2p_mgmt_frame_rx_cb;
if (isregister)
status = wlan_mgmt_txrx_register_rx_cb(psoc,
WLAN_UMAC_COMP_P2P, frm_cb_info, 2);
else
status = wlan_mgmt_txrx_deregister_rx_cb(psoc,
WLAN_UMAC_COMP_P2P, frm_cb_info, 2);
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 *p_node;
QDF_STATUS status;
status = qdf_list_peek_front(&p2p_soc_obj->roc_q, &p_node);
while (QDF_IS_STATUS_SUCCESS(status)) {
roc_ctx = qdf_container_of(p_node,
struct p2p_roc_context, node);
if (roc_ctx->roc_state != ROC_STATE_IDLE) {
p2p_debug("p2p soc obj:%pK, roc ctx:%pK, vdev_id"
":%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
return roc_ctx;
}
status = qdf_list_peek_next(&p2p_soc_obj->roc_q,
p_node, &p_node);
}
return NULL;
}
struct p2p_roc_context *p2p_find_roc_by_tx_ctx(
struct p2p_soc_priv_obj *p2p_soc_obj, uint64_t cookie)
{
struct p2p_roc_context *curr_roc_ctx;
qdf_list_node_t *p_node;
QDF_STATUS status;
p2p_debug("p2p soc obj:%pK, cookie:%llx", p2p_soc_obj, cookie);
status = qdf_list_peek_front(&p2p_soc_obj->roc_q, &p_node);
while (QDF_IS_STATUS_SUCCESS(status)) {
curr_roc_ctx = qdf_container_of(p_node,
struct p2p_roc_context, node);
if ((uintptr_t) curr_roc_ctx->tx_ctx == cookie)
return curr_roc_ctx;
status = qdf_list_peek_next(&p2p_soc_obj->roc_q,
p_node, &p_node);
}
return NULL;
}
struct p2p_roc_context *p2p_find_roc_by_chan(
struct p2p_soc_priv_obj *p2p_soc_obj, uint8_t chan)
{
struct p2p_roc_context *roc_ctx;
qdf_list_node_t *p_node;
QDF_STATUS status;
status = qdf_list_peek_front(&p2p_soc_obj->roc_q, &p_node);
while (QDF_IS_STATUS_SUCCESS(status)) {
roc_ctx = qdf_container_of(p_node,
struct p2p_roc_context,
node);
if (roc_ctx->chan == chan) {
p2p_debug("p2p soc obj:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
return roc_ctx;
}
status = qdf_list_peek_next(&p2p_soc_obj->roc_q,
p_node, &p_node);
}
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_sync(
struct p2p_soc_priv_obj *p2p_soc_obj,
struct wlan_objmgr_vdev *vdev)
{
struct scheduler_msg msg = {0};
struct p2p_cleanup_param *param;
QDF_STATUS status;
uint32_t vdev_id;
if (!p2p_soc_obj) {
p2p_err("p2p soc context is NULL");
return QDF_STATUS_E_FAILURE;
}
p2p_debug("p2p_soc_obj:%pK, vdev:%pK", p2p_soc_obj, vdev);
param = qdf_mem_malloc(sizeof(*param));
if (!param) {
p2p_err("failed to allocate cleanup param");
return QDF_STATUS_E_NOMEM;
}
param->p2p_soc_obj = p2p_soc_obj;
if (vdev)
vdev_id = (uint32_t)wlan_vdev_get_id(vdev);
else
vdev_id = P2P_INVALID_VDEV_ID;
param->vdev_id = vdev_id;
qdf_event_reset(&p2p_soc_obj->cleanup_roc_done);
msg.type = P2P_CLEANUP_ROC;
msg.bodyptr = param;
msg.callback = p2p_process_cmd;
status = scheduler_post_message(QDF_MODULE_ID_P2P,
QDF_MODULE_ID_P2P,
QDF_MODULE_ID_OS_IF, &msg);
if (status != QDF_STATUS_SUCCESS) {
p2p_err("failed to post message");
qdf_mem_free(param);
return status;
}
status = qdf_wait_single_event(
&p2p_soc_obj->cleanup_roc_done,
P2P_WAIT_CLEANUP_ROC);
if (status != QDF_STATUS_SUCCESS)
p2p_err("wait for cleanup roc timeout, %d", status);
return status;
}
QDF_STATUS p2p_process_cleanup_roc_queue(
struct p2p_cleanup_param *param)
{
uint32_t vdev_id;
QDF_STATUS status, ret;
struct p2p_roc_context *roc_ctx;
qdf_list_node_t *p_node;
struct p2p_soc_priv_obj *p2p_soc_obj;
if (!param || !(param->p2p_soc_obj)) {
p2p_err("Invalid cleanup param");
return QDF_STATUS_E_FAILURE;
}
p2p_soc_obj = param->p2p_soc_obj;
vdev_id = param->vdev_id;
p2p_debug("clean up idle roc request, roc queue size:%d, vdev id:%d",
qdf_list_size(&p2p_soc_obj->roc_q), vdev_id);
status = qdf_list_peek_front(&p2p_soc_obj->roc_q, &p_node);
while (QDF_IS_STATUS_SUCCESS(status)) {
roc_ctx = qdf_container_of(p_node,
struct p2p_roc_context, node);
p2p_debug("p2p soc obj:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
status = qdf_list_peek_next(&p2p_soc_obj->roc_q,
p_node, &p_node);
if ((roc_ctx->roc_state == ROC_STATE_IDLE) &&
((vdev_id == P2P_INVALID_VDEV_ID) ||
(vdev_id == roc_ctx->vdev_id))) {
ret = qdf_list_remove_node(
&p2p_soc_obj->roc_q,
(qdf_list_node_t *)roc_ctx);
if (ret == 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));
status = qdf_list_peek_front(&p2p_soc_obj->roc_q, &p_node);
while (QDF_IS_STATUS_SUCCESS(status)) {
roc_ctx = qdf_container_of(p_node,
struct p2p_roc_context, node);
p2p_debug("p2p soc obj:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx ctx:%pK, 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->tx_ctx, roc_ctx->chan,
roc_ctx->phy_mode, roc_ctx->duration,
roc_ctx->roc_type, roc_ctx->roc_state);
status = qdf_list_peek_next(&p2p_soc_obj->roc_q,
p_node, &p_node);
if ((roc_ctx->roc_state != ROC_STATE_IDLE) &&
((vdev_id == P2P_INVALID_VDEV_ID) ||
(vdev_id == roc_ctx->vdev_id))) {
if (roc_ctx->roc_state !=
ROC_STATE_CANCEL_IN_PROG)
p2p_execute_cancel_roc_req(roc_ctx);
ret = qdf_wait_single_event(
&p2p_soc_obj->cancel_roc_done,
P2P_WAIT_CANCEL_ROC);
p2p_debug("RoC cancellation done, return:%d", ret);
}
}
qdf_event_set(&p2p_soc_obj->cleanup_roc_done);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS p2p_process_roc_req(struct p2p_roc_context *roc_ctx)
{
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:%pK, roc ctx:%pK, vdev_id:%d, scan_id:%d, tx_ctx:%pK, 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->tx_ctx, 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) {
p2p_destroy_roc_ctx(roc_ctx, true, false);
p2p_debug("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)
{
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:%pK, cookie:%llx, roc ctx:%pK",
p2p_soc_obj, cancel_roc_ctx->cookie, curr_roc_ctx);
if (!curr_roc_ctx) {
p2p_debug("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 = p2p_destroy_roc_ctx(curr_roc_ctx, true, true);
} 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:%pK, 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;
}
qdf_mtrace(QDF_MODULE_ID_SCAN, QDF_MODULE_ID_P2P, event->type,
event->vdev_id, event->scan_id);
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:
case SCAN_EVENT_TYPE_DEQUEUED:
case SCAN_EVENT_TYPE_START_FAILED:
p2p_process_scan_complete_evt(curr_roc_ctx);
break;
default:
p2p_debug("drop scan event, %d", event->type);
}
}

247
p2p/core/src/wlan_p2p_roc.h Normale Datei
Datei anzeigen

@@ -0,0 +1,247 @@
/*
* 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: Defines RoC API & structures
*/
#ifndef _WLAN_P2P_ROC_H_
#define _WLAN_P2P_ROC_H_
#include <qdf_types.h>
#include <qdf_mc_timer.h>
#include <qdf_list.h>
#define P2P_EVENT_PROPAGATE_TIME 10
#define P2P_WAIT_CANCEL_ROC 1000
#define P2P_WAIT_CLEANUP_ROC 2000
#define P2P_MAX_ROC_DURATION 1500
#define P2P_ROC_DURATION_MULTI_GO_PRESENT 6
#define P2P_ROC_DURATION_MULTI_GO_ABSENT 10
#define P2P_ACTION_FRAME_DEFAULT_WAIT 200
struct wlan_objmgr_vdev;
struct scan_event;
/**
* enum roc_type - user requested or off channel tx
* @USER_REQUESTED: Requested by supplicant
* @OFF_CHANNEL_TX: Issued internally for off channel tx
*/
enum roc_type {
USER_REQUESTED,
OFF_CHANNEL_TX,
};
/**
* enum roc_state - P2P RoC state
* @ROC_STATE_IDLE: RoC not yet started or completed
* @ROC_STATE_REQUESTED: Sent scan command to scan manager
* @ROC_STATE_STARTED: Got started event from scan manager
* @ROC_STATE_ON_CHAN: Got foreign channel event from SCM
* @ROC_STATE_CANCEL_IN_PROG: Requested abort scan to SCM
* @ROC_STATE_INVALID: We should not come to this state
*/
enum roc_state {
ROC_STATE_IDLE = 0,
ROC_STATE_REQUESTED,
ROC_STATE_STARTED,
ROC_STATE_ON_CHAN,
ROC_STATE_CANCEL_IN_PROG,
ROC_STATE_INVALID,
};
/**
* struct p2p_roc_context - RoC request context
* @node: Node for next element in the list
* @p2p_soc_obj: Pointer to SoC global p2p private object
* @vdev_id: Vdev id on which this request has come
* @scan_id: Scan id given by scan component for this roc req
* @tx_ctx: TX context if this ROC is for tx MGMT
* @chan: Chan for which this RoC has been requested
* @phy_mode: PHY mode
* @duration: Duration for the RoC
* @roc_type: RoC type User requested or internal
* @roc_timer: RoC timer
* @roc_state: Roc state
* @id: identifier of roc
*/
struct p2p_roc_context {
qdf_list_node_t node;
struct p2p_soc_priv_obj *p2p_soc_obj;
uint32_t vdev_id;
uint32_t scan_id;
void *tx_ctx;
uint8_t chan;
uint8_t phy_mode;
uint32_t duration;
enum roc_type roc_type;
qdf_mc_timer_t roc_timer;
enum roc_state roc_state;
int32_t id;
};
/**
* struct cancel_roc_context - p2p cancel roc context
* @p2p_soc_obj: Pointer to SoC global p2p private object
* @cookie: Cookie which is given by supplicant
*/
struct cancel_roc_context {
struct p2p_soc_priv_obj *p2p_soc_obj;
uint64_t cookie;
};
/**
* struct p2p_cleanup_param - p2p cleanup parameters
* @p2p_soc_obj: Pointer to SoC global p2p private object
* @vdev_id: vdev id
*/
struct p2p_cleanup_param {
struct p2p_soc_priv_obj *p2p_soc_obj;
uint32_t vdev_id;
};
/**
* p2p_mgmt_rx_action_ops() - register or unregister rx action callback
* @psoc: psoc object
* @isregister: register if true, unregister if false
*
* This function registers or unregisters rx action frame callback to
* mgmt txrx component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_mgmt_rx_action_ops(struct wlan_objmgr_psoc *psoc,
bool isregister);
/**
* p2p_find_current_roc_ctx() - Find out roc context in progressing
* @p2p_soc_obj: p2p psoc private object
*
* This function finds 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_find_roc_by_tx_ctx() - Find out roc context by tx context
* @p2p_soc_obj: p2p psoc private object
* @cookie: cookie is the key to find out roc context
*
* This function finds out roc context by tx context from p2p psoc
* private object
*
* Return: Pointer to roc context - success
* NULL - failure
*/
struct p2p_roc_context *p2p_find_roc_by_tx_ctx(
struct p2p_soc_priv_obj *p2p_soc_obj, uint64_t cookie);
/**
* p2p_find_roc_by_chan() - Find out roc context by channel
* @p2p_soc_obj: p2p psoc private object
* @chan: channel of the ROC
*
* This function finds out roc context by channel from p2p psoc
* private object
*
* Return: Pointer to roc context - success
* NULL - failure
*/
struct p2p_roc_context *p2p_find_roc_by_chan(
struct p2p_soc_priv_obj *p2p_soc_obj, uint8_t chan);
/**
* 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_sync() - Cleanup roc context in queue
* @p2p_soc_obj: p2p psoc private object
* @vdev: vdev object
*
* This function cleanup roc context in queue, include the roc
* context in progressing until cancellation done. To avoid deadlock,
* don't call from scheduler thread.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_cleanup_roc_sync(
struct p2p_soc_priv_obj *p2p_soc_obj,
struct wlan_objmgr_vdev *vdev);
/**
* p2p_process_cleanup_roc_queue() - process the message to cleanup roc
* @param: pointer to cleanup parameters
*
* This function process the message to cleanup roc context in queue,
* include the roc context in progressing.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_cleanup_roc_queue(
struct p2p_cleanup_param *param);
/**
* p2p_process_roc_req() - Process roc request
* @roc_ctx: roc request context
*
* This function handles roc request. It will call API from scan/mgmt
* txrx component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_roc_req(struct p2p_roc_context *roc_ctx);
/**
* p2p_process_cancel_roc_req() - Process cancel roc request
* @cancel_roc_ctx: cancel roc request context
*
* This function cancel roc request by cookie.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS p2p_process_cancel_roc_req(
struct cancel_roc_context *cancel_roc_ctx);
/**
* p2p_scan_event_cb() - Process scan event
* @vdev: vdev associated to this scan event
* @event: event information
* @arg: registered arguments
*
* This function handles P2P scan event and deliver P2P event to HDD
* layer by registered callback.
*
* Return: None
*/
void p2p_scan_event_cb(struct wlan_objmgr_vdev *vdev,
struct scan_event *event, void *arg);
#endif /* _WLAN_P2P_ROC_H_ */

128
p2p/dispatcher/inc/wlan_p2p_cfg.h Normale Datei
Datei anzeigen

@@ -0,0 +1,128 @@
/*
* 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.
*/
#if !defined(CONFIG_P2P_H__)
#define CONFIG_P2P_H__
#include "cfg_define.h"
#include "cfg_converged.h"
#include "qdf_types.h"
/*
* <ini>
* gGoKeepAlivePeriod - P2P GO keep alive period.
* @Min: 1
* @Max: 65535
* @Default: 20
*
* This is P2P GO keep alive period.
*
* Related: None.
*
* Supported Feature: P2P
*
* Usage: Internal/External
*
* </ini>
*/
#define CFG_GO_KEEP_ALIVE_PERIOD CFG_INI_UINT( \
"gGoKeepAlivePeriod", \
1, \
65535, \
20, \
CFG_VALUE_OR_DEFAULT, \
"P2P GO keep alive period")
/*
* <ini>
* gGoLinkMonitorPeriod - period where link is idle and where
* we send NULL frame
* @Min: 3
* @Max: 50
* @Default: 10
*
* This is period where link is idle and where we send NULL frame for P2P GO.
*
* Related: None.
*
* Supported Feature: P2P
*
* Usage: Internal/External
*
* </ini>
*/
#define CFG_GO_LINK_MONITOR_PERIOD CFG_INI_UINT( \
"gGoLinkMonitorPeriod", \
3, \
50, \
10, \
CFG_VALUE_OR_DEFAULT, \
"period where link is idle and where we send NULL frame")
/*
* <ini>
* isP2pDeviceAddrAdministrated - Enables to derive the P2P MAC address from
* the primary MAC address
* @Min: 0
* @Max: 1
* @Default: 1
*
* This ini is used to enable/disable to derive the P2P MAC address from the
* primary MAC address.
*
* Related: None.
*
* Supported Feature: P2P
*
* Usage: Internal/External
*
* </ini>
*/
#define CFG_P2P_DEVICE_ADDRESS_ADMINISTRATED CFG_INI_BOOL( \
"isP2pDeviceAddrAdministrated", \
1, \
"derive the P2P MAC address from the primary MAC address")
/*
* <ini>
* gSkipDfsChannelInP2pSearch - Skip DFS Channel in case of P2P Search
* @Min: 0
* @Max: 1
* @Default: 1
*
* This ini is used to disable(skip) dfs channel in p2p search.
* Related: None.
*
* Supported Feature: DFS P2P
*
* Usage: Internal/External
*
* </ini>
*/
#define CFG_ENABLE_SKIP_DFS_IN_P2P_SEARCH CFG_INI_BOOL( \
"gSkipDfsChannelInP2pSearch", \
1, \
"skip dfs channel in p2p search")
#define CFG_P2P_ALL \
CFG(CFG_GO_KEEP_ALIVE_PERIOD) \
CFG(CFG_GO_LINK_MONITOR_PERIOD) \
CFG(CFG_P2P_DEVICE_ADDRESS_ADMINISTRATED) \
CFG(CFG_ENABLE_SKIP_DFS_IN_P2P_SEARCH)
#endif

76
p2p/dispatcher/inc/wlan_p2p_cfg_api.h Normale Datei
Datei anzeigen

@@ -0,0 +1,76 @@
/*
* 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: Contains p2p configures interface definitions
*/
#ifndef _WLAN_P2P_CFG_API_H_
#define _WLAN_P2P_CFG_API_H_
#include <qdf_types.h>
struct wlan_objmgr_psoc;
/**
* cfg_p2p_get_go_keepalive_period() - get go keepalive period
* @psoc: pointer to psoc object
* @period: go keepalive period
*
* This function gets go keepalive period to p2p component
*/
QDF_STATUS
cfg_p2p_get_go_keepalive_period(struct wlan_objmgr_psoc *psoc,
uint32_t *period);
/**
* cfg_p2p_get_go_link_monitor_period() - get go link monitor period
* @psoc: pointer to psoc object
* @period: go link monitor period
*
* This function gets go link monitor period to p2p component
*/
QDF_STATUS
cfg_p2p_get_go_link_monitor_period(struct wlan_objmgr_psoc *psoc,
uint32_t *period);
/**
* cfg_p2p_get_device_addr_admin() - get enable/disable p2p device
* addr administrated
* @psoc: pointer to psoc object
* @enable: enable/disable p2p device addr administrated
*
* This function gets enable/disable p2p device addr administrated
*/
QDF_STATUS
cfg_p2p_get_device_addr_admin(struct wlan_objmgr_psoc *psoc,
bool *enable);
/**
* cfg_p2p_get_skip_dfs_channel_p2p_search() - get skip dfs channel
* in p2p search
* @psoc: pointer to psoc object
* @enable: enable/disable skip dfs channel in p2p search
*
* This function gets enable/disable skip dfs channel in p2p search
*/
QDF_STATUS
cfg_p2p_get_skip_dfs_channel_p2p_search(struct wlan_objmgr_psoc *psoc,
bool *enable);
#endif /* _WLAN_P2P_CFG_API_H_ */

272
p2p/dispatcher/inc/wlan_p2p_public_struct.h Normale Datei
Datei anzeigen

@@ -0,0 +1,272 @@
/*
* 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: Contains p2p public data structure definations
*/
#ifndef _WLAN_P2P_PUBLIC_STRUCT_H_
#define _WLAN_P2P_PUBLIC_STRUCT_H_
#include <qdf_types.h>
#define P2P_MAX_NOA_DESC 4
/**
* struct p2p_ps_params - P2P powersave related params
* @opp_ps: opportunistic power save
* @ctwindow: CT window
* @count: count
* @duration: duration
* @interval: interval
* @single_noa_duration: single shot noa duration
* @ps_selection: power save selection
* @session_id: session id
*/
struct p2p_ps_params {
uint8_t opp_ps;
uint32_t ctwindow;
uint8_t count;
uint32_t duration;
uint32_t interval;
uint32_t single_noa_duration;
uint8_t ps_selection;
uint8_t session_id;
};
/**
* struct p2p_roc_req - P2P roc request
* @vdev_id: Vdev id on which this request has come
* @chan: Chan for which this RoC has been requested
* @phy_mode: PHY mode
* @duration: Duration for the RoC
*/
struct p2p_roc_req {
uint32_t vdev_id;
uint32_t chan;
uint32_t phy_mode;
uint32_t duration;
};
/**
* enum p2p_roc_event - P2P RoC event
* @ROC_EVENT_READY_ON_CHAN: RoC has started now
* @ROC_EVENT_COMPLETED: RoC has been completed
* @ROC_EVENT_INAVLID: Invalid event
*/
enum p2p_roc_event {
ROC_EVENT_READY_ON_CHAN = 0,
ROC_EVENT_COMPLETED,
ROC_EVENT_INAVLID,
};
/**
* struct p2p_event - p2p event
* @vdev_id: Vdev id
* @roc_event: RoC event
* @cookie: Cookie which is given to supplicant for this roc req
* @chan: Chan for which this RoC has been requested
* @duration: Duration for the RoC
*/
struct p2p_event {
uint32_t vdev_id;
enum p2p_roc_event roc_event;
uint64_t cookie;
uint32_t chan;
uint32_t duration;
};
/**
* struct p2p_rx_mgmt_frame - rx mgmt frame structure
* @frame_len: Frame length
* @rx_chan: RX channel
* @vdev_id: Vdev id
* @frm_type: Frame type
* @rx_rssi: RX rssi
* @buf: Buffer address
*/
struct p2p_rx_mgmt_frame {
uint32_t frame_len;
uint32_t rx_chan;
uint32_t vdev_id;
uint32_t frm_type;
uint32_t rx_rssi;
uint8_t buf[1];
};
/**
* struct p2p_tx_cnf - tx confirm structure
* @vdev_id: Vdev id
* @action_cookie: TX cookie for this action frame
* @buf_len: Frame length
* @status: TX status
* @buf: Buffer address
*/
struct p2p_tx_cnf {
uint32_t vdev_id;
uint64_t action_cookie;
uint32_t buf_len;
uint32_t status;
uint8_t *buf;
};
/**
* struct p2p_mgmt_tx - p2p mgmt tx structure
* @vdev_id: Vdev id
* @chan: Chan for which this RoC has been requested
* @wait: Duration for the RoC
* @len: Length of tx buffer
* @no_cck: Required cck or not
* @dont_wait_for_ack: Wait for ack or not
* @off_chan: Off channel tx or not
* @buf: TX buffer
*/
struct p2p_mgmt_tx {
uint32_t vdev_id;
uint32_t chan;
uint32_t wait;
uint32_t len;
uint32_t no_cck;
uint32_t dont_wait_for_ack;
uint32_t off_chan;
const uint8_t *buf;
};
/**
* struct p2p_set_mac_filter
* @vdev_id: Vdev id
* @mac: mac addr
* @freq: frequency
* @set: set or clear
*/
struct p2p_set_mac_filter {
uint32_t vdev_id;
uint8_t mac[QDF_MAC_ADDR_SIZE];
uint32_t freq;
bool set;
};
/**
* struct p2p_set_mac_filter_evt
* @vdev_id: Vdev id
* @status: target reported result of set mac addr filter
*/
struct p2p_set_mac_filter_evt {
uint32_t vdev_id;
uint32_t status;
};
/**
* struct p2p_ps_config
* @vdev_id: Vdev id
* @opp_ps: Opportunistic power save
* @ct_window: CT window
* @count: Count
* @duration: Duration
* @interval: Interval
* @single_noa_duration: Single shot noa duration
* @ps_selection: power save selection
*/
struct p2p_ps_config {
uint32_t vdev_id;
uint32_t opp_ps;
uint32_t ct_window;
uint32_t count;
uint32_t duration;
uint32_t interval;
uint32_t single_noa_duration;
uint32_t ps_selection;
};
/**
* struct p2p_lo_start - p2p listen offload start
* @vdev_id: Vdev id
* @ctl_flags: Control flag
* @freq: P2P listen frequency
* @period: Listen offload period
* @interval: Listen offload interval
* @count: Number listen offload intervals
* @dev_types_len: Device types length
* @probe_resp_len: Probe response template length
* @device_types: Device types
* @probe_resp_tmplt: Probe response template
*/
struct p2p_lo_start {
uint32_t vdev_id;
uint32_t ctl_flags;
uint32_t freq;
uint32_t period;
uint32_t interval;
uint32_t count;
uint32_t dev_types_len;
uint32_t probe_resp_len;
uint8_t *device_types;
uint8_t *probe_resp_tmplt;
};
/**
* struct p2p_lo_event
* @vdev_id: vdev id
* @reason_code: reason code
*/
struct p2p_lo_event {
uint32_t vdev_id;
uint32_t reason_code;
};
/**
* struct noa_descriptor - noa descriptor
* @type_count: 255: continuous schedule, 0: reserved
* @duration: Absent period duration in micro seconds
* @interval: Absent period interval in micro seconds
* @start_time: 32 bit tsf time when in starts
*/
struct noa_descriptor {
uint32_t type_count;
uint32_t duration;
uint32_t interval;
uint32_t start_time;
};
/**
* struct p2p_noa_info - p2p noa information
* @index: identifies instance of NOA su element
* @opps_ps: opps ps state of the AP
* @ct_window: ct window in TUs
* @vdev_id: vdev id
* @num_descriptors: number of NOA descriptors
* @noa_desc: noa descriptors
*/
struct p2p_noa_info {
uint32_t index;
uint32_t opps_ps;
uint32_t ct_window;
uint32_t vdev_id;
uint32_t num_desc;
struct noa_descriptor noa_desc[P2P_MAX_NOA_DESC];
};
/**
* struct p2p_protocol_callbacks - callback to non-converged driver
* @is_mgmt_protected: func to get 11w mgmt protection status
*/
struct p2p_protocol_callbacks {
bool (*is_mgmt_protected)(uint32_t vdev_id, const uint8_t *peer_addr);
};
#endif /* _WLAN_P2P_PUBLIC_STRUCT_H_ */

208
p2p/dispatcher/inc/wlan_p2p_tgt_api.h Normale Datei
Datei anzeigen

@@ -0,0 +1,208 @@
/*
* 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: Contains p2p south bound interface definitions
*/
#ifndef _WLAN_P2P_TGT_API_H_
#define _WLAN_P2P_TGT_API_H_
#include <qdf_types.h>
#include <qdf_nbuf.h>
struct scan_event;
struct wlan_objmgr_psoc;
struct wlan_objmgr_peer;
struct p2p_noa_info;
struct p2p_lo_event;
struct mgmt_rx_event_params;
enum mgmt_frame_type;
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
/**
* tgt_p2p_lo_event_cb() - Listen offload stop request
* @psoc: soc object
* @event_info: lo stop event buffer
*
* This function gets called from target interface.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_lo_event_cb(struct wlan_objmgr_psoc *psoc,
struct p2p_lo_event *event_info);
/**
* 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_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);
#else
static inline QDF_STATUS tgt_p2p_register_lo_ev_handler(
struct wlan_objmgr_psoc *psoc)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS tgt_p2p_unregister_lo_ev_handler(
struct wlan_objmgr_psoc *psoc)
{
return QDF_STATUS_SUCCESS;
}
#endif
/**
* tgt_p2p_register_macaddr_rx_filter_evt_handler() - register add mac rx
* filter status event
* @psoc: soc object
* @register: register or unregister
*
* p2p tgt api to register add mac rx filter status event
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_register_macaddr_rx_filter_evt_handler(
struct wlan_objmgr_psoc *psoc, bool register);
/**
* 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_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
* @event: event information
* @arg: registered arguments
*
* This function gets called from scan component when getting P2P
* scan event.
*
* Return: None
*/
void tgt_p2p_scan_event_cb(struct wlan_objmgr_vdev *vdev,
struct scan_event *event, void *arg);
/**
* tgt_p2p_mgmt_download_comp_cb() - Callback for mgmt frame tx
* complete
* @context: tx context
* @buf: buffer address
* @free: need to free or not
*
* This function gets called from mgmt tx/rx component when mgmt
* frame tx complete.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_mgmt_download_comp_cb(void *context,
qdf_nbuf_t buf, bool free);
/**
* tgt_p2p_mgmt_ota_comp_cb() - Callback for mgmt frame tx ack
* @context: tx context
* @buf: buffer address
* @status: tx status
* @tx_compl_params: tx complete parameters
*
* This function gets called from mgmt tx/rx component when getting
* mgmt frame tx ack.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_mgmt_ota_comp_cb(void *context, qdf_nbuf_t buf,
uint32_t status, void *tx_compl_params);
/**
* tgt_p2p_mgmt_frame_rx_cb() - Callback for rx mgmt frame
* @psoc: soc context
* @peer: peer context
* @buf: rx buffer
* @mgmt_rx_params: mgmt rx parameters
* @frm_type: frame type
*
* This function gets called from mgmt tx/rx component when rx mgmt
* frame.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
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);
/**
* tgt_p2p_noa_event_cb() - Callback for noa event
* @psoc: soc object
* @event_info: noa event information
*
* This function gets called from target interface.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS tgt_p2p_noa_event_cb(struct wlan_objmgr_psoc *psoc,
struct p2p_noa_info *event_info);
/**
* tgt_p2p_add_mac_addr_status_event_cb() - Callback for set mac addr filter evt
* @psoc: soc object
* @event_info: event information type of p2p_set_mac_filter_evt
*
* This function gets called from target interface.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS
tgt_p2p_add_mac_addr_status_event_cb(
struct wlan_objmgr_psoc *psoc,
struct p2p_set_mac_filter_evt *event_info);
#endif /* _WLAN_P2P_TGT_API_H_ */

411
p2p/dispatcher/inc/wlan_p2p_ucfg_api.h Normale Datei
Datei anzeigen

@@ -0,0 +1,411 @@
/*
* 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: Contains p2p north bound interface definitions
*/
#ifndef _WLAN_P2P_UCFG_API_H_
#define _WLAN_P2P_UCFG_API_H_
#include <qdf_types.h>
struct wlan_objmgr_psoc;
struct p2p_roc_req;
struct p2p_event;
struct p2p_rx_mgmt_frame;
struct p2p_tx_cnf;
struct p2p_mgmt_tx;
struct p2p_ps_config;
struct p2p_lo_start;
struct p2p_lo_event;
/**
* p2p_rx_callback() - Callback for rx mgmt frame
* @user_data: user data associated to this rx mgmt frame.
* @rx_frame: RX mgmt frame
*
* This callback will be used to give rx frames to hdd.
*
* Return: None
*/
typedef void (*p2p_rx_callback)(void *user_data,
struct p2p_rx_mgmt_frame *rx_frame);
/**
* p2p_action_tx_cnf_callback() - Callback for tx confirmation
* @user_data: user data associated to this tx confirmation
* @tx_cnf: tx confirmation information
*
* This callback will be used to give tx mgmt frame confirmation to
* hdd.
*
* Return: None
*/
typedef void (*p2p_action_tx_cnf_callback)(void *user_data,
struct p2p_tx_cnf *tx_cnf);
/**
* p2p_lo_event_callback() - Callback for listen offload event
* @user_data: user data associated to this lo event
* @p2p_lo_event: listen offload event information
*
* This callback will be used to give listen offload event to hdd.
*
* Return: None
*/
typedef void (*p2p_lo_event_callback)(void *user_data,
struct p2p_lo_event *p2p_lo_event);
/**
* p2p_event_callback() - Callback for P2P event
* @user_data: user data associated to this p2p event
* @p2p_event: p2p event information
*
* This callback will be used to give p2p event to hdd.
*
* Return: None
*/
typedef void (*p2p_event_callback)(void *user_data,
struct p2p_event *p2p_event);
/**
* struct p2p_start_param - p2p soc start parameters. Below callbacks
* will be registered by the HDD
* @rx_callback: Function pointer to hdd rx callback. This
* function will be used to give rx frames to hdd
* @rx_cb_data: RX callback user data
* @event_cb: Founction pointer to hdd p2p event callback.
* This function will be used to give p2p event
* to hdd
* @event_cb_data: Pointer to p2p event callback user data
* @tx_cnf_cb: Function pointer to hdd tx confirm callback.
* This function will be used to give tx confirm
* to hdd
* @tx_cnf_cb_data: Pointer to p2p tx confirm callback user data
* @lo_event_cb: Founction pointer to p2p listen offload
* callback. This function will be used to give
* listen offload stopped event to hdd
* @lo_event_cb_data: Pointer to p2p listen offload callback user data
*/
struct p2p_start_param {
p2p_rx_callback rx_cb;
void *rx_cb_data;
p2p_event_callback event_cb;
void *event_cb_data;
p2p_action_tx_cnf_callback tx_cnf_cb;
void *tx_cnf_cb_data;
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
p2p_lo_event_callback lo_event_cb;
void *lo_event_cb_data;
#endif
};
/**
* ucfg_p2p_init() - P2P component initialization
*
* This function gets called when dispatcher initializing.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_init(void);
/**
* ucfg_p2p_deinit() - P2P component de-init
*
* This function gets called when dispatcher de-init.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_deinit(void);
/**
* ucfg_p2p_psoc_open() - Open P2P component
* @soc: soc context
*
* This function gets called when dispatcher opening.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_psoc_open(struct wlan_objmgr_psoc *soc);
/**
* ucfg_p2p_psoc_close() - Close P2P component
* @soc: soc context
*
* This function gets called when dispatcher closing.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_psoc_close(struct wlan_objmgr_psoc *soc);
/**
* ucfg_p2p_psoc_start() - Start P2P component
* @soc: soc context
* @req: P2P start parameters
*
* This function gets called when up layer starting up.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_psoc_start(struct wlan_objmgr_psoc *soc,
struct p2p_start_param *req);
/**
* ucfg_p2p_psoc_stop() - Stop P2P component
* @soc: soc context
*
* This function gets called when up layer exit.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_psoc_stop(struct wlan_objmgr_psoc *soc);
/**
* ucfg_p2p_roc_req() - Roc request
* @soc: soc context
* @roc_req: Roc request parameters
* @cookie: return cookie to caller
*
* This function delivers roc request to P2P component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_roc_req(struct wlan_objmgr_psoc *soc,
struct p2p_roc_req *roc_req, uint64_t *cookie);
/**
* ucfg_p2p_roc_cancel_req() - Cancel roc request
* @soc: soc context
* @cookie: Find out the roc request by cookie
*
* This function delivers cancel roc request to P2P component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_roc_cancel_req(struct wlan_objmgr_psoc *soc,
uint64_t cookie);
/**
* ucfg_p2p_cleanup_roc_by_vdev() - Cleanup roc request by vdev
* @vdev: pointer to vdev object
*
* This function call P2P API to cleanup roc request by vdev
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_cleanup_roc_by_vdev(struct wlan_objmgr_vdev *vdev);
/**
* ucfg_p2p_cleanup_roc_by_poc() - Cleanup roc request by psoc
* @psoc: pointer to psoc object
*
* This function call P2P API to cleanup roc request by psoc
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_cleanup_roc_by_psoc(struct wlan_objmgr_psoc *psoc);
/**
* ucfg_p2p_cleanup_tx_by_vdev() - Cleanup tx request by vdev
* @vdev: pointer to vdev object
*
* This function call P2P API to cleanup tx action frame request by vdev
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_cleanup_tx_by_vdev(struct wlan_objmgr_vdev *vdev);
/**
* ucfg_p2p_cleanup_tx_by_poc() - Cleanup tx request by psoc
* @psoc: pointer to psoc object
*
* This function call P2P API to cleanup tx action frame request by psoc
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_cleanup_tx_by_psoc(struct wlan_objmgr_psoc *psoc);
/**
* ucfg_p2p_mgmt_tx() - Mgmt frame tx request
* @soc: soc context
* @mgmt_frm: TX mgmt frame parameters
* @cookie: Return the cookie to caller
*
* This function delivers mgmt frame tx request to P2P component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_mgmt_tx(struct wlan_objmgr_psoc *soc,
struct p2p_mgmt_tx *mgmt_frm, uint64_t *cookie);
/**
* ucfg_p2p_mgmt_tx_cancel() - Cancel mgmt frame tx request
* @soc: soc context
* @vdev: vdev object
* @cookie: Find out the mgmt tx request by cookie
*
* This function delivers cancel mgmt frame tx request request to P2P
* component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_mgmt_tx_cancel(struct wlan_objmgr_psoc *soc,
struct wlan_objmgr_vdev *vdev, uint64_t cookie);
/**
* ucfg_p2p_set_ps() - P2P set power save
* @soc: soc context
* @ps_config: power save configure
*
* This function delivers p2p power save request to P2P component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_set_ps(struct wlan_objmgr_psoc *soc,
struct p2p_ps_config *ps_config);
#ifdef FEATURE_P2P_LISTEN_OFFLOAD
/**
* ucfg_p2p_lo_start() - Listen offload start request
* @soc: soc context
* @p2p_lo_start: lo start parameters
*
* This function delivers listen offload start request to P2P
* component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_lo_start(struct wlan_objmgr_psoc *soc,
struct p2p_lo_start *p2p_lo_start);
/**
* ucfg_p2p_lo_stop() - Listen offload stop request
* @soc: soc context
* @vdev_id: vdev id
*
* This function delivers listen offload stop request to P2P component.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_lo_stop(struct wlan_objmgr_psoc *soc,
uint32_t vdev_id);
#endif
/**
* p2p_peer_authorized() - Process peer authorized event
* @vdev: vdev structure to which peer is associated
* @mac_addr: peer mac address
*
* This function handles disables noa whenever a legacy station
* complete 4-way handshake after association.
*
* Return: void
*/
void p2p_peer_authorized(struct wlan_objmgr_vdev *vdev, uint8_t *mac_addr);
/**
* ucfg_p2p_set_noa() - Disable/Enable NOA
* @soc: soc context
* @vdev_id: vdev id
* @disable_noa: TRUE - Disable NoA, FALSE - Enable NoA
*
* This function send wmi command to enable / disable NoA.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_set_noa(struct wlan_objmgr_psoc *soc,
uint32_t vdev_id, bool disable_noa);
/**
* ucfg_p2p_check_random_mac() - check random mac addr or not
* @soc: soc context
* @vdev_id: vdev id
* @random_mac_addr: mac addr to be checked
*
* This function check the input addr is random mac addr or not for vdev.
*
* Return: true if addr is random mac address else false.
*/
bool ucfg_p2p_check_random_mac(struct wlan_objmgr_psoc *soc, uint32_t vdev_id,
uint8_t *random_mac_addr);
/**
* ucfg_p2p_register_callbacks() - register p2p callbacks
* @soc: soc context
* @cb_obj: p2p_protocol_callbacks struct
*
* This function registers lim callbacks to p2p components to provide
* protocol information.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_register_callbacks(struct wlan_objmgr_psoc *soc,
struct p2p_protocol_callbacks *cb_obj);
/**
* ucfg_p2p_status_scan() - Show P2P connection status when scanning
* @vdev: vdev context
*
* This function shows P2P connection status when scanning.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_status_scan(struct wlan_objmgr_vdev *vdev);
/**
* ucfg_p2p_status_connect() - Update P2P connection status
* @vdev: vdev context
*
* Updates P2P connection status by up layer when connecting.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_status_connect(struct wlan_objmgr_vdev *vdev);
/**
* ucfg_p2p_status_disconnect() - Update P2P connection status
* @vdev: vdev context
*
* Updates P2P connection status by up layer when disconnecting.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_status_disconnect(struct wlan_objmgr_vdev *vdev);
/**
* ucfg_p2p_status_start_bss() - Update P2P connection status
* @vdev: vdev context
*
* Updates P2P connection status by up layer when starting bss.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_status_start_bss(struct wlan_objmgr_vdev *vdev);
/**
* ucfg_p2p_status_stop_bss() - Update P2P connection status
* @vdev: vdev context
*
* Updates P2P connection status by up layer when stopping bss.
*
* Return: QDF_STATUS_SUCCESS - in case of success
*/
QDF_STATUS ucfg_p2p_status_stop_bss(struct wlan_objmgr_vdev *vdev);
#endif /* _WLAN_P2P_UCFG_API_H_ */

105
p2p/dispatcher/src/wlan_p2p_cfg.c Normale Datei
Datei anzeigen

@@ -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
p2p/dispatcher/src/wlan_p2p_tgt_api.c Normale Datei
Datei anzeigen

@@ -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
p2p/dispatcher/src/wlan_p2p_ucfg_api.c Normale Datei
Datei anzeigen

@@ -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);
}