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

qcacmn: NDP_INITIATOR_REQ implementation

Browse Source 
Add implementation for NDP_INITIATOR_REQ.

Change-Id: Ieb4cb79d500fd75b23b4a3f8bfa414d14eb6fe18
CRs-Fixed: 2014795
This commit is contained in:
Naveen Rawat
2017-04-05 17:26:18 -07:00
committed by Sandeep Puligilla
parent e830e98bcf
commit 06a5eb5071
8 changed files with 1402 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
os_if/linux/nan/inc/os_if_nan.h
View File

@@ -153,6 +153,16 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc,
int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
struct nan_callbacks *cb_obj);
/**
* os_if_nan_register_lim_callbacks: os_if api to register lim callbacks
* @psoc: pointer to psoc object
* @cb_obj: struct pointer containing callbacks
*
* Return: status of operation
*/
int os_if_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
struct nan_callbacks *cb_obj);
/**
* os_if_nan_post_ndi_create_rsp: os_if api to pos ndi create rsp to umac nan
* component

524
os_if/linux/nan/src/os_if_nan.c
View File

@@ -24,6 +24,7 @@
#include "qdf_trace.h"
#include "os_if_nan.h"
#include "wlan_nan_api.h"
#include "nan_ucfg_api.h"
#include "nan_public_structs.h"
#include "wlan_osif_priv.h"
#include <net/cfg80211.h>
@@ -168,6 +169,147 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc,
return cb_obj.ndi_delete(vdev_id, iface_name, transaction_id);
}
/**
* os_if_nan_process_ndp_initiator_req() - NDP initiator request handler
* @ctx: hdd context
* @tb: parsed NL attribute list
*
* tb will contain following vendor attributes:
* QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR
* QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID
* QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL - optional
* QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG
* QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID
* QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR
* QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO - optional
* QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional
* QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional
* QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional
*
* Return: 0 on success or error code on failure
*/
static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc,
struct nlattr **tb)
{
int ret = 0;
char *iface_name;
QDF_STATUS status;
uint32_t ndp_qos_cfg;
enum nan_datapath_state state;
struct wlan_objmgr_vdev *nan_vdev;
struct nan_datapath_initiator_req req = {0};
if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) {
cfg80211_err("Interface name string is unavailable");
return -EINVAL;
}
iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]);
nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID);
if (!nan_vdev) {
cfg80211_err("NAN data interface %s not available", iface_name);
return -EINVAL;
}
state = ucfg_nan_get_ndi_state(nan_vdev);
if (state == NAN_DATA_NDI_DELETED_STATE ||
state == NAN_DATA_NDI_DELETING_STATE ||
state == NAN_DATA_NDI_CREATING_STATE) {
cfg80211_err("Data request not allowed in NDI current state: %d",
state);
ret = -EINVAL;
goto initiator_req_failed;
}
if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) {
cfg80211_err("Transaction ID is unavailable");
ret = -EINVAL;
goto initiator_req_failed;
}
req.transaction_id =
nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]);
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL])
req.channel = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]);
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]) {
req.channel_cfg =
nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]);
} else {
cfg80211_err("Channel config is unavailable");
ret = -EINVAL;
goto initiator_req_failed;
}
if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]) {
cfg80211_err("NDP service instance ID is unavailable");
ret = -EINVAL;
goto initiator_req_failed;
}
req.service_instance_id =
nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]);
qdf_mem_copy(req.self_ndi_mac_addr.bytes,
wlan_vdev_mlme_get_macaddr(nan_vdev), QDF_MAC_ADDR_SIZE);
if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]) {
cfg80211_err("NDI peer discovery mac addr is unavailable");
ret = -EINVAL;
goto initiator_req_failed;
}
qdf_mem_copy(req.peer_discovery_mac_addr.bytes,
nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]),
QDF_MAC_ADDR_SIZE);
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) {
req.ndp_info.ndp_app_info_len =
nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]);
req.ndp_info.ndp_app_info =
nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]);
}
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]) {
/* at present ndp config stores 4 bytes QOS info only */
req.ndp_config.ndp_cfg_len = 4;
req.ndp_config.ndp_cfg = (uint8_t *)&ndp_qos_cfg;
ndp_qos_cfg =
nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]);
}
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] &&
!tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) {
cfg80211_err("PMK cannot be absent when CSID is present.");
ret = -EINVAL;
goto initiator_req_failed;
}
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) {
req.pmk.pmk = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]);
req.pmk.pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD,
QDF_TRACE_LEVEL_DEBUG,
req.pmk.pmk, req.pmk.pmk_len);
}
if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) {
req.ncs_sk_type =
nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]);
}
cfg80211_debug("vdev_id: %d, transaction_id: %d, channel: %d, service_instance_id: %d, ndp_app_info_len: %d, csid: %d, peer_discovery_mac_addr: %pM",
wlan_vdev_get_id(nan_vdev), req.transaction_id, req.channel,
req.service_instance_id, req.ndp_info.ndp_app_info_len,
req.ncs_sk_type, req.peer_discovery_mac_addr.bytes);
status = ucfg_nan_req_processor(nan_vdev, &req, NDP_INITIATOR_REQ);
ret = qdf_status_to_os_return(status);
initiator_req_failed:
wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID);
return ret;
}
int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc,
const void *data, int data_len)
{
@@ -211,6 +353,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc,
return os_if_nan_process_ndi_create(psoc, tb);
case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE:
return os_if_nan_process_ndi_delete(psoc, tb);
case QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST:
return os_if_nan_process_ndp_initiator_req(psoc, tb);
default:
cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type);
return -EINVAL;
@@ -219,6 +363,368 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc,
return -EINVAL;
}
/**
* os_if_ndp_initiator_rsp_handler() - NDP initiator response handler
* @vdev: pointer to vdev object
* @rsp_params: response parameters
*
* Following vendor event is sent to cfg80211:
* QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD =
* QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes)
*
* Return: none
*/
static void os_if_ndp_initiator_rsp_handler(struct wlan_objmgr_vdev *vdev,
struct nan_datapath_initiator_rsp *rsp)
{
uint32_t data_len;
struct sk_buff *vendor_event;
struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
if (!rsp) {
cfg80211_err("Invalid NDP Initator response");
return;
}
data_len = (4 * sizeof(uint32_t)) + (1 * sizeof(uint16_t)) +
NLMSG_HDRLEN + (5 * NLA_HDRLEN);
vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL,
data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
GFP_ATOMIC);
if (!vendor_event) {
cfg80211_err("cfg80211_vendor_event_alloc failed");
return;
}
if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE))
goto ndp_initiator_rsp_nla_failed;
if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID,
rsp->transaction_id))
goto ndp_initiator_rsp_nla_failed;
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
rsp->ndp_instance_id))
goto ndp_initiator_rsp_nla_failed;
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE,
rsp->status))
goto ndp_initiator_rsp_nla_failed;
if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE,
rsp->reason))
goto ndp_initiator_rsp_nla_failed;
cfg80211_debug("NDP Initiator rsp sent, tid:%d, instance id:%d, status:%d, reason: %d",
rsp->transaction_id, rsp->ndp_instance_id, rsp->status,
rsp->reason);
cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
return;
ndp_initiator_rsp_nla_failed:
cfg80211_err("nla_put api failed");
kfree_skb(vendor_event);
}
/**
* os_if_ndp_indication_handler() - NDP indication handler
* @vdev: pointer to vdev object
* @ind_params: indication parameters
*
* Following vendor event is sent to cfg80211:
* QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD =
* QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ)
* QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR (6 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR (6 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size)
* QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE(4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_SCID(scid_len in size)
*
* Return: none
*/
static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev,
struct nan_datapath_indication_event *event)
{
uint16_t data_len;
uint32_t ndp_qos_config;
struct sk_buff *vendor_event;
struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
enum nan_datapath_state state;
if (!event) {
cfg80211_err("Invalid NDP Indication");
return;
}
cfg80211_debug("NDP Indication, policy: %d", event->policy);
state = ucfg_nan_get_ndi_state(vdev);
/* check if we are in middle of deleting/creating the interface */
if (state == NAN_DATA_NDI_DELETED_STATE ||
state == NAN_DATA_NDI_DELETING_STATE ||
state == NAN_DATA_NDI_CREATING_STATE) {
cfg80211_err("Data request not allowed in current NDI state: %d",
state);
return;
}
data_len = (5 * sizeof(uint32_t)) + (2 * QDF_MAC_ADDR_SIZE) + IFNAMSIZ +
event->ndp_info.ndp_app_info_len + event->scid.scid_len +
(10 * NLA_HDRLEN) + NLMSG_HDRLEN;
/* notify response to the upper layer */
vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy,
NULL, data_len,
QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
GFP_ATOMIC);
if (!vendor_event) {
cfg80211_err("cfg80211_vendor_event_alloc failed");
return;
}
if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND))
goto ndp_indication_nla_failed;
if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR,
IFNAMSIZ, "nan0"/* adapter->dev->name - fetch dev name */))
goto ndp_indication_nla_failed;
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID,
event->service_instance_id))
goto ndp_indication_nla_failed;
if (nla_put(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR,
QDF_MAC_ADDR_SIZE, event->peer_mac_addr.bytes))
goto ndp_indication_nla_failed;
if (nla_put(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR,
QDF_MAC_ADDR_SIZE, event->peer_discovery_mac_addr.bytes))
goto ndp_indication_nla_failed;
if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
event->ndp_instance_id))
goto ndp_indication_nla_failed;
if (event->ndp_info.ndp_app_info_len)
if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO,
event->ndp_info.ndp_app_info_len,
event->ndp_info.ndp_app_info))
goto ndp_indication_nla_failed;
if (event->ndp_config.ndp_cfg_len) {
ndp_qos_config = *((uint32_t *)event->ndp_config.ndp_cfg);
/* at present ndp config stores 4 bytes QOS info only */
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS,
ndp_qos_config))
goto ndp_indication_nla_failed;
}
if (event->scid.scid_len) {
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE,
event->ncs_sk_type))
goto ndp_indication_nla_failed;
if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SCID,
event->scid.scid_len,
event->scid.scid))
goto ndp_indication_nla_failed;
cfg80211_debug("csid: %d, scid_len: %d",
event->ncs_sk_type, event->scid.scid_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
event->scid.scid, event->scid.scid_len);
}
cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
return;
ndp_indication_nla_failed:
cfg80211_err("nla_put api failed");
kfree_skb(vendor_event);
}
/**
* os_if_ndp_confirm_ind_handler() - NDP confirm indication handler
* @vdev: pointer to vdev object
* @ind_params: indication parameters
*
* Following vendor event is sent to cfg80211:
* QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD =
* QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR (6 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ)
* QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size)
* QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE (4 bytes)
* QCA_WLAN_VENDOR_ATTR_NDP_RETURN_VALUE (4 bytes)
*
* Return: none
*/
static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev,
struct nan_datapath_confirm_event *ndp_confirm)
{
int idx = 0;
uint32_t data_len;
QDF_STATUS status;
uint32_t ndp_qos_config = 0;
struct sk_buff *vendor_event;
struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev);
struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
struct nan_callbacks cb_obj;
if (!ndp_confirm) {
cfg80211_err("Invalid NDP Initator response");
return;
}
status = ucfg_nan_get_callbacks(psoc, &cb_obj);
if (QDF_IS_STATUS_ERROR(status)) {
cfg80211_err("couldn't get callbacks");
return;
}
/* ndp_confirm is called each time user generated ndp req succeeds */
idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev),
&ndp_confirm->peer_ndi_mac_addr);
if (idx < 0)
cfg80211_err("can't find addr: %pM in vdev_id: %d, peer table.",
&ndp_confirm->peer_ndi_mac_addr,
wlan_vdev_get_id(vdev));
else if (ndp_confirm->rsp_code == NAN_DATAPATH_RESPONSE_ACCEPT) {
uint32_t active_sessions =
ucfg_nan_get_active_ndp_sessions(vdev, idx);
ucfg_nan_set_active_ndp_sessions(vdev, active_sessions + 1,
idx);
}
data_len = (4 * sizeof(uint32_t)) + QDF_MAC_ADDR_SIZE + IFNAMSIZ +
+ NLMSG_HDRLEN + (7 * NLA_HDRLEN) +
ndp_confirm->ndp_info.ndp_app_info_len;
if (ndp_confirm->ndp_info.ndp_app_info_len)
data_len += NLA_HDRLEN + ndp_confirm->ndp_info.ndp_app_info_len;
vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL,
data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
GFP_ATOMIC);
if (!vendor_event) {
cfg80211_err("cfg80211_vendor_event_alloc failed");
return;
}
if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND))
goto ndp_confirm_nla_failed;
if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
ndp_confirm->ndp_instance_id))
goto ndp_confirm_nla_failed;
if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR,
QDF_MAC_ADDR_SIZE, ndp_confirm->peer_ndi_mac_addr.bytes))
goto ndp_confirm_nla_failed;
if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR,
IFNAMSIZ, "nan0" /* TBD adapter->dev->name - fetch name */))
goto ndp_confirm_nla_failed;
if (ndp_confirm->ndp_info.ndp_app_info_len && nla_put(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO,
ndp_confirm->ndp_info.ndp_app_info_len,
ndp_confirm->ndp_info.ndp_app_info))
goto ndp_confirm_nla_failed;
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE,
ndp_confirm->rsp_code))
goto ndp_confirm_nla_failed;
if (nla_put_u32(vendor_event,
QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE,
ndp_confirm->reason_code))
goto ndp_confirm_nla_failed;
cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM, ndp_cfg: %d, rsp_code: %d, reason_code: %d",
ndp_confirm->ndp_instance_id,
ndp_confirm->peer_ndi_mac_addr.bytes,
ndp_qos_config, ndp_confirm->rsp_code,
ndp_confirm->reason_code);
cfg80211_debug("NDP confim, ndp app info dump");
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
ndp_confirm->ndp_info.ndp_app_info,
ndp_confirm->ndp_info.ndp_app_info_len);
return;
ndp_confirm_nla_failed:
cfg80211_err("nla_put api failed");
kfree_skb(vendor_event);
}
/**
* os_if_new_peer_ind_handler() - NDP new peer indication handler
* @adapter: pointer to adapter context
* @ind_params: indication parameters
*
* Return: none
*/
static void os_if_new_peer_ind_handler(struct wlan_objmgr_vdev *vdev,
struct nan_datapath_peer_ind *peer_ind)
{
int ret;
QDF_STATUS status;
uint8_t vdev_id = wlan_vdev_get_id(vdev);
struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev);
uint32_t active_peers = ucfg_nan_get_active_peers(vdev);
struct nan_callbacks cb_obj;
if (NULL == peer_ind) {
cfg80211_err("Invalid new NDP peer params");
return;
}
status = ucfg_nan_get_callbacks(psoc, &cb_obj);
if (QDF_IS_STATUS_ERROR(status)) {
cfg80211_err("failed to get callbacks");
return;
}
cfg80211_debug("session_id: %d, peer_mac: %pM, sta_id: %d",
peer_ind->session_id, peer_ind->peer_mac_addr.bytes,
peer_ind->sta_id);
ret = cb_obj.new_peer_ind(vdev_id, peer_ind->sta_id,
&peer_ind->peer_mac_addr,
(active_peers == 0 ? true : false));
if (ret) {
cfg80211_err("new peer handling at HDD failed %d", ret);
return;
}
active_peers++;
ucfg_nan_set_active_peers(vdev, active_peers);
cfg80211_debug("vdev_id: %d, num_peers: %d", vdev_id, active_peers);
}
/**
* os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler
* @adapter: pointer to adapter context
@@ -393,6 +899,18 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc,
case NAN_DATAPATH_INF_DELETE_RSP:
os_if_ndp_iface_delete_rsp_handler(psoc, vdev, msg);
break;
case NDP_CONFIRM:
os_if_ndp_confirm_ind_handler(vdev, msg);
break;
case NDP_INITIATOR_RSP:
os_if_ndp_initiator_rsp_handler(vdev, msg);
break;
case NDP_INDICATION:
os_if_ndp_indication_handler(vdev, msg);
break;
case NDP_NEW_PEER:
os_if_new_peer_ind_handler(vdev, msg);
break;
default:
break;
}
@@ -405,6 +923,12 @@ int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
os_if_nan_event_handler);
}
int os_if_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
struct nan_callbacks *cb_obj)
{
return ucfg_nan_register_lim_callbacks(psoc, cb_obj);
}
void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id, bool success)
{

571
target_if/nan/src/target_if_nan.c
View File

@@ -20,12 +20,513 @@
* DOC: contains nan target if functions
*/
#include "wlan_nan_api.h"
#include "../../../umac/nan/core/src/nan_main_i.h"
#include "nan_public_structs.h"
#include "target_if_nan.h"
#include "wmi_unified_api.h"
#include "scheduler_api.h"
static QDF_STATUS target_if_nan_req(void *in_req, uint32_t req_type)
static QDF_STATUS target_if_nan_event_dispatcher(struct scheduler_msg *msg)
{
QDF_STATUS status;
struct wlan_objmgr_vdev *vdev = NULL;
struct wlan_objmgr_psoc *psoc;
struct wlan_lmac_if_nan_rx_ops *nan_rx_ops;
switch (msg->type) {
case NDP_INITIATOR_RSP: {
struct nan_datapath_initiator_rsp *initiator_rsp = msg->bodyptr;
vdev = initiator_rsp->vdev;
break;
}
case NDP_INDICATION: {
struct nan_datapath_indication_event *ind = msg->bodyptr;
vdev = ind->vdev;
break;
}
case NDP_CONFIRM: {
struct nan_datapath_confirm_event *confirm = msg->bodyptr;
vdev = confirm->vdev;
break;
}
default:
target_if_err("invalid msg type %d", msg->type);
qdf_mem_free(msg->bodyptr);
return QDF_STATUS_E_INVAL;
}
if (!vdev) {
target_if_err("vdev is null");
qdf_mem_free(msg->bodyptr);
return QDF_STATUS_E_NULL_VALUE;
}
/* try get ref now, if failure, then vdev may have been deleted */
status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_NAN_ID);
if (QDF_IS_STATUS_ERROR(status)) {
nan_alert("couldn't get ref. vdev maybe deleted");
qdf_mem_free(msg->bodyptr);
return QDF_STATUS_E_INVAL;
}
psoc = wlan_vdev_get_psoc(vdev);
if (!psoc) {
target_if_err("psoc is null");
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
qdf_mem_free(msg->bodyptr);
return QDF_STATUS_E_NULL_VALUE;
}
nan_rx_ops = target_if_nan_get_rx_ops(psoc);
if (!nan_rx_ops) {
target_if_err("nan_rx_ops is null");
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
qdf_mem_free(msg->bodyptr);
return QDF_STATUS_E_NULL_VALUE;
}
status = nan_rx_ops->nan_event_rx(msg);
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
qdf_mem_free(msg->bodyptr);
return status;
}
static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req)
{
int ret;
uint16_t len;
wmi_buf_t buf;
uint8_t *tlv_ptr;
QDF_STATUS status;
wmi_channel *ch_tlv;
wmi_unified_t wmi_handle;
struct wlan_objmgr_psoc *psoc;
struct scheduler_msg pe_msg = {0};
wmi_ndp_initiator_req_fixed_param *cmd;
struct wlan_lmac_if_nan_rx_ops *nan_rx_ops;
uint32_t ndp_cfg_len, ndp_app_info_len, pmk_len;
struct nan_datapath_initiator_rsp ndp_rsp = {0};
struct nan_datapath_initiator_req *ndp_req = req;
if (!ndp_req) {
target_if_err("ndp_req is null.");
return QDF_STATUS_E_INVAL;
}
psoc = wlan_vdev_get_psoc(ndp_req->vdev);
if (!psoc) {
target_if_err("psoc is null.");
return QDF_STATUS_E_INVAL;
}
wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc);
if (!wmi_handle) {
target_if_err("wmi_handle is null.");
return QDF_STATUS_E_INVAL;
}
nan_rx_ops = target_if_nan_get_rx_ops(psoc);
if (!nan_rx_ops) {
target_if_err("nan_rx_ops is null.");
return QDF_STATUS_E_INVAL;
}
/*
* WMI command expects 4 byte alligned len:
* round up ndp_cfg_len and ndp_app_info_len to 4 bytes
*/
ndp_cfg_len = qdf_roundup(ndp_req->ndp_config.ndp_cfg_len, 4);
ndp_app_info_len = qdf_roundup(ndp_req->ndp_info.ndp_app_info_len, 4);
pmk_len = qdf_roundup(ndp_req->pmk.pmk_len, 4);
/* allocated memory for fixed params as well as variable size data */
len = sizeof(*cmd) + sizeof(*ch_tlv) + (3 * WMI_TLV_HDR_SIZE)
+ ndp_cfg_len + ndp_app_info_len + pmk_len;
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
target_if_err("wmi_buf_alloc failed");
status = QDF_STATUS_E_NOMEM;
goto send_ndp_initiator_fail;
}
cmd = (wmi_ndp_initiator_req_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ndp_initiator_req_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_ndp_initiator_req_fixed_param));
cmd->vdev_id = wlan_vdev_get_id(ndp_req->vdev);
cmd->transaction_id = ndp_req->transaction_id;
cmd->service_instance_id = ndp_req->service_instance_id;
WMI_CHAR_ARRAY_TO_MAC_ADDR(ndp_req->peer_discovery_mac_addr.bytes,
&cmd->peer_discovery_mac_addr);
cmd->ndp_cfg_len = ndp_req->ndp_config.ndp_cfg_len;
cmd->ndp_app_info_len = ndp_req->ndp_info.ndp_app_info_len;
cmd->ndp_channel_cfg = ndp_req->channel_cfg;
cmd->nan_pmk_len = ndp_req->pmk.pmk_len;
cmd->nan_csid = ndp_req->ncs_sk_type;
ch_tlv = (wmi_channel *)&cmd[1];
WMITLV_SET_HDR(ch_tlv, WMITLV_TAG_STRUC_wmi_channel,
WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
ch_tlv->mhz = ndp_req->channel;
/*
ch_tlv->band_center_freq1 =
cds_chan_to_freq(cds_freq_to_chan(ndp_req->channel));
*/
tlv_ptr = (uint8_t *)&ch_tlv[1];
WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len);
qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE],
ndp_req->ndp_config.ndp_cfg, cmd->ndp_cfg_len);
tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_cfg_len;
WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_app_info_len);
qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE],
ndp_req->ndp_info.ndp_app_info, cmd->ndp_app_info_len);
tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_app_info_len;
WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, pmk_len);
qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], ndp_req->pmk.pmk,
cmd->nan_pmk_len);
tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len;
target_if_debug("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d",
cmd->vdev_id, cmd->transaction_id, cmd->service_instance_id,
ch_tlv->mhz, cmd->ndp_channel_cfg, cmd->nan_csid);
target_if_debug("peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
cmd->peer_discovery_mac_addr.mac_addr31to0,
cmd->peer_discovery_mac_addr.mac_addr47to32);
target_if_debug("ndp_config len: %d", cmd->ndp_cfg_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
ndp_req->ndp_config.ndp_cfg,
ndp_req->ndp_config.ndp_cfg_len);
target_if_debug("ndp_app_info len: %d", cmd->ndp_app_info_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
ndp_req->ndp_info.ndp_app_info,
ndp_req->ndp_info.ndp_app_info_len);
target_if_debug("pmk len: %d", cmd->nan_pmk_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
ndp_req->pmk.pmk, cmd->nan_pmk_len);
target_if_debug("sending WMI_NDP_INITIATOR_REQ_CMDID(0x%X)",
WMI_NDP_INITIATOR_REQ_CMDID);
ret = wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_NDP_INITIATOR_REQ_CMDID);
if (ret < 0) {
target_if_err("WMI_NDP_INITIATOR_REQ_CMDID failed, ret: %d",
ret);
wmi_buf_free(buf);
goto send_ndp_initiator_fail;
}
return QDF_STATUS_SUCCESS;
send_ndp_initiator_fail:
ndp_rsp.vdev = ndp_req->vdev;
ndp_rsp.transaction_id = ndp_req->transaction_id;
ndp_rsp.ndp_instance_id = ndp_req->service_instance_id;
ndp_rsp.status = NAN_DATAPATH_DATA_INITIATOR_REQ_FAILED;
pe_msg.type = NDP_INITIATOR_RSP;
pe_msg.bodyptr = &ndp_rsp;
/* process even here and call callback */
if (nan_rx_ops && nan_rx_ops->nan_event_rx)
nan_rx_ops->nan_event_rx(&pe_msg);
return status;
}
static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data,
uint32_t len)
{
QDF_STATUS status;
struct wlan_objmgr_vdev *vdev;
struct wlan_objmgr_psoc *psoc;
struct scheduler_msg msg = {0};
struct nan_datapath_initiator_rsp *rsp;
WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *event;
wmi_ndp_initiator_rsp_event_fixed_param *fixed_params;
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
target_if_err("psoc is null");
return -EINVAL;
}
event = (WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *)data;
fixed_params = event->fixed_param;
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
fixed_params->vdev_id, WLAN_NAN_ID);
if (!vdev) {
target_if_err("vdev is null");
return -EINVAL;
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
return -ENOMEM;
}
rsp->vdev = vdev;
rsp->transaction_id = fixed_params->transaction_id;
rsp->ndp_instance_id = fixed_params->ndp_instance_id;
rsp->status = fixed_params->rsp_status;
rsp->reason = fixed_params->reason_code;
msg.type = NDP_INITIATOR_RSP;
msg.bodyptr = rsp;
msg.callback = target_if_nan_event_dispatcher;
target_if_err("NDP_INITIATOR_RSP sent: %d", msg.type);
status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
if (QDF_IS_STATUS_ERROR(status)) {
target_if_err("failed to post msg, status: %d", status);
qdf_mem_free(rsp);
return -EINVAL;
}
return 0;
}
static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data,
uint32_t data_len)
{
int ret;
QDF_STATUS status;
struct wlan_objmgr_psoc *psoc;
struct wlan_objmgr_vdev *vdev;
struct scheduler_msg msg = {0};
struct nan_datapath_indication_event *rsp;
WMI_NDP_INDICATION_EVENTID_param_tlvs *event;
wmi_ndp_indication_event_fixed_param *fixed_params;
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
target_if_err("psoc is null");
return -EINVAL;
}
event = (WMI_NDP_INDICATION_EVENTID_param_tlvs *)data;
fixed_params =
(wmi_ndp_indication_event_fixed_param *)event->fixed_param;
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
fixed_params->vdev_id, WLAN_NAN_ID);
if (!vdev) {
target_if_err("vdev is null");
return -EINVAL;
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
return -ENOMEM;
}
rsp->vdev = vdev;
rsp->service_instance_id = fixed_params->service_instance_id;
rsp->ndp_instance_id = fixed_params->ndp_instance_id;
rsp->role = fixed_params->self_ndp_role;
rsp->policy = fixed_params->accept_policy;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
rsp->peer_mac_addr.bytes);
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_discovery_mac_addr,
rsp->peer_discovery_mac_addr.bytes);
target_if_debug("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d,\n"
"service_instance %d, ndp_instance %d, role %d, policy %d,\n"
"csid: %d, scid_len: %d, peer_addr: %pM, peer_disc_addr: %pM",
WMI_NDP_INDICATION_EVENTID, fixed_params->vdev_id,
fixed_params->service_instance_id,
fixed_params->ndp_instance_id, fixed_params->self_ndp_role,
fixed_params->accept_policy,
fixed_params->nan_csid, fixed_params->nan_scid_len,
rsp->peer_mac_addr.bytes,
rsp->peer_discovery_mac_addr.bytes);
target_if_debug("ndp_cfg - %d bytes", fixed_params->ndp_cfg_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
&event->ndp_cfg, fixed_params->ndp_cfg_len);
target_if_debug("ndp_app_info - %d bytes",
fixed_params->ndp_app_info_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
&event->ndp_app_info, fixed_params->ndp_app_info_len);
rsp->ndp_config.ndp_cfg_len = fixed_params->ndp_cfg_len;
rsp->ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len;
rsp->ncs_sk_type = fixed_params->nan_csid;
rsp->scid.scid_len = fixed_params->nan_scid_len;
if (rsp->ndp_config.ndp_cfg_len) {
rsp->ndp_config.ndp_cfg =
qdf_mem_malloc(fixed_params->ndp_cfg_len);
if (!rsp->ndp_config.ndp_cfg) {
target_if_err("malloc failed");
ret = -ENOMEM;
goto free_ind_resources;
}
qdf_mem_copy(rsp->ndp_config.ndp_cfg, event->ndp_cfg,
rsp->ndp_config.ndp_cfg_len);
}
if (rsp->ndp_info.ndp_app_info_len) {
rsp->ndp_info.ndp_app_info =
qdf_mem_malloc(rsp->ndp_info.ndp_app_info_len);
if (!rsp->ndp_info.ndp_app_info) {
target_if_err("malloc failed");
ret = -ENOMEM;
goto free_ind_resources;
}
qdf_mem_copy(rsp->ndp_info.ndp_app_info,
event->ndp_app_info,
rsp->ndp_info.ndp_app_info_len);
}
if (rsp->scid.scid_len) {
rsp->scid.scid =
qdf_mem_malloc(rsp->scid.scid_len);
if (!rsp->scid.scid) {
target_if_err("malloc failed");
ret = -ENOMEM;
goto free_ind_resources;
}
qdf_mem_copy(rsp->scid.scid,
event->ndp_scid, rsp->scid.scid_len);
target_if_debug("scid hex dump:");
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
rsp->scid.scid, rsp->scid.scid_len);
}
msg.type = NDP_INDICATION;
msg.bodyptr = rsp;
msg.callback = target_if_nan_event_dispatcher;
target_if_debug("NDP_INDICATION sent: %d", msg.type);
status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
if (QDF_IS_STATUS_ERROR(status)) {
target_if_err("failed to post msg, status: %d", status);
ret = -EINVAL;
goto free_ind_resources;
}
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
return 0;
free_ind_resources:
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
qdf_mem_free(rsp->ndp_config.ndp_cfg);
qdf_mem_free(rsp->ndp_info.ndp_app_info);
qdf_mem_free(rsp->scid.scid);
qdf_mem_free(rsp);
return ret;
}
static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data,
uint32_t data_len)
{
QDF_STATUS status;
struct wlan_objmgr_psoc *psoc;
struct wlan_objmgr_vdev *vdev;
struct scheduler_msg msg = {0};
WMI_NDP_CONFIRM_EVENTID_param_tlvs *event;
wmi_ndp_confirm_event_fixed_param *fixed_params;
struct nan_datapath_confirm_event *rsp;
psoc = target_if_get_psoc_from_scn_hdl(scn);
if (!psoc) {
target_if_err("psoc is null");
return -EINVAL;
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
return -ENOMEM;
}
event = (WMI_NDP_CONFIRM_EVENTID_param_tlvs *) data;
fixed_params = (wmi_ndp_confirm_event_fixed_param *)event->fixed_param;
target_if_debug("WMI_NDP_CONFIRM_EVENTID(0x%X) recieved. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d",
WMI_NDP_CONFIRM_EVENTID, fixed_params->vdev_id,
fixed_params->ndp_instance_id, fixed_params->rsp_code,
fixed_params->reason_code,
fixed_params->num_active_ndps_on_peer);
target_if_debug("ndp_cfg - %d bytes", fixed_params->ndp_cfg_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
&event->ndp_cfg, fixed_params->ndp_cfg_len);
target_if_debug("ndp_app_info - %d bytes",
fixed_params->ndp_app_info_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
&event->ndp_app_info, fixed_params->ndp_app_info_len);
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
fixed_params->vdev_id, WLAN_NAN_ID);
if (!vdev) {
target_if_err("vdev is null");
return -EINVAL;
}
rsp->vdev = vdev;
rsp->ndp_instance_id = fixed_params->ndp_instance_id;
rsp->rsp_code = fixed_params->rsp_code;
rsp->reason_code = fixed_params->reason_code;
rsp->num_active_ndps_on_peer =
fixed_params->num_active_ndps_on_peer;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
rsp->peer_ndi_mac_addr.bytes);
rsp->ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len;
if (rsp->ndp_info.ndp_app_info_len) {
rsp->ndp_info.ndp_app_info =
qdf_mem_malloc(fixed_params->ndp_app_info_len);
if (!rsp->ndp_info.ndp_app_info) {
target_if_err("malloc failed");
qdf_mem_free(rsp);
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
return -ENOMEM;
}
qdf_mem_copy(&rsp->ndp_info.ndp_app_info,
event->ndp_app_info,
rsp->ndp_info.ndp_app_info_len);
}
msg.type = NDP_CONFIRM;
msg.bodyptr = rsp;
msg.callback = target_if_nan_event_dispatcher;
target_if_err("NDP_CONFIRM sent: %d", msg.type);
status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
if (QDF_IS_STATUS_ERROR(status)) {
target_if_err("failed to post msg, status: %d", status);
qdf_mem_free(rsp->ndp_info.ndp_app_info);
qdf_mem_free(rsp);
return -EINVAL;
}
return 0;
}
static QDF_STATUS target_if_nan_req(void *req, uint32_t req_type)
{
/* send cmd to fw */
switch (req_type) {
case NDP_INITIATOR_REQ:
target_if_nan_ndp_intiaitor_req(req);
break;
default:
target_if_err("invalid req type");
break;
}
return QDF_STATUS_SUCCESS;
}
@@ -36,8 +537,7 @@ void target_if_nan_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops)
void target_if_nan_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops)
{
/* TBD */
rx_ops->nan_rx_ops.nan_event_rx = NULL;
rx_ops->nan_rx_ops.nan_event_rx = nan_event_handler;
}
inline struct wlan_lmac_if_nan_tx_ops *target_if_nan_get_tx_ops(
@@ -64,12 +564,69 @@ inline struct wlan_lmac_if_nan_rx_ops *target_if_nan_get_rx_ops(
QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc)
{
/* TBD */
int ret;
wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc);
ret = wmi_unified_register_event_handler(handle,
WMI_NDP_INITIATOR_RSP_EVENTID,
target_if_ndp_initiator_rsp_handler,
WMI_RX_UMAC_CTX);
if (ret) {
target_if_err("wmi event registration failed, ret: %d", ret);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_register_event_handler(handle,
WMI_NDP_INDICATION_EVENTID,
target_if_ndp_ind_handler,
WMI_RX_UMAC_CTX);
if (ret) {
target_if_err("wmi event registration failed, ret: %d", ret);
target_if_nan_deregister_events(psoc);
return QDF_STATUS_E_FAILURE;
}
ret = wmi_unified_register_event_handler(handle,
WMI_NDP_CONFIRM_EVENTID,
target_if_ndp_confirm_handler,
WMI_RX_UMAC_CTX);
if (ret) {
target_if_err("wmi event registration failed, ret: %d", ret);
target_if_nan_deregister_events(psoc);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc)
{
/* TBD */
return QDF_STATUS_SUCCESS;
int ret, status = 0;
wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc);
ret = wmi_unified_unregister_event_handler(handle,
WMI_NDP_INITIATOR_RSP_EVENTID);
if (ret) {
target_if_err("wmi event deregistration failed, ret: %d", ret);
status = ret;
}
ret = wmi_unified_unregister_event_handler(handle,
WMI_NDP_INDICATION_EVENTID);
if (ret) {
target_if_err("wmi event deregistration failed, ret: %d", ret);
status = ret;
}
ret = wmi_unified_unregister_event_handler(handle,
WMI_NDP_CONFIRM_EVENTID);
if (ret) {
target_if_err("wmi event deregistration failed, ret: %d", ret);
status = ret;
}
if (status)
return QDF_STATUS_E_FAILURE;
else
return QDF_STATUS_SUCCESS;
}

6
umac/nan/core/inc/nan_public_structs.h
View File

@@ -492,6 +492,12 @@ struct nan_callbacks {
void (*drv_ndi_create_rsp_handler)(uint8_t,
struct nan_datapath_inf_create_rsp *);
void (*drv_ndi_delete_rsp_handler)(uint8_t);
int (*new_peer_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, bool);
int (*get_peer_idx)(uint8_t, struct qdf_mac_addr *);
QDF_STATUS (*add_ndi_peer)(uint32_t, struct qdf_mac_addr);
void (*delete_peers_by_addr)(uint8_t, struct qdf_mac_addr);
};
#endif

158
umac/nan/core/src/nan_main.c
View File

@@ -256,3 +256,161 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg)
}
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS nan_handle_confirm(
struct nan_datapath_confirm_event *confirm)
{
uint8_t vdev_id;
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct wlan_objmgr_psoc *psoc;
struct nan_psoc_priv_obj *psoc_nan_obj;
vdev_id = wlan_vdev_get_id(confirm->vdev);
psoc = wlan_vdev_get_psoc(confirm->vdev);
if (!psoc) {
nan_err("psoc is null");
status = QDF_STATUS_E_NULL_VALUE;
goto free_resource;
}
psoc_nan_obj = nan_get_psoc_priv_obj(psoc);
if (!psoc_nan_obj) {
nan_err("psoc_nan_obj is null");
status = QDF_STATUS_E_NULL_VALUE;
goto free_resource;
}
if (confirm->rsp_code != NAN_DATAPATH_RESPONSE_ACCEPT &&
confirm->num_active_ndps_on_peer == 0) {
/*
* This peer was created at ndp_indication but
* confirm failed, so it needs to be deleted
*/
nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDRESS_STR" on vdev_id: %d",
QDF_MAC_ADDR_ARRAY(confirm->peer_ndi_mac_addr.bytes),
vdev_id);
psoc_nan_obj->cb_obj.delete_peers_by_addr(vdev_id,
confirm->peer_ndi_mac_addr);
}
psoc_nan_obj->cb_obj.os_if_event_handler(psoc, confirm->vdev,
NDP_CONFIRM, confirm);
free_resource:
qdf_mem_free(confirm->ndp_info.ndp_app_info);
return status;
}
static QDF_STATUS nan_handle_initiator_rsp(
struct nan_datapath_initiator_rsp *rsp,
struct wlan_objmgr_vdev **vdev)
{
struct wlan_objmgr_psoc *psoc;
struct nan_psoc_priv_obj *psoc_nan_obj;
*vdev = rsp->vdev;
psoc = wlan_vdev_get_psoc(rsp->vdev);
if (!psoc) {
nan_err("psoc is null");
return QDF_STATUS_E_NULL_VALUE;
}
psoc_nan_obj = nan_get_psoc_priv_obj(psoc);
if (!psoc_nan_obj) {
nan_err("psoc_nan_obj is null");
return QDF_STATUS_E_NULL_VALUE;
}
psoc_nan_obj->cb_obj.os_if_event_handler(psoc, rsp->vdev,
NDP_INITIATOR_RSP, rsp);
return QDF_STATUS_SUCCESS;
}
static QDF_STATUS nan_handle_ndp_ind(
struct nan_datapath_indication_event *ndp_ind)
{
uint8_t vdev_id;
struct wlan_objmgr_psoc *psoc;
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct nan_psoc_priv_obj *psoc_nan_obj;
vdev_id = wlan_vdev_get_id(ndp_ind->vdev);
psoc = wlan_vdev_get_psoc(ndp_ind->vdev);
if (!psoc) {
nan_err("psoc is null");
status = QDF_STATUS_E_NULL_VALUE;
goto ndp_indication_failed;
}
psoc_nan_obj = nan_get_psoc_priv_obj(psoc);
if (!psoc_nan_obj) {
nan_err("psoc_nan_obj is null");
status = QDF_STATUS_E_NULL_VALUE;
goto ndp_indication_failed;
}
nan_debug("role: %d, vdev: %d, csid: %d, peer_mac_addr "
QDF_MAC_ADDRESS_STR,
ndp_ind->role, vdev_id, ndp_ind->ncs_sk_type,
QDF_MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes));
if ((ndp_ind->role == NAN_DATAPATH_ROLE_INITIATOR) ||
((NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) &&
(NAN_DATAPATH_ACCEPT_POLICY_ALL == ndp_ind->policy))) {
status = psoc_nan_obj->cb_obj.add_ndi_peer(vdev_id,
ndp_ind->peer_mac_addr);
if (QDF_IS_STATUS_ERROR(status)) {
nan_err("Couldn't add ndi peer, ndp_role: %d",
ndp_ind->role);
goto ndp_indication_failed;
}
}
if (NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role)
psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ndp_ind->vdev,
NDP_INDICATION, ndp_ind);
ndp_indication_failed:
qdf_mem_free(ndp_ind->ndp_config.ndp_cfg);
qdf_mem_free(ndp_ind->ndp_info.ndp_app_info);
qdf_mem_free(ndp_ind->scid.scid);
return status;
}
QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct wlan_serialization_queued_cmd_info cmd;
cmd.requestor = WLAN_UMAC_COMP_NAN;
cmd.cmd_id = 0;
cmd.req_type = WLAN_SER_CANCEL_NON_SCAN_CMD;
cmd.queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
if (!pe_msg->bodyptr) {
nan_err("msg body is null");
return QDF_STATUS_E_NULL_VALUE;
}
switch (pe_msg->type) {
case NDP_CONFIRM: {
nan_handle_confirm(pe_msg->bodyptr);
break;
}
case NDP_INITIATOR_RSP: {
nan_handle_initiator_rsp(pe_msg->bodyptr, &cmd.vdev);
cmd.cmd_type = WLAN_SER_CMD_NDP_INIT_REQ;
wlan_serialization_remove_cmd(&cmd);
break;
}
case NDP_INDICATION: {
nan_handle_ndp_ind(pe_msg->bodyptr);
break;
}
default:
nan_alert("Unhandled NDP event: %d", pe_msg->type);
status = QDF_STATUS_E_NOSUPPORT;
break;
}
return status;
}

