qcacmn: Defines os and target interfaces

Defines API and callbacks of os interface for P2P component. At the
same time, defines API of target interface.

Change-Id: Ice1c86ecba1f2410d965d9f84923589f229a1864
CRs-Fixed: 2013763

os_if/linux/p2p/inc/wlan_cfg80211_p2p.h

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2017 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: declares P2P functions interfacing with linux kernel
+ */
+
+#ifndef _WLAN_CFG80211_P2P_H_
+#define _WLAN_CFG80211_P2P_H_
+
+#include <qdf_types.h>
+
+struct wlan_objmgr_psoc;
+struct wlan_objmgr_vdev;
+struct ieee80211_channel;
+
+/**
+ * wlan_p2p_start() - start p2p component
+ * @psoc: soc object
+ *
+ * This function used to start P2P component and register events.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS wlan_p2p_start(struct wlan_objmgr_psoc *psoc);
+
+/**
+ * wlan_p2p_stop() - stop p2p component
+ * @psoc: soc object
+ *
+ * This function used to stop P2P component and unregister events.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS wlan_p2p_stop(struct wlan_objmgr_psoc *psoc);
+
+/**
+ * wlan_cfg80211_roc() - API to process cfg80211 roc request
+ * @vdev: Pointer to vdev object
+ * @chan: Pointer to channel
+ * @duration: Duration for this roc request
+ * @cookie: Pointer to return cookie to up layer
+ *
+ * API to trigger remain on channel request. It returns cookie
+ * as the identifier of roc.
+ *
+ * Return: 0 for success, non zero for failure
+ */
+int wlan_cfg80211_roc(struct wlan_objmgr_vdev *vdev,
+	struct ieee80211_channel *chan, uint32_t duration,
+	uint64_t *cookie);
+
+/**
+ * wlan_cfg80211_cancel_roc() - API to process cfg80211 cancel remain
+ * on channel request
+ * @vdev: Pointer to vdev object
+ * @cookie: Find out the roc request by cookie
+ *
+ * API to trigger cancel remain on channel request.
+ *
+ * Return: 0 for success, non zero for failure
+ */
+int wlan_cfg80211_cancel_roc(struct wlan_objmgr_vdev *vdev,
+	uint64_t cookie);
+
+/**
+ * wlan_cfg80211_mgmt_tx() - API to process cfg80211 mgmt tx request
+ * @vdev: Pointer to vdev object
+ * @chan: Pointer to channel
+ * @wait: wait time for this mgmt tx request
+ * @buf: TX buffer
+ * @len: Length of tx buffer
+ * @no_cck: Required cck or not
+ * @dont_wait_for_ack: Wait for ack or not
+ * @cookie: Return the cookie to caller
+ *
+ * API to trigger mgmt frame tx request. It returns cookie as the
+ * identifier of this tx.
+ *
+ * Return: 0 for success, non zero for failure
+ */
+int wlan_cfg80211_mgmt_tx(struct wlan_objmgr_vdev *vdev,
+	struct ieee80211_channel *chan, bool offchan, uint32_t wait,
+	const uint8_t *buf, uint32_t len, bool no_cck,
+	bool dont_wait_for_ack, uint64_t *cookie);
+
+/**
+ * wlan_cfg80211_mgmt_tx_cancel() - API to process cfg80211 cancel to
+ * wait mgmt tx
+ * @vdev: Pointer to vdev object
+ * @cookie: Find out the mgmt tx request by cookie
+ *
+ * API to trigger cancel mgmt frame tx request.
+ *
+ * Return: 0 for success, non zero for failure
+ */
+int wlan_cfg80211_mgmt_tx_cancel(struct wlan_objmgr_vdev *vdev,
+		uint64_t cookie);
+
+#endif /* _WLAN_CFG80211_P2P_H_ */

os_if/linux/p2p/src/wlan_cfg80211_p2p.c