8
umac/nan/core/src/nan_main_i.h
View File

@@ -124,4 +124,12 @@ void nan_release_cmd(void *in_req, uint32_t req_type);
*/
QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg);
/*
* nan_event_handler: function to process events from firmware
* @msg: message received from lmac
*
* Return: status of operation
*/
QDF_STATUS nan_event_handler(struct scheduler_msg *msg);
#endif

24
umac/nan/dispatcher/inc/nan_ucfg_api.h
View File

@@ -196,6 +196,20 @@ struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc,
QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
void *in_req, uint32_t req_type);
/**
* ucfg_nan_event_handler: ucfg API to be called from legacy code to
* post events to os_if/hdd layer
* @psoc: pointer to psoc object
* @vdev: pointer to vdev object
* @type: message type
* @msg: msg buffer
*
* Return: None
*/
void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_vdev *vdev,
uint32_t type, void *msg);
/**
* ucfg_nan_register_hdd_callbacks: ucfg API to set hdd callbacks
* @psoc: pointer to psoc object
@@ -211,6 +225,16 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_vdev *,
uint32_t, void *));
/*
* ucfg_nan_register_lim_callbacks: ucfg API to set lim callbacks
* @psoc: pointer to psoc object
* @cb_obj: structs containing callbacks
*
* Return: status of operation
*/
int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
struct nan_callbacks *cb_obj);
/**
* ucfg_nan_get_callbacks: ucfg API to return callbacks
* @psoc: pointer to psoc object

109
umac/nan/dispatcher/src/nan_ucfg_api.c
View File

@@ -322,9 +322,69 @@ struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc,
return psoc_obj->vdev;
}
static struct nan_datapath_initiator_req *ucfg_nan_copy_intiator_req(
struct wlan_objmgr_vdev *vdev,
struct nan_datapath_initiator_req *in_req)
{
struct nan_datapath_initiator_req *out_req;
out_req = qdf_mem_malloc(sizeof(*out_req));
if (!out_req) {
nan_alert("malloc failed");
return NULL;
}
qdf_mem_copy(out_req, in_req, sizeof(*out_req));
if (in_req->ndp_config.ndp_cfg_len) {
out_req->ndp_config.ndp_cfg =
qdf_mem_malloc(in_req->ndp_config.ndp_cfg_len);
if (!out_req->ndp_config.ndp_cfg) {
nan_alert("malloc failed");
goto free_resources;
}
qdf_mem_copy(out_req->ndp_config.ndp_cfg,
in_req->ndp_config.ndp_cfg,
in_req->ndp_config.ndp_cfg_len);
}
if (in_req->ndp_info.ndp_app_info_len) {
out_req->ndp_info.ndp_app_info =
qdf_mem_malloc(in_req->ndp_info.ndp_app_info_len);
if (!out_req->ndp_info.ndp_app_info) {
nan_alert("malloc failed");
goto free_resources;
}
qdf_mem_copy(out_req->ndp_info.ndp_app_info,
in_req->ndp_info.ndp_app_info,
in_req->ndp_info.ndp_app_info_len);
}
if (in_req->pmk.pmk_len) {
out_req->pmk.pmk = qdf_mem_malloc(in_req->pmk.pmk_len);
if (!out_req->pmk.pmk) {
nan_alert("malloc failed");
goto free_resources;
}
qdf_mem_copy(out_req->pmk.pmk, in_req->pmk.pmk,
in_req->pmk.pmk_len);
}
/* do not get ref here, rather take ref when request is activated */
out_req->vdev = vdev;
return out_req;
free_resources:
qdf_mem_free(out_req->pmk.pmk);
qdf_mem_free(out_req->ndp_info.ndp_app_info);
qdf_mem_free(out_req->ndp_config.ndp_cfg);
qdf_mem_free(out_req);
return NULL;
}
QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
void *in_req, uint32_t req_type)
{
void *req;
QDF_STATUS status;
struct scheduler_msg msg = {0};
@@ -333,8 +393,22 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
return QDF_STATUS_E_NULL_VALUE;
}
switch (req_type) {
case NDP_INITIATOR_REQ:
req = ucfg_nan_copy_intiator_req(vdev, in_req);
break;
default:
nan_err("in correct message req type: %d", req_type);
return QDF_STATUS_E_INVAL;
}
if (!req) {
nan_err("failed to create local copy");
return QDF_STATUS_E_INVAL;
}
msg.type = req_type;
msg.bodyptr = in_req;
msg.bodyptr = req;
msg.callback = nan_scheduled_msg_handler;
status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg);
if (QDF_IS_STATUS_ERROR(status)) {
@@ -345,6 +419,20 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
return status;
}
void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_vdev *vdev,
uint32_t type, void *msg)
{
struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
if (!psoc_obj) {
nan_err("nan psoc priv object is NULL");
return;
}
psoc_obj->cb_obj.os_if_event_handler(psoc, vdev, type, msg);
}
int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
struct nan_callbacks *cb_obj,
void (os_if_event_handler)(
@@ -370,5 +458,24 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
psoc_obj->cb_obj.drv_ndi_delete_rsp_handler =
cb_obj->drv_ndi_delete_rsp_handler;
psoc_obj->cb_obj.get_peer_idx = cb_obj->get_peer_idx;
psoc_obj->cb_obj.new_peer_ind = cb_obj->new_peer_ind;
return 0;
}
int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
struct nan_callbacks *cb_obj)
{
struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
if (!psoc_obj) {
nan_err("nan psoc priv object is NULL");
return -EINVAL;
}
psoc_obj->cb_obj.add_ndi_peer = cb_obj->add_ndi_peer;
psoc_obj->cb_obj.delete_peers_by_addr = cb_obj->delete_peers_by_addr;
return 0;
}