@@ -0,0 +1,457 @@
+/*
+ * Copyright (c) 2017 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 driver functions interfacing with linux kernel
+ */
+
+#include <qdf_util.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_public_struct.h>
+#include <wlan_p2p_ucfg_api.h>
+#include <wlan_utility.h>
+#include <wlan_osif_priv.h>
+#include "wlan_cfg80211.h"
+#include "wlan_cfg80211_p2p.h"
+
+#define MAX_NO_OF_2_4_CHANNELS 14
+
+/**
+ * wlan_p2p_rx_callback() - Callback for rx mgmt frame
+ * @user_data: pointer to soc object
+ * @rx_frame: RX mgmt frame information
+ *
+ * This callback will be used to rx frames in os interface.
+ *
+ * Return: None
+ */
+static void wlan_p2p_rx_callback(void *user_data,
+	struct p2p_rx_mgmt_frame *rx_frame)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_osif_priv *osif_priv;
+	struct wireless_dev *wdev;
+	uint16_t freq;
+
+	cfg80211_debug("user data:%p, vdev id:%d, rssi:%d, buf:%p, len:%d",
+		user_data, rx_frame->vdev_id, rx_frame->rx_rssi,
+		rx_frame->buf, rx_frame->frame_len);
+
+	psoc = user_data;
+	if (!psoc) {
+		cfg80211_err("psoc is null");
+		return;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+		rx_frame->vdev_id, WLAN_P2P_ID);
+	if (!vdev) {
+		cfg80211_err("vdev is null");
+		return;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	osif_priv = wlan_vdev_get_ospriv(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!osif_priv) {
+		cfg80211_err("osif_priv is null");
+		goto fail;
+	}
+
+	wdev = osif_priv->wdev;
+	if (!wdev) {
+		cfg80211_err("wdev is null");
+		goto fail;
+	}
+
+	if (rx_frame->rx_chan <= MAX_NO_OF_2_4_CHANNELS)
+		freq = ieee80211_channel_to_frequency(
+			rx_frame->rx_chan, NL80211_BAND_2GHZ);
+	else
+		freq = ieee80211_channel_to_frequency(
+			rx_frame->rx_chan, NL80211_BAND_5GHZ);
+
+	cfg80211_notice("Indicate frame over nl80211, vdev id:%d, idx:%d",
+		   rx_frame->vdev_id, wdev->netdev->ifindex);
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 18, 0))
+	cfg80211_rx_mgmt(wdev, freq, rx_frame->rx_rssi * 100,
+		rx_frame->buf, rx_frame->frame_len,
+		NL80211_RXMGMT_FLAG_ANSWERED);
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0))
+	cfg80211_rx_mgmt(wdev, freq, rx_frame->rx_rssi * 100,
+		rx_frame->buf, rx_frame->frame_len,
+		NL80211_RXMGMT_FLAG_ANSWERED, GFP_ATOMIC);
+#else
+	cfg80211_rx_mgmt(wdev, freq, rx_frame->rx_rssi * 100,
+		rx_frame->buf, rx_frame->frame_len, GFP_ATOMIC);
+#endif /* LINUX_VERSION_CODE */
+fail:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
+}
+
+/**
+ * wlan_p2p_action_tx_cnf_callback() - Callback for tx confirmation
+ * @user_data: pointer to soc object
+ * @tx_cnf: tx confirmation information
+ *
+ * This callback will be used to give tx mgmt frame confirmation to
+ * os interface.
+ *
+ * Return: None
+ */
+static void wlan_p2p_action_tx_cnf_callback(void *user_data,
+	struct p2p_tx_cnf *tx_cnf)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_osif_priv *osif_priv;
+	struct wireless_dev *wdev;
+
+	cfg80211_info("user data:%p, action cookie:%llx, buf:%p, len:%d, tx status:%d",
+		user_data, tx_cnf->action_cookie, tx_cnf->buf,
+		tx_cnf->buf_len, tx_cnf->status);
+
+	psoc = user_data;
+	if (!psoc) {
+		cfg80211_err("psoc is null");
+		return;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+		tx_cnf->vdev_id, WLAN_P2P_ID);
+	if (!vdev) {
+		cfg80211_err("vdev is null");
+		return;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	osif_priv = wlan_vdev_get_ospriv(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!osif_priv) {
+		cfg80211_err("osif_priv is null");
+		goto fail;
+	}
+
+	wdev = osif_priv->wdev;
+	if (!wdev) {
+		cfg80211_err("wireless dev is null");
+		goto fail;
+	}
+
+	cfg80211_mgmt_tx_status(
+		wdev,
+		tx_cnf->action_cookie,
+		tx_cnf->buf, tx_cnf->buf_len,
+		(bool)tx_cnf->status, GFP_KERNEL);
+fail:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
+}
+
+/**
+ * wlan_p2p_lo_event_callback() - Callback for listen offload event
+ * @user_data: pointer to soc object
+ * @p2p_lo_event: listen offload event information
+ *
+ * This callback will be used to give listen offload event to os interface.
+ *
+ * Return: None
+ */
+static void wlan_p2p_lo_event_callback(void *user_data,
+	struct p2p_lo_event *p2p_lo_event)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_osif_priv *osif_priv;
+	struct wireless_dev *wdev;
+	struct sk_buff *vendor_event;
+
+	cfg80211_debug("user data:%p, vdev id:%d, reason code:%d",
+		user_data, p2p_lo_event->vdev_id,
+		p2p_lo_event->reason_code);
+
+	psoc = user_data;
+	if (!psoc) {
+		cfg80211_err("psoc is null");
+		return;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+		p2p_lo_event->vdev_id, WLAN_P2P_ID);
+	if (!vdev) {
+		cfg80211_err("vdev is null");
+		return;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	osif_priv = wlan_vdev_get_ospriv(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!osif_priv) {
+		cfg80211_err("osif_priv is null");
+		goto fail;
+	}
+
+	wdev = osif_priv->wdev;
+	if (!wdev) {
+		cfg80211_err("wireless dev is null");
+		goto fail;
+	}
+
+	vendor_event = cfg80211_vendor_event_alloc(wdev->wiphy, NULL,
+			sizeof(uint32_t) + NLMSG_HDRLEN,
+			QCA_NL80211_VENDOR_SUBCMD_P2P_LO_EVENT_INDEX,
+			GFP_KERNEL);
+	if (!vendor_event) {
+		cfg80211_err("cfg80211_vendor_event_alloc failed");
+		goto fail;
+	}
+
+	if (nla_put_u32(vendor_event,
+		QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_STOP_REASON,
+		p2p_lo_event->reason_code)) {
+		cfg80211_err("nla put failed");
+		kfree_skb(vendor_event);
+		goto fail;
+	}
+
+	cfg80211_vendor_event(vendor_event, GFP_KERNEL);
+
+fail:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
+}
+
+/**
+ * wlan_p2p_event_callback() - Callback for P2P event
+ * @user_data: pointer to soc object
+ * @p2p_event: p2p event information
+ *
+ * This callback will be used to give p2p event to os interface.
+ *
+ * Return: None
+ */
+static void wlan_p2p_event_callback(void *user_data,
+	struct p2p_event *p2p_event)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+	struct ieee80211_channel *chan;
+	struct vdev_osif_priv *osif_priv;
+	struct wireless_dev *wdev;
+
+	cfg80211_debug("user data:%p, vdev id:%d, event type:%d",
+		user_data, p2p_event->vdev_id, p2p_event->roc_event);
+
+	psoc = user_data;
+	if (!psoc) {
+		cfg80211_err("psoc is null");
+		return;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+		p2p_event->vdev_id, WLAN_P2P_ID);
+	if (!vdev) {
+		cfg80211_err("vdev is null");
+		return;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	osif_priv = wlan_vdev_get_ospriv(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!osif_priv) {
+		cfg80211_err("osif_priv is null");
+		goto fail;
+	}
+
+	wdev = osif_priv->wdev;
+	if (!wdev) {
+		cfg80211_err("wireless dev is null");
+		goto fail;
+	}
+
+	chan = __ieee80211_get_channel(wdev->wiphy,
+			wlan_chan_to_freq(p2p_event->chan));
+	if (p2p_event->roc_event == ROC_EVENT_READY_ON_CHAN) {
+		cfg80211_ready_on_channel(wdev,
+			p2p_event->cookie, chan,
+			p2p_event->duration, GFP_KERNEL);
+	} else if (p2p_event->roc_event == ROC_EVENT_COMPLETED) {
+		cfg80211_remain_on_channel_expired(wdev,
+			p2p_event->cookie, chan, GFP_KERNEL);
+	} else {
+		cfg80211_err("Invalid p2p event");
+	}
+
+fail:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_P2P_ID);
+}
+
+QDF_STATUS wlan_p2p_start(struct wlan_objmgr_psoc *psoc)
+{
+	struct p2p_start_param start_param;
+
+	if (!psoc) {
+		cfg80211_err("psoc null");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	start_param.rx_cb = wlan_p2p_rx_callback;
+	start_param.rx_cb_data = psoc;
+	start_param.event_cb = wlan_p2p_event_callback;
+	start_param.event_cb_data = psoc;
+	start_param.tx_cnf_cb = wlan_p2p_action_tx_cnf_callback;
+	start_param.tx_cnf_cb_data = psoc;
+	start_param.lo_event_cb = wlan_p2p_lo_event_callback;
+	start_param.lo_event_cb_data = psoc;
+
+	return ucfg_p2p_psoc_start(psoc, &start_param);
+}
+
+QDF_STATUS wlan_p2p_stop(struct wlan_objmgr_psoc *psoc)
+{
+	if (!psoc) {
+		cfg80211_err("psoc null");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	return ucfg_p2p_psoc_stop(psoc);
+}
+
+int wlan_cfg80211_roc(struct wlan_objmgr_vdev *vdev,
+	struct ieee80211_channel *chan, uint32_t duration,
+	uint64_t *cookie)
+{
+	struct p2p_roc_req roc_req;
+	struct wlan_objmgr_psoc *psoc;
+	uint8_t vdev_id;
+
+	if (!vdev) {
+		cfg80211_err("invalid vdev object");
+		return -EINVAL;
+	}
+
+	if (!chan) {
+		cfg80211_err("invalid channel");
+		return -EINVAL;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	psoc = wlan_vdev_get_psoc(vdev);
+	vdev_id = wlan_vdev_get_id(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!psoc) {
+		cfg80211_err("psoc handle is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	roc_req.chan = (uint32_t)wlan_freq_to_chan(chan->center_freq);
+	roc_req.duration = duration;
+	roc_req.vdev_id = (uint32_t)vdev_id;
+
+	return qdf_status_to_os_return(
+		ucfg_p2p_roc_req(psoc, &roc_req, cookie));
+}
+
+int wlan_cfg80211_cancel_roc(struct wlan_objmgr_vdev *vdev,
+		uint64_t cookie)
+{
+	struct wlan_objmgr_psoc *psoc;
+
+	if (!vdev) {
+		cfg80211_err("invalid vdev object");
+		return -EINVAL;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	psoc = wlan_vdev_get_psoc(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!psoc) {
+		cfg80211_err("psoc handle is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	return qdf_status_to_os_return(
+		ucfg_p2p_roc_cancel_req(psoc, cookie));
+}
+
+int wlan_cfg80211_mgmt_tx(struct wlan_objmgr_vdev *vdev,
+		struct ieee80211_channel *chan, bool offchan,
+		unsigned int wait,
+		const uint8_t *buf, uint32_t len, bool no_cck,
+		bool dont_wait_for_ack, uint64_t *cookie)
+{
+	struct p2p_mgmt_tx mgmt_tx;
+	struct wlan_objmgr_psoc *psoc;
+	uint8_t vdev_id;
+
+	if (!vdev) {
+		cfg80211_err("invalid vdev object");
+		return -EINVAL;
+	}
+
+	if (!chan) {
+		cfg80211_err("invalid channel");
+		return -EINVAL;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	psoc = wlan_vdev_get_psoc(vdev);
+	vdev_id = wlan_vdev_get_id(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!psoc) {
+		cfg80211_err("psoc handle is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	mgmt_tx.vdev_id = (uint32_t)vdev_id;
+	mgmt_tx.chan = (uint32_t)wlan_freq_to_chan(chan->center_freq);
+	mgmt_tx.wait = wait;
+	mgmt_tx.len = len;
+	mgmt_tx.no_cck = (uint32_t)no_cck;
+	mgmt_tx.dont_wait_for_ack = (uint32_t)dont_wait_for_ack;
+	mgmt_tx.buf = buf;
+
+	return qdf_status_to_os_return(
+		ucfg_p2p_mgmt_tx(psoc, &mgmt_tx, cookie));
+}
+
+int wlan_cfg80211_mgmt_tx_cancel(struct wlan_objmgr_vdev *vdev,
+	uint64_t cookie)
+{
+	struct wlan_objmgr_psoc *psoc;
+
+	if (!vdev) {
+		cfg80211_err("invalid vdev object");
+		return -EINVAL;
+	}
+
+	wlan_vdev_obj_lock(vdev);
+	psoc = wlan_vdev_get_psoc(vdev);
+	wlan_vdev_obj_unlock(vdev);
+	if (!psoc) {
+		cfg80211_err("psoc handle is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	return qdf_status_to_os_return(
+		ucfg_p2p_mgmt_tx_cancel(psoc, cookie));
+}

target_if/core/src/target_if_main.c

@@ -26,6 +26,10 @@
 #include "target_if_pmo_main.h"
 #endif
 
+#ifdef WLAN_P2P_ENABLE
+#include "target_if_p2p.h"
+#endif
+
 static struct target_if_ctx *g_target_if_ctx;
 
 struct target_if_ctx *target_if_get_ctx()
@@ -130,6 +134,10 @@ QDF_STATUS target_if_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops)
 	/* Components parallel to UMAC to register their TX-ops here */
 	target_if_pmo_register_tx_ops_req(tx_ops);
 
+#ifdef WLAN_P2P_ENABLE
+	/* Converged UMAC components to register P2P TX-ops */
+	target_if_p2p_register_tx_ops(tx_ops);
+#endif
 	return QDF_STATUS_SUCCESS;
 }
 

target_if/p2p/inc/target_if_p2p.h

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: offload lmac interface APIs for P2P
+ */
+
+#ifndef _TARGET_IF_P2P_H_
+#define _TARGET_IF_P2P_H_
+
+#include <qdf_types.h>
+
+struct wlan_objmgr_psoc;
+struct p2p_ps_config;
+struct p2p_lo_start;
+
+/**
+ * target_if_p2p_register_tx_ops() - Register P2P component TX OPS
+ * @tx_ops: lmac if transmit ops
+ *
+ * Return: None
+ */
+void target_if_p2p_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops);
+
+/**
+ * target_if_p2p_register_lo_event_handler() - Register lo event handler
+ * @psoc: soc object
+ * @arg: additional argument
+ *
+ * Target interface API to register P2P listen offload event handler.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_register_lo_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg);
+
+/**
+ * target_if_p2p_register_noa_event_handler() - Register noa event handler
+ * @psoc: soc object
+ * @arg: additional argument
+ *
+ * Target interface API to register P2P noa event handler.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_register_noa_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg);
+
+/**
+ * target_if_p2p_unregister_lo_event_handler() - Unregister lo event handler
+ * @psoc: soc object
+ * @arg: additional argument
+ *
+ * Target interface API to unregister P2P listen offload event handler.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_unregister_lo_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg);
+
+/**
+ * target_if_p2p_unregister_noa_event_handler() - Unregister noa event handler
+ * @psoc: soc object
+ * @arg: additional argument
+ *
+ * Target interface API to unregister P2P listen offload event handler.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_unregister_noa_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg);
+
+/**
+ * target_if_p2p_set_ps() - Set power save
+ * @psoc: soc object
+ * @arg: additional argument
+ *
+ * Target interface API to set power save.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_set_ps(struct wlan_objmgr_psoc *psoc,
+	struct p2p_ps_config *ps_config);
+
+/**
+ * target_if_p2p_lo_start() - Start listen offload
+ * @psoc: soc object
+ * @lo_start: lo start information
+ *
+ * Target interface API to start listen offload.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_lo_start(struct wlan_objmgr_psoc *psoc,
+	struct p2p_lo_start *lo_start);
+
+/**
+ * target_if_p2p_lo_stop() - Stop listen offload
+ * @psoc: soc object
+ * @vdev_id: vdev id
+ *
+ * Target interface API to stop listen offload.
+ *
+ * Return: QDF_STATUS_SUCCESS - in case of success
+ */
+QDF_STATUS target_if_p2p_lo_stop(struct wlan_objmgr_psoc *psoc,
+	uint32_t vdev_id);
+
+#endif /* _TARGET_IF_P2P_H_ */

target_if/p2p/src/target_if_p2p.c

@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: offload lmac interface APIs definitions for P2P
+ */
+
+#include <wmi_unified_api.h>
+#include <wlan_p2p_public_struct.h>
+#include "target_if.h"
+#include "target_if_p2p.h"
+
+static inline struct wlan_lmac_if_p2p_rx_ops *
+target_if_psoc_get_p2p_rx_ops(struct wlan_objmgr_psoc *psoc)
+{
+	return &(psoc->soc_cb.rx_ops.p2p);
+}
+
+/**
+ * target_p2p_lo_event_handler() - WMI callback for lo stop event
+ * @scn:
+ * @event_buf: event buffer
+ * @len: buffer length
+ *
+ * This function gets called from WMI when triggered wmi event
+ * wmi_p2p_lo_stop_event_id.
+ *
+ * Return: 0 - success
+ * others - failure
+ */
+static int target_p2p_lo_event_handler(ol_scn_t scn, uint8_t *data,
+	uint32_t datalen)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wmi_unified *wmi_handle;
+	struct p2p_lo_event *event_info;
+	struct wlan_lmac_if_p2p_rx_ops *p2p_rx_ops;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	target_if_info("scn:%p, data:%p, datalen:%d", scn, data, datalen);
+
+	if (!scn || !data) {
+		target_if_err("scn: 0x%p, data: 0x%p", scn, data);
+		return -EINVAL;
+	}
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("null psoc");
+		return -EINVAL;
+	}
+
+	wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc);
+	if (!wmi_handle) {
+		target_if_err("null wmi handle");
+		return -EINVAL;
+	}
+
+	event_info = qdf_mem_malloc(sizeof(*event_info));
+	if (!event_info) {
+		target_if_err("Failed to allocate p2p lo event");
+		return -ENOMEM;
+	}
+
+	/*TODO, extract wmi lo stop event */
+
+	p2p_rx_ops = target_if_psoc_get_p2p_rx_ops(psoc);
+	if (p2p_rx_ops->lo_ev_handler) {
+		status = p2p_rx_ops->lo_ev_handler(psoc, event_info);
+		target_if_debug("call lo event handler, status:%d",
+			status);
+	}
+
+	return qdf_status_to_os_return(status);
+}
+
+/**
+ * target_p2p_noa_event_handler() - WMI callback for noa event
+ * @scn:
+ * @event_buf: event buffer
+ * @len: buffer length
+ *
+ * This function gets called from WMI when triggered WMI event
+ * wmi_p2p_noa_event_id.
+ *
+ * Return: 0 - success
+ * others - failure
+ */
+static int target_p2p_noa_event_handler(ol_scn_t scn, uint8_t *data,
+	uint32_t datalen)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wmi_unified *wmi_handle;
+	struct p2p_noa_info *event_info;
+	struct wlan_lmac_if_p2p_rx_ops *p2p_rx_ops;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	target_if_info("scn:%p, data:%p, datalen:%d", scn, data, datalen);
+
+	if (!scn || !data) {
+		target_if_err("scn: 0x%p, data: 0x%p", scn, data);
+		return -EINVAL;
+	}
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("null psoc");
+		return -EINVAL;
+	}
+
+	wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc);
+	if (!wmi_handle) {
+		target_if_err("null wmi handle");
+		return -EINVAL;
+	}
+
+	event_info = qdf_mem_malloc(sizeof(*event_info));
+	if (!event_info) {
+		target_if_err("Failed to allocate p2p noa information");
+		return -ENOMEM;
+	}
+
+	/*TODO, extract wmi noa event */
+
+	p2p_rx_ops = target_if_psoc_get_p2p_rx_ops(psoc);
+	if (p2p_rx_ops->noa_ev_handler) {
+		status = p2p_rx_ops->noa_ev_handler(psoc, event_info);
+		target_if_debug("call noa event handler, status:%d",
+			status);
+	}
+
+	return qdf_status_to_os_return(status);
+}
+
+QDF_STATUS target_if_p2p_register_lo_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg)
+{
+	int status;
+	wmi_unified_t wmi_handle = wlan_psoc_get_tgt_if_handle(psoc);
+
+	target_if_info("psoc:%p, arg:%p", psoc, arg);
+
+	if (!wmi_handle) {
+		target_if_err("Invalid wmi handle");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = wmi_unified_register_event_handler(wmi_handle,
+		wmi_p2p_lo_stop_event_id, target_p2p_lo_event_handler,
+		WMI_RX_UMAC_CTX);
+
+	target_if_info("wmi register lo event handle, status:%d",
+		status);
+
+	return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
+}
+
+QDF_STATUS target_if_p2p_register_noa_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg)
+{
+	int status;
+	wmi_unified_t wmi_handle = wlan_psoc_get_tgt_if_handle(psoc);
+
+	target_if_info("psoc:%p, arg:%p", psoc, arg);
+
+	if (!wmi_handle) {
+		target_if_err("Invalid wmi handle");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = wmi_unified_register_event_handler(wmi_handle,
+		wmi_p2p_noa_event_id, target_p2p_noa_event_handler,
+		WMI_RX_UMAC_CTX);
+
+	target_if_info("wmi register noa event handle, status:%d",
+		status);
+
+	return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
+}
+
+QDF_STATUS target_if_p2p_unregister_lo_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg)
+{
+	int status;
+	wmi_unified_t wmi_handle = wlan_psoc_get_tgt_if_handle(psoc);
+
+	target_if_info("psoc:%p, arg:%p", psoc, arg);
+
+	if (!wmi_handle) {
+		target_if_err("Invalid wmi handle");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = wmi_unified_unregister_event_handler(wmi_handle,
+		wmi_p2p_lo_stop_event_id);
+
+	target_if_info("wmi unregister lo event handle, status:%d",
+		status);
+
+	return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
+}
+
+QDF_STATUS target_if_p2p_unregister_noa_event_handler(
+	struct wlan_objmgr_psoc *psoc, void *arg)
+{
+	int status;
+	wmi_unified_t wmi_handle = wlan_psoc_get_tgt_if_handle(psoc);
+
+	target_if_info("psoc:%p, arg:%p", psoc, arg);
+
+	if (!wmi_handle) {
+		target_if_err("Invalid wmi handle");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = wmi_unified_unregister_event_handler(wmi_handle,
+		wmi_p2p_noa_event_id);
+
+	target_if_info("wmi unregister noa event handle, status:%d",
+		status);
+
+	return status == 0 ? QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
+}
+
+QDF_STATUS target_if_p2p_set_ps(struct wlan_objmgr_psoc *psoc,
+	struct p2p_ps_config *ps_config)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS target_if_p2p_lo_start(struct wlan_objmgr_psoc *psoc,
+	struct p2p_lo_start *lo_start)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS target_if_p2p_lo_stop(struct wlan_objmgr_psoc *psoc,
+	uint32_t vdev_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+void target_if_p2p_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops)
+{
+	struct wlan_lmac_if_p2p_tx_ops *p2p_tx_ops;
+
+	if (!tx_ops) {
+		target_if_err("lmac tx_ops is null");
+		return;
+	}
+
+	p2p_tx_ops = &tx_ops->p2p;
+	p2p_tx_ops->set_ps = target_if_p2p_set_ps;
+	p2p_tx_ops->lo_start = target_if_p2p_lo_start;
+	p2p_tx_ops->lo_stop = target_if_p2p_lo_stop;
+	p2p_tx_ops->reg_lo_ev_handler =
+			target_if_p2p_register_lo_event_handler;
+	p2p_tx_ops->reg_noa_ev_handler =
+			target_if_p2p_register_noa_event_handler;
+	p2p_tx_ops->unreg_lo_ev_handler =
+			target_if_p2p_unregister_lo_event_handler;
+	p2p_tx_ops->unreg_noa_ev_handler =
+			target_if_p2p_unregister_noa_event_handler;
+}

umac/cmn_services/obj_mgr/inc/wlan_objmgr_cmn.h

@@ -166,6 +166,7 @@ typedef void (*wlan_objmgr_peer_status_handler)(
  * @WLAN_LEGACY_SME_ID:         Legacy SME operations
  * @WLAN_SCAN_ID:               scan operations
  * @WLAN_DFS_ID:                DFS operations
+ * @WLAN_P2P_ID:                P2P operations
  * @WLAN_REF_ID_MAX:            Max id used to generate ref count tracking array
  */
 typedef enum {
@@ -184,6 +185,7 @@ typedef enum {
 	WLAN_SCAN_ID          = 12,
 	WLAN_WIFI_POS_ID      = 13,
 	WLAN_DFS_ID           = 14,
+	WLAN_P2P_ID           = 15,
 	WLAN_REF_ID_MAX,
 } wlan_objmgr_ref_dbgid;
 

umac/cmn_services/utils/inc/wlan_utility.h

@@ -41,4 +41,12 @@ uint32_t wlan_chan_to_freq(uint8_t chan);
  */
 bool wlan_is_dsrc_channel(uint16_t center_freq);
 
+/**
+ * wlan_freq_to_chan() - converts frequency to channel
+ * @freq: frequency
+ *
+ * Return: channel of frequency
+ */
+uint8_t wlan_freq_to_chan(uint32_t freq);
+
 #endif /* _WLAN_UTILITY_H_ */

umac/cmn_services/utils/src/wlan_utility.c

@@ -48,3 +48,24 @@ bool wlan_is_dsrc_channel(uint16_t center_freq)
 
 	return false;
 }
+
+uint8_t wlan_freq_to_chan(uint32_t freq)
+{
+	uint8_t chan;
+
+	if (freq > WLAN_24_GHZ_BASE_FREQ && freq < WLAN_CHAN_14_FREQ)
+		chan = ((freq - WLAN_24_GHZ_BASE_FREQ) /
+			WLAN_CHAN_SPACING_5MHZ);
+	else if (freq == WLAN_CHAN_14_FREQ)
+		chan = WLAN_24_GHZ_CHANNEL_14;
+	else if ((freq > WLAN_24_GHZ_BASE_FREQ) &&
+		(freq < WLAN_5_GHZ_BASE_FREQ))
+		chan = (((freq - WLAN_CHAN_15_FREQ) /
+			WLAN_CHAN_SPACING_20MHZ) +
+			WLAN_24_GHZ_CHANNEL_15);
+	else
+		chan = (freq - WLAN_5_GHZ_BASE_FREQ) /
+			WLAN_CHAN_SPACING_5MHZ;
+
+	return chan;
+}

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -200,6 +200,41 @@ struct wlan_lmac_if_pmo_tx_ops {
 };
 #endif
 
+#ifdef WLAN_P2P_ENABLE
+
+/* forward declarations for p2p tx ops */
+struct p2p_ps_config;
+struct p2p_lo_start;
+
+/**
+ * struct wlan_lmac_if_p2p_tx_ops - structure of tx function pointers
+ * for P2P component
+ * @set_ps:      function pointer to set power save
+ * @lo_start:    function pointer to start listen offload
+ * @lo_stop:     function pointer to stop listen offload
+ * @reg_lo_ev_handler:   function pointer to register lo event handler
+ * @reg_noa_ev_handler:  function pointer to register noa event handler
+ * @unreg_lo_ev_handler: function pointer to unregister lo event handler
+ * @unreg_noa_ev_handler:function pointer to unregister noa event handler
+ */
+struct wlan_lmac_if_p2p_tx_ops {
+	QDF_STATUS (*set_ps)(struct wlan_objmgr_psoc *psoc,
+		struct p2p_ps_config *ps_config);
+	QDF_STATUS (*lo_start)(struct wlan_objmgr_psoc *psoc,
+		struct p2p_lo_start *lo_start);
+	QDF_STATUS (*lo_stop)(struct wlan_objmgr_psoc *psoc,
+		uint32_t vdev_id);
+	QDF_STATUS (*reg_lo_ev_handler)(struct wlan_objmgr_psoc *psoc,
+			void *arg);
+	QDF_STATUS (*reg_noa_ev_handler)(struct wlan_objmgr_psoc *psoc,
+			void *arg);
+	QDF_STATUS (*unreg_lo_ev_handler)(struct wlan_objmgr_psoc *psoc,
+			void *arg);
+	QDF_STATUS (*unreg_noa_ev_handler)(struct wlan_objmgr_psoc *psoc,
+			void *arg);
+};
+#endif
+
 /**
  * struct wlan_lmac_if_tx_ops - south bound tx function pointers
  * @mgmt_txrx_tx_ops: mgmt txrx tx ops
@@ -221,6 +256,9 @@ struct wlan_lmac_if_tx_ops {
 #ifdef WLAN_PMO_ENABLE
 	 struct wlan_lmac_if_pmo_tx_ops pmo_tx_ops;
 #endif
+#ifdef WLAN_P2P_ENABLE
+	struct wlan_lmac_if_p2p_tx_ops p2p;
+#endif
 };
 
 /**
@@ -273,6 +311,26 @@ struct wlan_lmac_if_pmo_rx_ops {
 };
 #endif
 
+#ifdef WLAN_P2P_ENABLE
+
+/* forward declarations for p2p rx ops */
+struct p2p_noa_info;
+struct p2p_lo_event;
+
+/**
+ * struct wlan_lmac_if_p2p_rx_ops - structure of rx function pointers
+ * for P2P component
+ * @lo_ev_handler:    function pointer to give listen offload event
+ * @noa_ev_handler:   function pointer to give noa event
+ */
+struct wlan_lmac_if_p2p_rx_ops {
+	QDF_STATUS (*lo_ev_handler)(struct wlan_objmgr_psoc *psoc,
+		struct p2p_lo_event *event_info);
+	QDF_STATUS (*noa_ev_handler)(struct wlan_objmgr_psoc *psoc,
+		struct p2p_noa_info *event_info);
+};
+#endif
+
 /**
  * struct wlan_lmac_if_rx_ops - south bound rx function pointers
  * @arg1
@@ -292,6 +350,9 @@ struct wlan_lmac_if_rx_ops {
 #ifdef WLAN_PMO_ENABLE
 	 struct wlan_lmac_if_pmo_rx_ops pmo_rx_ops;
 #endif
+#ifdef WLAN_P2P_ENABLE
+	struct wlan_lmac_if_p2p_rx_ops p2p;
+#endif
 };
 
 /* Function pointer to call legacy tx_ops registration in OL/WMA.

wmi/inc/wmi_unified_param.h

@@ -5023,6 +5023,7 @@ typedef enum {
 	wmi_roam_synch_event_id,
 	wmi_p2p_disc_event_id,
 	wmi_p2p_noa_event_id,
+	wmi_p2p_lo_stop_event_id,
 	wmi_pdev_resume_event_id,
 	wmi_do_wow_disable_ack_event_id,
 	wmi_wow_initial_wakeup_event_id,

wmi/src/wmi_unified_tlv.c

@@ -16294,7 +16294,8 @@ static void populate_tlv_events_id(uint32_t *event_ids)
 	event_ids[wmi_p2p_disc_event_id] = WMI_P2P_DISC_EVENTID;
 
 	event_ids[wmi_p2p_noa_event_id] = WMI_P2P_NOA_EVENTID;
-
+	event_ids[wmi_p2p_lo_stop_event_id] =
+				WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID;
 	event_ids[wmi_pdev_resume_event_id] = WMI_PDEV_RESUME_EVENTID;
 	event_ids[wmi_wow_wakeup_host_event_id] = WMI_WOW_WAKEUP_HOST_EVENTID;
 	event_ids[wmi_do_wow_disable_ack_event_id] =