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

qcacld-3.0: NAN datapath cleanup

Browse source 
Cleanup NAN datapath legacy code left after NAN componentization

Change-Id: I5828002d2363e01f63b0a643a0c59abd52bc4f19
CRs-Fixed: 2117687
This commit is contained in:
Naveen Rawat 2017-09-15 12:19:22 -07:00 • committed by snandini
commit 7154974018
23 changed files with 149 additions and 4410 deletions
Download patch file Download diff file Expand all files Collapse all files

7
core/hdd/inc/wlan_hdd_main.h
View file

@ -654,9 +654,6 @@ struct hdd_station_ctx {
int sta_debug_state;
uint8_t broadcast_staid;
struct hdd_mon_set_ch_info ch_info;
#if defined(WLAN_FEATURE_NAN_DATAPATH) && !defined(WLAN_FEATURE_NAN_CONVERGENCE)
struct nan_datapath_ctx ndp_ctx;
#endif
bool ap_supports_immediate_power_save;
};
@ -1243,10 +1240,6 @@ struct hdd_adapter {
#define WLAN_HDD_GET_SAP_CTX_PTR(adapter) ((adapter)->session.ap.sap_context)
#ifdef WLAN_FEATURE_NAN_DATAPATH
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
#define WLAN_HDD_GET_NDP_CTX_PTR(adapter) \
(&(adapter)->session.station.ndp_ctx)
#endif /* WLAN_FEATURE_NAN_CONVERGENCE */
#define WLAN_HDD_IS_NDP_ENABLED(hdd_ctx) ((hdd_ctx)->nan_datapath_enabled)
#else
/* WLAN_HDD_GET_NDP_CTX_PTR and WLAN_HDD_GET_NDP_WEXT_STATE_PTR are not defined

6
core/hdd/src/wlan_hdd_main.c
View file

@ -2418,7 +2418,6 @@ static void hdd_register_policy_manager_callback(
}
#endif
#ifdef WLAN_FEATURE_NAN_CONVERGENCE
static void hdd_nan_register_callbacks(struct hdd_context *hdd_ctx)
{
struct nan_callbacks cb_obj = {0};
@ -2436,11 +2435,6 @@ static void hdd_nan_register_callbacks(struct hdd_context *hdd_ctx)
os_if_nan_register_hdd_callbacks(hdd_ctx->hdd_psoc, &cb_obj);
}
#else
static void hdd_nan_register_callbacks(struct hdd_context *hdd_ctx)
{
}
#endif
#ifdef CONFIG_LEAK_DETECTION
/**

1703
core/hdd/src/wlan_hdd_nan_datapath.c
View file

File diff suppressed because it is too large Load diff

160
core/hdd/src/wlan_hdd_nan_datapath.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -50,164 +50,6 @@ struct wireless_dev;
#define WLAN_HDD_IS_NDI_CONNECTED(adapter) (false)
#endif /* WLAN_FEATURE_NAN_DATAPATH */
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
#define NDP_QOS_INFO_LEN 255
#define NDP_APP_INFO_LEN 255
#define NDP_PMK_LEN 32
#define NDP_SCID_BUF_LEN 256
#define NDP_NUM_INSTANCE_ID 255
/**
* enum qca_wlan_vendor_attr_ndp_params - vendor attribute parameters
* @QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD: NDP Sub command
* @QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID: Transaction id reference
* @QCA_WLAN_VENDOR_ATTR_NDP_STATUS_ID: NDP status id
* @QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID: Service instance id
* @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL: Requested channel
* @QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR: Peer discovery mac addr
* @QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR: Iface name
* @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY: Security configuration
* @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS: Qos configuration
* @QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO: Application info
* @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID: NDP instance id
* @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY: NDP instance id array
* @QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE: Schedule response
* @QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR: NDI mac address
* @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE: Driver return status
* @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE: Driver return value
* @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG: Channel config request type
* @QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE: Cipher Suit ID
* @QCA_WLAN_VENDOR_ATTR_NDP_PMK: Pairwise Master Key
* @QCA_WLAN_VENDOR_ATTR_NDP_SCID: Security Context ID
*/
enum qca_wlan_vendor_attr_ndp_params {
QCA_WLAN_VENDOR_ATTR_NDP_PARAM_INVALID = 0,
QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID,
QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID,
QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL,
QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR,
QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR,
/* CONFIG_SECURITY is deprecated, use NCS_SK_TYPE/PMK/SCID instead */
QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY,
QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS,
QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO,
QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY,
QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE,
QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR,
QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE,
QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE,
QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG,
QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE,
QCA_WLAN_VENDOR_ATTR_NDP_PMK,
QCA_WLAN_VENDOR_ATTR_NDP_SCID,
QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST,
QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX =
QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST - 1,
};
/**
* enum qca_wlan_vendor_attr_ndp_cfg_security - vendor security attribute
* @QCA_WLAN_VENDOR_ATTR_NDP_SECURITY_ENABLE: Security enabled
*/
enum qca_wlan_vendor_attr_ndp_cfg_security {
QCA_WLAN_VENDOR_ATTR_NDP_SECURITY_ENABLE = 1,
};
/**
* enum qca_wlan_vendor_attr_ndp_qos - vendor qos attribute
* @QCA_WLAN_VENDOR_ATTR_NDP_QOS_CONFIG: NDP QoS configuration
*/
enum qca_wlan_vendor_attr_ndp_qos {
QCA_WLAN_VENDOR_ATTR_NDP_QOS_CONFIG = 1,
};
/**
* enum qca_wlan_vendor_attr_ndp_sub_cmd_value - NDP subcmd value
* @QCA_WLAN_VENDOR_ATTR_NDP_INVALID: Unused subcmd value
* @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE: iface create
* @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE: iface delete
* @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST: NDP initiator request
* @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE: NDP initiator response
* @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: NDP responder request
* @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE: NDP responder response
* @QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST: NDP end request
* @QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE: NDP end response
* @QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND: NDP request indication
* @QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND: NDP confirm indication
* @QCA_WLAN_VENDOR_ATTR_NDP_END_IND: NDP End indication
*/
enum qca_wlan_vendor_attr_ndp_sub_cmd_value {
QCA_WLAN_VENDOR_ATTR_NDP_INVALID = 0,
QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE = 1,
QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE = 2,
QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST = 3,
QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE = 4,
QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST = 5,
QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE = 6,
QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST = 7,
QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE = 8,
QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND = 9,
QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND = 10,
QCA_WLAN_VENDOR_ATTR_NDP_END_IND = 11
};
/** enum nan_datapath_state - NAN datapath states
* @NAN_DATA_NDI_CREATING_STATE: NDI create is in progress
* @NAN_DATA_NDI_CREATED_STATE: NDI successfully crated
* @NAN_DATA_NDI_DELETING_STATE: NDI delete is in progress
* @NAN_DATA_NDI_DELETED_STATE: NDI delete is in progress
* @NAN_DATA_PEER_CREATE_STATE: Peer create is in progress
* @NAN_DATA_PEER_DELETE_STATE: Peer delete is in progrss
* @NAN_DATA_CONNECTING_STATE: Data connection in progress
* @NAN_DATA_CONNECTED_STATE: Data connection successful
* @NAN_DATA_END_STATE: NDP end is in progress
* @NAN_DATA_DISCONNECTED_STATE: NDP is in disconnected state
*/
enum nan_datapath_state {
NAN_DATA_NDI_CREATING_STATE = 0,
NAN_DATA_NDI_CREATED_STATE = 1,
NAN_DATA_NDI_DELETING_STATE = 2,
NAN_DATA_NDI_DELETED_STATE = 3,
NAN_DATA_PEER_CREATE_STATE = 4,
NAN_DATA_PEER_DELETE_STATE = 5,
NAN_DATA_CONNECTING_STATE = 6,
NAN_DATA_CONNECTED_STATE = 7,
NAN_DATA_END_STATE = 8,
NAN_DATA_DISCONNECTED_STATE = 9,
};
/**
* struct nan_datapath_ctx - context for nan data path
* @state: Current state of NDP
* @active_ndp_sessions: active ndp sessions per adapter
* @active_ndp_peers: number of active ndp peers
* @ndp_create_transaction_id: transaction id for create req
* @ndp_delete_transaction_id: transaction id for delete req
* @ndp_key_installed: NDP security key installed
* @ndp_enc_key: NDP encryption key info
* @ndp_debug_state: debug state info
* @ndi_delete_rsp_reason: reason code for ndi_delete rsp
* @ndi_delete_rsp_status: status for ndi_delete rsp
*/
struct nan_datapath_ctx {
enum nan_datapath_state state;
/* idx in following array should follow conn_info.peerMacAddress */
uint32_t active_ndp_sessions[MAX_PEERS];
uint32_t active_ndp_peers;
uint16_t ndp_create_transaction_id;
uint16_t ndp_delete_transaction_id;
bool ndp_key_installed;
tCsrRoamSetKey ndp_enc_key;
uint32_t ndp_debug_state;
uint32_t ndi_delete_rsp_reason;
uint32_t ndi_delete_rsp_status;
};
#endif
#ifdef WLAN_FEATURE_NAN_DATAPATH
void hdd_ndp_print_ini_config(struct hdd_context *hdd_ctx);
void hdd_nan_datapath_target_config(struct hdd_context *hdd_ctx,

11
core/mac/inc/wni_api.h
View file

@ -223,17 +223,6 @@ enum eWniMsgTypes {
eWNI_SME_MON_INIT_SESSION,
eWNI_SME_PDEV_SET_HT_VHT_IE,
eWNI_SME_SET_VDEV_IES_PER_BAND,
eWNI_SME_NDP_INITIATOR_REQ,
eWNI_SME_NDP_INITIATOR_RSP,
eWNI_SME_NDP_NEW_PEER_IND,
eWNI_SME_NDP_CONFIRM_IND,
eWNI_SME_NDP_INDICATION,
eWNI_SME_NDP_RESPONDER_REQ,
eWNI_SME_NDP_RESPONDER_RSP,
eWNI_SME_NDP_END_REQ,
eWNI_SME_NDP_END_RSP,
eWNI_SME_NDP_PEER_DEPARTED_IND,
eWNI_SME_NDP_END_IND,
eWNI_SME_SEND_DISASSOC_FRAME,
eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE,
eWNI_SME_DEFAULT_SCAN_IE,

10
core/mac/src/pe/lim/lim_api.c
View file

@ -740,7 +740,6 @@ static void lim_register_debug_callback(void)
qdf_register_debug_callback(QDF_MODULE_ID_PE, &lim_state_info_dump);
}
#ifdef WLAN_FEATURE_NAN_CONVERGENCE
static void lim_nan_register_callbacks(tpAniSirGlobal mac_ctx)
{
struct nan_callbacks cb_obj = {0};
@ -751,11 +750,6 @@ static void lim_nan_register_callbacks(tpAniSirGlobal mac_ctx)
ucfg_nan_register_lim_callbacks(mac_ctx->psoc, &cb_obj);
}
#else
static void lim_nan_register_callbacks(tpAniSirGlobal mac_ctx)
{
}
#endif
/*
* pe_shutdown_notifier_cb - Shutdown notifier callback
@ -1282,10 +1276,6 @@ void pe_register_callbacks_with_wma(tpAniSirGlobal pMac,
ready_req->pe_roam_synch_cb);
if (status != QDF_STATUS_SUCCESS)
pe_err("Registering roaming callbacks with WMA failed");
status = wma_register_ndp_cb(lim_handle_ndp_event_message);
if (status != QDF_STATUS_SUCCESS)
pe_err("Registering NDP callbacks with WMA failed");
}
/**

3
core/mac/src/pe/lim/lim_process_message_queue.c
View file

@ -1538,9 +1538,6 @@ static void lim_process_messages(tpAniSirGlobal mac_ctx,
case eWNI_SME_REGISTER_MGMT_FRAME_CB:
case eWNI_SME_EXT_CHANGE_CHANNEL:
case eWNI_SME_ROAM_SCAN_OFFLOAD_REQ:
case eWNI_SME_NDP_INITIATOR_REQ:
case eWNI_SME_NDP_RESPONDER_REQ:
case eWNI_SME_NDP_END_REQ:
/* These messages are from HDD.No need to respond to HDD */
lim_process_normal_hdd_msg(mac_ctx, msg, false);
break;

5
core/mac/src/pe/lim/lim_process_sme_req_messages.c
View file

@ -5022,11 +5022,6 @@ bool lim_process_sme_req_messages(tpAniSirGlobal pMac,
case eWNI_SME_SET_VDEV_IES_PER_BAND:
lim_process_set_vdev_ies_per_band(pMac, pMsgBuf);
break;
case eWNI_SME_NDP_END_REQ:
case eWNI_SME_NDP_INITIATOR_REQ:
case eWNI_SME_NDP_RESPONDER_REQ:
lim_handle_ndp_request_message(pMac, pMsg);
break;
case eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE:
lim_process_sme_update_access_policy_vendor_ie(pMac, pMsgBuf);
break;

500
core/mac/src/pe/nan/nan_datapath.c
View file

@ -31,66 +31,9 @@
#include "lim_types.h"
#include "lim_send_messages.h"
#include "wma_nan_datapath.h"
#ifdef WLAN_FEATURE_NAN_CONVERGENCE
#include "os_if_nan.h"
#include "nan_public_structs.h"
#include "nan_ucfg_api.h"
#endif
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* lim_send_ndp_event_to_sme() - generic function to prepare and send NDP
* message to SME.
* @mac_ctx: handle to mac context structure
* @msg_type: sme message type to send
* @body_ptr: buffer
* @len: buffer length
* @body_val: value
*
* Return: None
*/
static void lim_send_ndp_event_to_sme(tpAniSirGlobal mac_ctx, uint32_t msg_type,
void *body_ptr, uint32_t len, uint32_t body_val)
{
struct scheduler_msg mmh_msg = {0};
mmh_msg.type = msg_type;
if (len && body_ptr) {
mmh_msg.bodyptr = qdf_mem_malloc(len);
if (NULL == mmh_msg.bodyptr) {
pe_err("Malloc failed");
return;
}
qdf_mem_copy(mmh_msg.bodyptr, body_ptr, len);
} else {
mmh_msg.bodyval = body_val;
}
lim_sys_process_mmh_msg_api(mac_ctx, &mmh_msg, ePROT);
}
static void lim_send_peer_departed(tpAniSirGlobal mac_ctx,
struct sme_ndp_peer_ind *ind)
{
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_PEER_DEPARTED_IND,
ind, sizeof(*ind), false);
}
#else
static void lim_send_peer_departed(tpAniSirGlobal mac_ctx,
struct sme_ndp_peer_ind *ind)
{
struct nan_datapath_peer_ind peer_ind = {0};
struct wlan_objmgr_psoc *psoc = mac_ctx->psoc;
struct wlan_objmgr_vdev *vdev =
wlan_objmgr_get_vdev_by_id_from_psoc(psoc, ind->session_id,
WLAN_NAN_ID);
peer_ind.session_id = ind->session_id;
qdf_mem_copy(&peer_ind.peer_mac_addr, &ind->peer_mac_addr,
sizeof(struct qdf_mac_addr));
peer_ind.sta_id = ind->sta_id;
ucfg_nan_event_handler(psoc, vdev, NDP_PEER_DEPARTED, &peer_ind);
}
#endif
/**
* lim_add_ndi_peer() - Function to add ndi peer
@ -172,103 +115,6 @@ QDF_STATUS lim_add_ndi_peer_converged(uint32_t vdev_id,
return lim_add_ndi_peer(mac_ctx, vdev_id, peer_mac_addr);
}
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* lim_handle_ndp_indication_event() - Function to handle SIR_HAL_NDP_INDICATION
* event from WMA
* @mac_ctx: handle to mac structure
* @ndp_ind: ndp indication event params
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
static QDF_STATUS lim_handle_ndp_indication_event(tpAniSirGlobal mac_ctx,
struct ndp_indication_event *ndp_ind)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
pe_info("role: %d, vdev: %d, csid: %d, peer_mac_addr "
MAC_ADDRESS_STR,
ndp_ind->role, ndp_ind->vdev_id, ndp_ind->ncs_sk_type,
MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes));
if ((ndp_ind->role == NDP_ROLE_INITIATOR) ||
((NDP_ROLE_RESPONDER == ndp_ind->role) &&
(NDP_ACCEPT_POLICY_ALL == ndp_ind->policy))) {
status = lim_add_ndi_peer(mac_ctx, ndp_ind->vdev_id,
ndp_ind->peer_mac_addr);
if (QDF_STATUS_SUCCESS != status) {
pe_err("Couldn't add ndi peer, ndp_role: %d",
ndp_ind->role);
goto ndp_indication_failed;
}
}
if (NDP_ROLE_RESPONDER == ndp_ind->role)
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_INDICATION,
ndp_ind, sizeof(*ndp_ind), 0);
/*
* With NDP indication if peer does not exists already add_sta is
* executed resulting in new peer else no action is taken. Note that
* new_peer event is not necessary event and should not be sent if case
* anything fails in this function. Rather eWNI_SME_NDP_CONFIRM_IND is
* used to indicate success of final operation and abscence of it can be
* used by service layer to identify failure.
*/
ndp_indication_failed:
/*
* Free config if failure or for NDP_ROLE_INITIATOR role
* As for success responder case this info is sent till HDD
* and will be freed in sme.
*/
if (status != QDF_STATUS_SUCCESS ||
NDP_ROLE_INITIATOR == ndp_ind->role) {
qdf_mem_free(ndp_ind->ndp_config.ndp_cfg);
qdf_mem_free(ndp_ind->ndp_info.ndp_app_info);
ndp_ind->ndp_config.ndp_cfg = NULL;
ndp_ind->ndp_info.ndp_app_info = NULL;
}
return status;
}
/**
* lim_ndp_responder_rsp_handler() - Handler for NDP responder rsp
* @mac_ctx: handle to mac structure
* @ndp_rsp: pointer to rsp message
* @bodyval: value
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
static QDF_STATUS lim_ndp_responder_rsp_handler(tpAniSirGlobal mac_ctx,
struct ndp_responder_rsp_event *rsp_ind, uint32_t bodyval)
{
QDF_STATUS ret_val = QDF_STATUS_SUCCESS;
if ((NULL == rsp_ind) || bodyval) {
pe_err("rsp_ind is NULL or bodyval %d", bodyval);
/* msg to unblock SME, but not send rsp to HDD */
bodyval = true;
ret_val = QDF_STATUS_E_INVAL;
goto responder_rsp;
}
if (QDF_STATUS_SUCCESS == rsp_ind->status &&
rsp_ind->create_peer == true) {
ret_val = lim_add_ndi_peer(mac_ctx, rsp_ind->vdev_id,
rsp_ind->peer_mac_addr);
if (QDF_STATUS_SUCCESS != ret_val) {
pe_err("Couldn't add ndi peer");
rsp_ind->status = QDF_STATUS_E_FAILURE;
}
}
responder_rsp:
/* send eWNI_SME_NDP_RESPONDER_RSP */
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_RESPONDER_RSP,
bodyval ? NULL : rsp_ind,
bodyval ? 0 : sizeof(*rsp_ind), bodyval);
return ret_val;
}
#endif /* WLAN_FEATURE_NAN_CONVERGENCE */
/**
* lim_ndp_delete_peer_by_addr() - Delete NAN data peer, given addr and vdev_id
* @mac_ctx: handle to mac context
@ -424,43 +270,6 @@ void lim_ndp_delete_peers_converged(struct peer_nan_datapath_map *ndp_map,
num_peers);
}
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* lim_ndp_end_indication_handler() - Handler for NDP end indication
* @mac_ctx: handle to mac context
* @ind_buf: pointer to indication buffer
*
* It deletes peers from ndp_map. Response of that operation goes
* to LIM and HDD. But peer information does not go to service layer.
* ndp_id_list is sent to service layer; it is not interpreted by the
* driver.
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
static QDF_STATUS lim_ndp_end_indication_handler(tpAniSirGlobal mac_ctx,
uint32_t *ind_buf)
{
struct ndp_end_indication_event *ndp_event_buf =
(struct ndp_end_indication_event *)ind_buf;
int buf_size;
if (!ind_buf) {
pe_err("NDP end indication buffer is NULL");
return QDF_STATUS_E_INVAL;
}
lim_ndp_delete_peers(mac_ctx, ndp_event_buf->ndp_map,
ndp_event_buf->num_ndp_ids);
buf_size = sizeof(*ndp_event_buf) + ndp_event_buf->num_ndp_ids *
sizeof(ndp_event_buf->ndp_map[0]);
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_END_IND,
ndp_event_buf, buf_size, false);
return QDF_STATUS_SUCCESS;
}
#endif
/**
* lim_process_ndi_del_sta_rsp() - Handle WDA_DELETE_STA_RSP in eLIM_NDI_ROLE
* @mac_ctx: Global MAC context
@ -473,10 +282,12 @@ void lim_process_ndi_del_sta_rsp(tpAniSirGlobal mac_ctx,
struct scheduler_msg *lim_msg,
tpPESession pe_session)
{
tpDeleteStaParams del_sta_params = (tpDeleteStaParams) lim_msg->bodyptr;
tpDphHashNode sta_ds;
tpDeleteStaParams del_sta_params = (tpDeleteStaParams) lim_msg->bodyptr;
tSirResultCodes status = eSIR_SME_SUCCESS;
struct sme_ndp_peer_ind peer_ind;
struct wlan_objmgr_vdev *vdev;
struct wlan_objmgr_psoc *psoc = mac_ctx->psoc;
struct nan_datapath_peer_ind peer_ind;
if (!del_sta_params) {
pe_err("del_sta_params is NULL");
@ -510,277 +321,24 @@ void lim_process_ndi_del_sta_rsp(tpAniSirGlobal mac_ctx,
* Copy peer info in del peer indication before
* lim_delete_dph_hash_entry is called as this will be lost.
*/
peer_ind.msg_len = sizeof(peer_ind);
peer_ind.msg_type = eWNI_SME_NDP_PEER_DEPARTED_IND;
peer_ind.session_id = pe_session->smeSessionId;
peer_ind.sta_id = sta_ds->staIndex;
qdf_mem_copy(&peer_ind.peer_mac_addr.bytes,
sta_ds->staAddr, sizeof(tSirMacAddr));
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
pe_session->smeSessionId, WLAN_NAN_ID);
lim_release_peer_idx(mac_ctx, sta_ds->assocId, pe_session);
lim_delete_dph_hash_entry(mac_ctx, sta_ds->staAddr, sta_ds->assocId,
pe_session);
pe_session->limMlmState = eLIM_MLM_IDLE_STATE;
lim_send_peer_departed(mac_ctx, &peer_ind);
ucfg_nan_event_handler(psoc, vdev, NDP_PEER_DEPARTED, &peer_ind);
skip_event:
qdf_mem_free(del_sta_params);
lim_msg->bodyptr = NULL;
}
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* lim_handle_ndp_event_message() - Handler for NDP events/RSP from WMA
* @mac_ctx: handle to mac structure
* @msg: pointer to message
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS lim_handle_ndp_event_message(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
switch (msg->type) {
case SIR_HAL_NDP_CONFIRM: {
struct ndp_confirm_event *ndp_confirm = msg->bodyptr;
if (ndp_confirm->rsp_code != NDP_RESPONSE_ACCEPT &&
ndp_confirm->num_active_ndps_on_peer == 0) {
/*
* This peer was created at ndp_indication but
* ndp_confirm failed, so it needs to be deleted
*/
pe_err("NDP confirm with reject and no active ndp sessions. deleting peer: "MAC_ADDRESS_STR" on vdev_id: %d",
MAC_ADDR_ARRAY(
ndp_confirm->peer_ndi_mac_addr.bytes),
ndp_confirm->vdev_id);
lim_ndp_delete_peer_by_addr(mac_ctx,
ndp_confirm->vdev_id,
ndp_confirm->peer_ndi_mac_addr);
}
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_CONFIRM_IND,
msg->bodyptr, sizeof(*ndp_confirm),
msg->bodyval);
break;
}
case SIR_HAL_NDP_INITIATOR_RSP:
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_INITIATOR_RSP,
msg->bodyptr, sizeof(struct ndp_initiator_rsp),
msg->bodyval);
break;
case SIR_HAL_NDP_INDICATION: {
struct ndp_indication_event *ndp_ind = msg->bodyptr;
status = lim_handle_ndp_indication_event(mac_ctx, ndp_ind);
break;
}
case SIR_HAL_NDP_RESPONDER_RSP:
status = lim_ndp_responder_rsp_handler(mac_ctx, msg->bodyptr,
msg->bodyval);
break;
case SIR_HAL_NDP_END_RSP: {
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_END_RSP,
msg->bodyptr,
sizeof(struct ndp_end_rsp_event),
msg->bodyval);
break;
}
case SIR_HAL_NDP_END_IND:
status = lim_ndp_end_indication_handler(mac_ctx, msg->bodyptr);
break;
default:
pe_err("Unhandled NDP event: %d", msg->type);
status = QDF_STATUS_E_NOSUPPORT;
break;
}
/*
* No need to free body pointer, since the function is serving purpose
* of callback and bodyptr if allocated is freed by caller itself
*/
return status;
}
/**
* lim_process_sme_ndp_initiator_req() - Handler for eWNI_SME_NDP_INITIATOR_REQ
* from SME.
* @mac_ctx: handle to mac structure
* @ndp_msg: ndp initiator request msg
*
* Return: Status of operation
*/
static QDF_STATUS lim_process_sme_ndp_initiator_req(tpAniSirGlobal mac_ctx,
void *ndp_msg)
{
struct scheduler_msg msg = {0};
QDF_STATUS status;
struct sir_sme_ndp_initiator_req *sme_req =
(struct sir_sme_ndp_initiator_req *)ndp_msg;
struct ndp_initiator_req *wma_req;
if (NULL == ndp_msg) {
pe_err("invalid ndp_req");
status = QDF_STATUS_E_INVAL;
goto send_initiator_rsp;
}
wma_req = qdf_mem_malloc(sizeof(*wma_req));
if (wma_req == NULL) {
pe_err("malloc failed");
status = QDF_STATUS_E_NOMEM;
goto send_initiator_rsp;
}
qdf_mem_copy(wma_req, &sme_req->req, sizeof(*wma_req));
msg.type = SIR_HAL_NDP_INITIATOR_REQ;
msg.reserved = 0;
msg.bodyptr = wma_req;
msg.bodyval = 0;
pe_debug("sending WDA_NDP_INITIATOR_REQ to WMA");
MTRACE(mac_trace_msg_tx(mac_ctx, NO_SESSION, msg.type));
if (eSIR_SUCCESS != wma_post_ctrl_msg(mac_ctx, &msg))
pe_err("wma_post_ctrl_msg failed");
return QDF_STATUS_SUCCESS;
send_initiator_rsp:
/* msg to unblock SME, but not send rsp to HDD */
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_INITIATOR_RSP,
NULL, 0, true);
return status;
}
/**
* lim_process_sme_ndp_responder_req() - Handler for NDP responder req
* @mac_ctx: handle to mac structure
* @ndp_msg: pointer to message
*
* Return: QDF_STATUS_SUCCESS on success or failure code in case of failure
*/
static QDF_STATUS lim_process_sme_ndp_responder_req(tpAniSirGlobal mac_ctx,
struct sir_sme_ndp_responder_req *lim_msg)
{
struct scheduler_msg msg = {0};
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct ndp_responder_req *responder_req;
if (NULL == lim_msg) {
pe_err("ndp_msg is NULL");
status = QDF_STATUS_E_INVAL;
goto send_failure_rsp;
}
responder_req = qdf_mem_malloc(sizeof(*responder_req));
if (NULL == responder_req) {
pe_err("Unable to allocate memory for responder_req");
status = QDF_STATUS_E_NOMEM;
goto send_failure_rsp;
}
qdf_mem_copy(responder_req, &lim_msg->req, sizeof(*responder_req));
msg.type = SIR_HAL_NDP_RESPONDER_REQ;
msg.reserved = 0;
msg.bodyptr = responder_req;
msg.bodyval = 0;
pe_debug("sending SIR_HAL_NDP_RESPONDER_REQ to WMA");
MTRACE(mac_trace_msg_tx(mac_ctx, NO_SESSION, msg.type));
if (eSIR_SUCCESS != wma_post_ctrl_msg(mac_ctx, &msg)) {
pe_err("wma_post_ctrl_msg failed");
status = QDF_STATUS_E_FAILURE;
qdf_mem_free(responder_req);
goto send_failure_rsp;
}
return status;
send_failure_rsp:
/* msg to unblock SME, but not send rsp to HDD */
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_RESPONDER_RSP,
NULL, 0, true);
return status;
}
/**
* lim_process_sme_ndp_data_end_req() - Handler for eWNI_SME_NDP_END_REQ
* from SME.
* @mac_ctx: handle to mac context
* @sme_msg: ndp data end request msg
*
* Return: Status of operation
*/
static QDF_STATUS lim_process_sme_ndp_data_end_req(tpAniSirGlobal mac_ctx,
struct sir_sme_ndp_end_req *sme_msg)
{
struct scheduler_msg msg = {0};
uint32_t len;
QDF_STATUS status = QDF_STATUS_SUCCESS;
if (NULL == sme_msg) {
pe_err("invalid ndp_req");
/* msg to unblock SME, but not send rsp to HDD */
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_END_RSP, NULL,
0, true);
return QDF_STATUS_E_INVAL;
}
msg.type = SIR_HAL_NDP_END_REQ;
msg.reserved = 0;
len = sizeof(*sme_msg->req) + (sme_msg->req->num_ndp_instances *
sizeof(uint32_t));
msg.bodyptr = qdf_mem_malloc(len);
if (NULL == msg.bodyptr) {
/* msg to unblock SME, but not send rsp to HDD */
lim_send_ndp_event_to_sme(mac_ctx, eWNI_SME_NDP_END_RSP, NULL,
0, true);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(msg.bodyptr, sme_msg->req, len);
msg.bodyval = 0;
pe_debug("sending SIR_HAL_NDP_END_REQ to WMA");
MTRACE(mac_trace_msg_tx(mac_ctx, NO_SESSION, msg.type));
if (eSIR_SUCCESS != wma_post_ctrl_msg(mac_ctx, &msg)) {
pe_err("wma_post_ctrl_msg failed");
status = QDF_STATUS_E_FAILURE;
}
return status;
}
/**
* lim_handle_ndp_request_message() - Handler for NDP req from SME
* @mac_ctx: handle to mac structure
* @msg: pointer to message
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS lim_handle_ndp_request_message(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg)
{
QDF_STATUS status;
switch (msg->type) {
case eWNI_SME_NDP_END_REQ:
status = lim_process_sme_ndp_data_end_req(mac_ctx,
msg->bodyptr);
break;
case eWNI_SME_NDP_INITIATOR_REQ:
status = lim_process_sme_ndp_initiator_req(mac_ctx,
msg->bodyptr);
break;
case eWNI_SME_NDP_RESPONDER_REQ:
status = lim_process_sme_ndp_responder_req(mac_ctx,
msg->bodyptr);
break;
default:
pe_err("Unhandled NDP request: %d", msg->type);
status = QDF_STATUS_E_NOSUPPORT;
break;
}
return status;
}
#endif
/**
* lim_process_ndi_mlm_add_bss_rsp() - Process ADD_BSS response for NDI
* @mac_ctx: Pointer to Global MAC structure
@ -887,49 +445,6 @@ end:
}
}
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* lim_send_sme_ndp_add_sta_rsp() - prepares and send new peer ind to SME
* @mac_ctx: handle to mac structure
* @session: session pointer
* @add_sta_rsp: add sta response struct
*
* Return: status of operation
*/
static QDF_STATUS lim_send_sme_ndp_add_sta_rsp(tpAniSirGlobal mac_ctx,
tpPESession session,
tAddStaParams *add_sta_rsp)
{
struct scheduler_msg mmh_msg = {0};
struct sme_ndp_peer_ind *new_peer_ind;
mmh_msg.type = eWNI_SME_NDP_NEW_PEER_IND;
if (NULL == add_sta_rsp) {
pe_err("Invalid add_sta_rsp");
return QDF_STATUS_E_INVAL;
}
new_peer_ind = qdf_mem_malloc(sizeof(*new_peer_ind));
if (NULL == new_peer_ind) {
pe_err("Failed to allocate memory");
return QDF_STATUS_E_NOMEM;
}
/* this message is going to HDD, fill in sme session id */
new_peer_ind->session_id = add_sta_rsp->smesessionId;
new_peer_ind->msg_len = sizeof(struct sme_ndp_peer_ind);
new_peer_ind->msg_type = eWNI_SME_NDP_NEW_PEER_IND;
qdf_mem_copy(new_peer_ind->peer_mac_addr.bytes, add_sta_rsp->staMac,
sizeof(tSirMacAddr));
new_peer_ind->sta_id = add_sta_rsp->staIdx;
mmh_msg.bodyptr = new_peer_ind;
mmh_msg.bodyval = 0;
lim_sys_process_mmh_msg_api(mac_ctx, &mmh_msg, ePROT);
return QDF_STATUS_SUCCESS;
}
#else
static QDF_STATUS lim_send_sme_ndp_add_sta_rsp(tpAniSirGlobal mac_ctx,
tpPESession session,
tAddStaParams *add_sta_rsp)
@ -973,7 +488,6 @@ static QDF_STATUS lim_send_sme_ndp_add_sta_rsp(tpAniSirGlobal mac_ctx,
wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
return QDF_STATUS_SUCCESS;
}
#endif
/**
* lim_ndp_add_sta_rsp() - handles add sta rsp for NDP from WMA

17
core/mac/src/pe/nan/nan_datapath.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -149,26 +149,11 @@ static inline void lim_ndp_add_sta_rsp(tpAniSirGlobal mac_ctx,
#endif /* WLAN_FEATURE_NAN_DATAPATH || WLAN_FEATURE_NAN_CONVERGENCE */
#if defined(WLAN_FEATURE_NAN_DATAPATH) && !defined(WLAN_FEATURE_NAN_CONVERGENCE)
/* Function to process NDP requests */
QDF_STATUS lim_handle_ndp_request_message(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg);
/* Function to process NDP events */
QDF_STATUS lim_handle_ndp_event_message(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg);
#else
static inline QDF_STATUS lim_handle_ndp_request_message(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS lim_handle_ndp_event_message(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg)
{
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_FEATURE_NAN_DATAPATH && !WLAN_FEATURE_NAN_CONVERGENCE */
#endif /* __MAC_NAN_DATAPATH_H */

11
core/mac/src/sys/legacy/src/utils/src/mac_trace.c
View file

@ -382,17 +382,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_SME_MON_INIT_SESSION);
CASE_RETURN_STRING(eWNI_SME_PDEV_SET_HT_VHT_IE);
CASE_RETURN_STRING(eWNI_SME_SET_VDEV_IES_PER_BAND);
CASE_RETURN_STRING(eWNI_SME_NDP_INITIATOR_REQ);
CASE_RETURN_STRING(eWNI_SME_NDP_INITIATOR_RSP);
CASE_RETURN_STRING(eWNI_SME_NDP_NEW_PEER_IND);
CASE_RETURN_STRING(eWNI_SME_NDP_CONFIRM_IND);
CASE_RETURN_STRING(eWNI_SME_NDP_INDICATION);
CASE_RETURN_STRING(eWNI_SME_NDP_RESPONDER_REQ);
CASE_RETURN_STRING(eWNI_SME_NDP_RESPONDER_RSP);
CASE_RETURN_STRING(eWNI_SME_NDP_END_REQ);
CASE_RETURN_STRING(eWNI_SME_NDP_END_RSP);
CASE_RETURN_STRING(eWNI_SME_NDP_PEER_DEPARTED_IND);
CASE_RETURN_STRING(eWNI_SME_NDP_END_IND);
CASE_RETURN_STRING(eWNI_SME_SEND_DISASSOC_FRAME);
CASE_RETURN_STRING(eWNI_SME_UPDATE_ACCESS_POLICY_VENDOR_IE);
CASE_RETURN_STRING(eWNI_SME_DEFAULT_SCAN_IE);

8
core/sme/inc/csr_api.h
View file

@ -1495,14 +1495,6 @@ struct csr_roam_info {
#ifdef WLAN_FEATURE_NAN_DATAPATH
union {
struct sme_ndp_peer_ind ndp_peer_ind_params;
struct ndp_schedule_update_rsp ndp_sched_upd_rsp_params;
struct ndp_end_indication_event *ndp_end_ind_params;
struct ndp_end_rsp_event *ndp_end_rsp_params;
struct ndp_confirm_event ndp_confirm_params;
struct ndp_responder_rsp_event ndp_responder_rsp_params;
struct ndp_indication_event ndp_indication_params;
struct ndp_initiator_rsp ndp_init_rsp_params;
struct ndi_create_rsp ndi_create_params;
struct ndi_delete_rsp ndi_delete_params;
} ndp;

7
core/sme/inc/sme_inside.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -184,11 +184,6 @@ typedef struct tagSmeCmd {
struct s_nss_update_cmd nss_update_cmd;
struct sir_dual_mac_config set_dual_mac_cmd;
struct sir_antenna_mode_param set_antenna_mode_cmd;
#if defined(WLAN_FEATURE_NAN_DATAPATH) && !defined(WLAN_FEATURE_NAN_CONVERGENCE)
struct ndp_initiator_req initiator_req;
struct ndp_responder_req responder_req;
struct ndp_end_req *data_end_req;
#endif
} u;
} tSmeCmd;

5
core/sme/inc/sme_internal.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2011-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -86,9 +86,6 @@ typedef enum eSmeCommandType {
e_sme_command_nss_update,
e_sme_command_set_dual_mac_config,
e_sme_command_set_antenna_mode,
eSmeCommandNdpInitiatorRequest,
eSmeCommandNdpResponderRequest,
eSmeCommandNdpDataEndInitiatorRequest,
} eSmeCommandType;
typedef enum eSmeState {

125
core/sme/inc/sme_nan_datapath.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -29,129 +29,6 @@
#include "csr_inside_api.h"
#if defined(WLAN_FEATURE_NAN_DATAPATH) && !defined(WLAN_FEATURE_NAN_CONVERGENCE)
#include "qdf_types.h"
#include "sir_api.h"
#include "ani_global.h"
#include "sme_inside.h"
/**
* struct sir_sme_ndp_initiator_req - sme request struct for ndp initiator req
* @mesgType: SME msg type(eWNI_SME_NDP_INITIATOR_REQ)
* @mesgLen: lenght of message
* @req: actual ndp initiator request
*
*/
struct sir_sme_ndp_initiator_req {
uint16_t msg_type;
uint16_t msg_len;
struct ndp_initiator_req req;
};
/**
* struct sir_sme_ndp_responder_req - Wraper of responder's response
* to ndp create request
* @msg_type: SME msg type
* @msg_len: Length of msg
* @req: responder's response to ndp create request
*
*/
struct sir_sme_ndp_responder_req {
uint16_t msg_type;
uint16_t msg_len;
struct ndp_responder_req req;
};
/*
* struct sir_sme_ndp_end_req - sme request struct for ndp end req
* @msg_type: SME msg type(sir_sme_ndp_initiator_req)
* @msg_len: lenght of message
* @req: actual ndp initiator request
*
*/
struct sir_sme_ndp_end_req {
uint16_t msg_type;
uint16_t msg_len;
struct ndp_end_req *req;
};
/* NaN initiator request handler */
QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
struct ndp_initiator_req *req_params);
/* NaN responder request handler */
QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
struct ndp_responder_req *req_params);
/* NAN indication response handler */
QDF_STATUS sme_ndp_end_req_handler(tHalHandle hal, struct ndp_end_req *req);
QDF_STATUS csr_process_ndp_initiator_request(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd);
QDF_STATUS csr_process_ndp_data_end_request(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd);
void sme_ndp_msg_processor(tpAniSirGlobal mac_ctx, struct scheduler_msg *msg);
QDF_STATUS csr_process_ndp_responder_request(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd);
void csr_release_ndp_initiator_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd);
void csr_release_ndp_responder_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd);
void csr_release_ndp_data_end_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd);
#else
/* NAN initiator request handler */
static inline QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
void *req_params) {
return QDF_STATUS_SUCCESS;
}
/* NAN responder request handler */
static inline QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
void *req_params) {
return QDF_STATUS_SUCCESS;
}
/* NAN indication response handler */
static inline QDF_STATUS sme_ndp_end_req_handler(uint32_t session_id,
void *req_params) {
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS csr_process_ndp_initiator_request(
tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
{
return QDF_STATUS_SUCCESS;
}
static inline void sme_ndp_msg_processor(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg)
{
}
static inline QDF_STATUS csr_process_ndp_responder_request(
tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS csr_process_ndp_data_end_request(
tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
{
return QDF_STATUS_SUCCESS;
}
static inline void csr_release_ndp_initiator_req(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd) {}
static inline void csr_release_ndp_responder_req(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd) {}
static inline void csr_release_ndp_data_end_req(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd) {}
#endif /* WLAN_FEATURE_NAN_DATAPATH */
#ifdef WLAN_FEATURE_NAN_DATAPATH
/* Start NDI BSS */
QDF_STATUS csr_roam_start_ndi(tpAniSirGlobal mac_ctx, uint32_t session_id,

19
core/sme/src/common/sme_api.c
View file

@ -523,15 +523,6 @@ QDF_STATUS sme_ser_handle_active_cmd(struct wlan_serialization_command *cmd)
csr_roam_process_wm_status_change_command(mac_ctx,
sme_cmd);
break;
case eSmeCommandNdpInitiatorRequest:
status = csr_process_ndp_initiator_request(mac_ctx, sme_cmd);
break;
case eSmeCommandNdpResponderRequest:
status = csr_process_ndp_responder_request(mac_ctx, sme_cmd);
break;
case eSmeCommandNdpDataEndInitiatorRequest:
status = csr_process_ndp_data_end_request(mac_ctx, sme_cmd);
break;
case eSmeCommandScan:
sme_debug("Processing scan offload cmd");
qdf_mc_timer_start(&sme_cmd->u.scanCmd.csr_scan_timer,
@ -2366,16 +2357,6 @@ QDF_STATUS sme_process_msg(tHalHandle hHal, struct scheduler_msg *pMsg)
sme_err("Empty message for: %d", pMsg->type);
}
break;
case eWNI_SME_NDP_CONFIRM_IND:
case eWNI_SME_NDP_NEW_PEER_IND:
case eWNI_SME_NDP_INITIATOR_RSP:
case eWNI_SME_NDP_INDICATION:
case eWNI_SME_NDP_RESPONDER_RSP:
case eWNI_SME_NDP_END_RSP:
case eWNI_SME_NDP_END_IND:
case eWNI_SME_NDP_PEER_DEPARTED_IND:
sme_ndp_msg_processor(pMac, pMsg);
break;
case eWNI_SME_LOST_LINK_INFO_IND:
if (pMac->sme.lost_link_info_cb)
pMac->sme.lost_link_info_cb(pMac->hHdd,

5
core/sme/src/common/sme_trace.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2013-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -193,9 +193,6 @@ static uint8_t *sme_trace_get_command_string(uint32_t command)
CASE_RETURN_STRING(e_sme_command_nss_update);
CASE_RETURN_STRING(e_sme_command_set_dual_mac_config);
CASE_RETURN_STRING(e_sme_command_set_antenna_mode);
CASE_RETURN_STRING(eSmeCommandNdpInitiatorRequest);
CASE_RETURN_STRING(eSmeCommandNdpResponderRequest);
CASE_RETURN_STRING(eSmeCommandNdpDataEndInitiatorRequest);
default:
return "UNKNOWN";
}

18
core/sme/src/csr/csr_api_roam.c
View file

@ -19418,15 +19418,6 @@ static void csr_free_cmd_memory(tpAniSirGlobal pMac, tSmeCmd *pCommand)
case eSmeCommandWmStatusChange:
csr_release_command_wm_status_change(pMac, pCommand);
break;
case eSmeCommandNdpInitiatorRequest:
csr_release_ndp_initiator_req(pMac, pCommand);
break;
case eSmeCommandNdpResponderRequest:
csr_release_ndp_responder_req(pMac, pCommand);
break;
case eSmeCommandNdpDataEndInitiatorRequest:
csr_release_ndp_data_end_req(pMac, pCommand);
break;
default:
break;
}
@ -19641,15 +19632,6 @@ enum wlan_serialization_cmd_type csr_get_cmd_type(tSmeCmd *sme_cmd)
case eSmeCommandWmStatusChange:
cmd_type = WLAN_SER_CMD_WM_STATUS_CHANGE;
break;
case eSmeCommandNdpInitiatorRequest:
cmd_type = WLAN_SER_CMD_NDP_INIT_REQ;
break;
case eSmeCommandNdpResponderRequest:
cmd_type = WLAN_SER_CMD_NDP_RESP_REQ;
break;
case eSmeCommandNdpDataEndInitiatorRequest:
cmd_type = WLAN_SER_CMD_NDP_DATA_END_INIT_REQ;
break;
case eSmeCommandEnterStandby:
cmd_type = WLAN_SER_CMD_ENTER_STANDBY;
break;

640
core/sme/src/nan/nan_datapath_api.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -30,276 +30,6 @@
#include "csr_internal.h"
#include "sme_nan_datapath.h"
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* csr_free_ndp_initiator_req() - free resouces from sme command for ndp
* initiator request
* @cmd: sme command msg
*
* Return: None
*/
static void csr_free_ndp_initiator_req(tSmeCmd *cmd)
{
qdf_mem_free(cmd->u.initiator_req.ndp_config.ndp_cfg);
cmd->u.initiator_req.ndp_config.ndp_cfg = NULL;
cmd->u.initiator_req.ndp_config.ndp_cfg_len = 0;
qdf_mem_free(cmd->u.initiator_req.ndp_info.ndp_app_info);
cmd->u.initiator_req.ndp_info.ndp_app_info = NULL;
cmd->u.initiator_req.ndp_info.ndp_app_info_len = 0;
qdf_mem_free(cmd->u.initiator_req.pmk.pmk);
cmd->u.initiator_req.pmk.pmk = NULL;
cmd->u.initiator_req.pmk.pmk_len = 0;
}
/**
* csr_free_ndp_responder_req() - free resouces from sme command for ndp
* responder request
* @cmd: sme command msg
*
* Return: None
*/
static void csr_free_ndp_responder_req(tSmeCmd *cmd)
{
qdf_mem_free(cmd->u.responder_req.ndp_config.ndp_cfg);
cmd->u.responder_req.ndp_config.ndp_cfg = NULL;
cmd->u.responder_req.ndp_config.ndp_cfg_len = 0;
qdf_mem_free(cmd->u.responder_req.ndp_info.ndp_app_info);
cmd->u.responder_req.ndp_info.ndp_app_info = NULL;
cmd->u.responder_req.ndp_info.ndp_app_info_len = 0;
qdf_mem_free(cmd->u.responder_req.pmk.pmk);
cmd->u.responder_req.pmk.pmk = NULL;
cmd->u.responder_req.pmk.pmk_len = 0;
}
/**
* sme_ndp_initiator_req_handler() - ndp initiator req handler
* @hal: hal handle
* @req_params: request parameters
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS sme_ndp_initiator_req_handler(tHalHandle hal,
struct ndp_initiator_req *req_params)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
tSmeCmd *cmd;
tpAniSirGlobal mac_ctx = PMAC_STRUCT(hal);
if (NULL == req_params) {
sme_err("Invalid req_params");
return QDF_STATUS_E_INVAL;
}
status = sme_acquire_global_lock(&mac_ctx->sme);
if (QDF_STATUS_SUCCESS != status) {
sme_err("SME lock failed, status: %d", status);
return status;
}
cmd = csr_get_command_buffer(mac_ctx);
if (NULL == cmd) {
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_RESOURCES;
}
cmd->command = eSmeCommandNdpInitiatorRequest;
cmd->sessionId = (uint8_t)req_params->vdev_id;
qdf_mem_copy(&cmd->u.initiator_req, req_params,
sizeof(struct ndp_initiator_req));
/* pointers copied as part of above operation are to be overwritten */
cmd->u.initiator_req.ndp_info.ndp_app_info = NULL;
cmd->u.initiator_req.ndp_config.ndp_cfg = NULL;
cmd->u.initiator_req.pmk.pmk = NULL;
if (req_params->ndp_info.ndp_app_info_len) {
cmd->u.initiator_req.ndp_info.ndp_app_info =
qdf_mem_malloc(req_params->ndp_info.ndp_app_info_len);
if (NULL == cmd->u.initiator_req.ndp_info.ndp_app_info) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.initiator_req.ndp_info.ndp_app_info,
req_params->ndp_info.ndp_app_info,
req_params->ndp_info.ndp_app_info_len);
}
if (req_params->ndp_config.ndp_cfg_len) {
cmd->u.initiator_req.ndp_config.ndp_cfg =
qdf_mem_malloc(req_params->ndp_config.ndp_cfg_len);
if (NULL == cmd->u.initiator_req.ndp_config.ndp_cfg) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.initiator_req.ndp_config.ndp_cfg,
req_params->ndp_config.ndp_cfg,
req_params->ndp_config.ndp_cfg_len);
}
if (req_params->pmk.pmk_len) {
cmd->u.initiator_req.pmk.pmk =
qdf_mem_malloc(req_params->pmk.pmk_len);
if (NULL == cmd->u.initiator_req.pmk.pmk) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.initiator_req.pmk.pmk,
req_params->pmk.pmk, req_params->pmk.pmk_len);
}
status = csr_queue_sme_command(mac_ctx, cmd, true);
if (QDF_STATUS_SUCCESS != status)
sme_err("SME enqueue failed, status: %d", status);
sme_release_global_lock(&mac_ctx->sme);
return status;
}
/**
* sme_ndp_responder_req_handler() - ndp responder request handler
* @hal: hal handle
* @req_params: request parameters
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS sme_ndp_responder_req_handler(tHalHandle hal,
struct ndp_responder_req *req_params)
{
QDF_STATUS status;
tSmeCmd *cmd;
tpAniSirGlobal mac_ctx = PMAC_STRUCT(hal);
if (NULL == req_params) {
sme_err("Invalid req_params");
return QDF_STATUS_E_INVAL;
}
status = sme_acquire_global_lock(&mac_ctx->sme);
if (QDF_STATUS_SUCCESS != status) {
sme_err("SME lock failed, status: %d", status);
return status;
}
cmd = csr_get_command_buffer(mac_ctx);
if (NULL == cmd) {
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_RESOURCES;
}
cmd->command = eSmeCommandNdpResponderRequest;
cmd->sessionId = (uint8_t)req_params->vdev_id;
qdf_mem_copy(&cmd->u.responder_req, req_params,
sizeof(*req_params));
/*
* Pointers copied as part of above operation are
* to be overwritten
*/
cmd->u.responder_req.ndp_info.ndp_app_info = NULL;
cmd->u.responder_req.ndp_config.ndp_cfg = NULL;
cmd->u.responder_req.pmk.pmk = NULL;
if (req_params->ndp_info.ndp_app_info_len) {
cmd->u.responder_req.ndp_info.ndp_app_info =
qdf_mem_malloc(req_params->ndp_info.ndp_app_info_len);
if (NULL == cmd->u.responder_req.ndp_info.ndp_app_info) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.responder_req.ndp_info.ndp_app_info,
req_params->ndp_info.ndp_app_info,
req_params->ndp_info.ndp_app_info_len);
}
if (req_params->ndp_config.ndp_cfg_len) {
cmd->u.responder_req.ndp_config.ndp_cfg =
qdf_mem_malloc(req_params->ndp_config.ndp_cfg_len);
if (NULL == cmd->u.responder_req.ndp_config.ndp_cfg) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.responder_req.ndp_config.ndp_cfg,
req_params->ndp_config.ndp_cfg,
req_params->ndp_config.ndp_cfg_len);
}
if (req_params->pmk.pmk_len) {
cmd->u.responder_req.pmk.pmk =
qdf_mem_malloc(req_params->pmk.pmk_len);
if (NULL == cmd->u.responder_req.pmk.pmk) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.responder_req.pmk.pmk,
req_params->pmk.pmk, req_params->pmk.pmk_len);
}
status = csr_queue_sme_command(mac_ctx, cmd, true);
if (QDF_STATUS_SUCCESS != status)
sme_err("SME enqueue failed, status: %d", status);
sme_release_global_lock(&mac_ctx->sme);
return status;
}
/**
* sme_ndp_end_req_handler() - ndp end request handler
* @hal: hal handle
* @req: ndp end request parameters
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS sme_ndp_end_req_handler(tHalHandle hal, struct ndp_end_req *req)
{
tSmeCmd *cmd;
QDF_STATUS ret = QDF_STATUS_SUCCESS;
QDF_STATUS status = QDF_STATUS_SUCCESS;
tpAniSirGlobal mac_ctx = PMAC_STRUCT(hal);
if (NULL == req) {
sme_err("Invalid ndp end req");
return QDF_STATUS_E_INVAL;
}
status = sme_acquire_global_lock(&mac_ctx->sme);
if (QDF_STATUS_SUCCESS != status) {
sme_err("SME lock failed, status: %d", status);
return QDF_STATUS_E_RESOURCES;
}
cmd = csr_get_command_buffer(mac_ctx);
if (NULL == cmd) {
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_RESOURCES;
}
cmd->command = eSmeCommandNdpDataEndInitiatorRequest;
cmd->u.data_end_req = qdf_mem_malloc(sizeof(*req) +
(req->num_ndp_instances * sizeof(uint32_t)));
if (NULL == cmd->u.data_end_req) {
csr_release_command(mac_ctx, cmd);
sme_release_global_lock(&mac_ctx->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(cmd->u.data_end_req, req, sizeof(*req));
cmd->u.data_end_req->ndp_ids =
(uint32_t *)((uint8_t *)&cmd->u.data_end_req[1]);
qdf_mem_copy(cmd->u.data_end_req->ndp_ids, req->ndp_ids,
sizeof(uint32_t) * req->num_ndp_instances);
status = csr_queue_sme_command(mac_ctx, cmd, true);
if (QDF_STATUS_SUCCESS != status) {
sme_err("SME enqueue failed, status: %d", status);
ret = QDF_STATUS_E_FAILURE;
}
sme_release_global_lock(&mac_ctx->sme);
return ret;
}
#endif /* WLAN_FEATURE_NAN_CONVERGENCE */
/**
* csr_roam_start_ndi() - Start connection for NAN datapath
* @mac_ctx: Global MAC context
@ -440,371 +170,3 @@ void csr_roam_update_ndp_return_params(tpAniSirGlobal mac_ctx,
break;
}
}
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* csr_process_ndp_initiator_request() - process ndp initiator request
* @mac_ctx: Global MAC context
* @cmd: ndp initiator sme cmd
*
* Return: status of operation
*/
QDF_STATUS csr_process_ndp_initiator_request(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd)
{
QDF_STATUS status;
struct sir_sme_ndp_initiator_req *lim_msg;
uint16_t msg_len;
uint8_t *self_mac_addr = NULL;
struct ndp_initiator_req *req;
if (NULL == cmd) {
sme_err("Invalid req_params");
return QDF_STATUS_E_INVAL;
}
req = &cmd->u.initiator_req;
msg_len = sizeof(*lim_msg);
lim_msg = qdf_mem_malloc(msg_len);
if (NULL == lim_msg) {
status = QDF_STATUS_E_NOMEM;
goto sme_initiator_req_failed;
}
lim_msg->msg_type = eWNI_SME_NDP_INITIATOR_REQ;
lim_msg->msg_len = msg_len;
/*
* following is being copied from p_cmd->u.initiator_req,
* no need to perform deep copy, as we are going to use memory
* allocated at SME in p_cmd->u.initiator_req and pass it all the way
* to WMA.
*/
qdf_mem_copy(&lim_msg->req, req, sizeof(struct ndp_initiator_req));
self_mac_addr = lim_msg->req.self_ndi_mac_addr.bytes;
sme_debug("selfMac = "MAC_ADDRESS_STR,
MAC_ADDR_ARRAY(self_mac_addr));
status = umac_send_mb_message_to_mac(lim_msg);
if (status != QDF_STATUS_SUCCESS)
csr_free_ndp_initiator_req(cmd);
sme_initiator_req_failed:
/* If fail, free up resources allocated in sme. */
if (status != QDF_STATUS_SUCCESS)
csr_free_ndp_initiator_req(cmd);
return status;
}
/**
* csr_process_ndp_responder_request() - ndp responder req
* @mac_ctx: Global MAC context
* @cmd: Cmd sent to SME
*
* Return: Success or failure code
*/
QDF_STATUS csr_process_ndp_responder_request(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd)
{
struct sir_sme_ndp_responder_req *lim_msg;
uint16_t msg_len;
QDF_STATUS status;
if (!cmd) {
sme_err("Invalid req_params");
return QDF_STATUS_E_INVAL;
}
msg_len = sizeof(*lim_msg);
lim_msg = qdf_mem_malloc(msg_len);
if (!lim_msg) {
sme_err("Mem alloc fail");
status = QDF_STATUS_E_NOMEM;
goto free_config;
}
lim_msg->msg_type = eWNI_SME_NDP_RESPONDER_REQ;
lim_msg->msg_len = msg_len;
/*
* following is being copied from p_cmd->u.responder_req,
* no need to perform deep copy, as we are going to use memory
* allocated at SME in p_cmd->u.responder_req and pass it all the way
* to WMA.
*/
qdf_mem_copy(&lim_msg->req, &cmd->u.responder_req,
sizeof(struct ndp_responder_req));
sme_debug("vdev_id: %d ndp_rsp: %d Instance id: %d",
lim_msg->req.vdev_id,
lim_msg->req.ndp_rsp,
lim_msg->req.ndp_instance_id);
status = umac_send_mb_message_to_mac(lim_msg);
free_config:
/* If fail, free up the ndp_cfg and ndp_app_info allocated in sme. */
if (status != QDF_STATUS_SUCCESS)
csr_free_ndp_responder_req(cmd);
return status;
}
/*
* csr_process_ndp_data_end_request() - process ndp data end request
* @mac_ctx: Global MAC context
* @cmd: sme command containing ndp initiator request
*
* Return: status of operation
*/
QDF_STATUS csr_process_ndp_data_end_request(tpAniSirGlobal mac_ctx,
tSmeCmd *cmd)
{
QDF_STATUS status;
struct sir_sme_ndp_end_req *lim_msg;
uint16_t msg_len;
if (NULL == cmd) {
sme_err("NULL sme cmd");
return QDF_STATUS_E_INVAL;
}
msg_len = sizeof(*lim_msg);
lim_msg = qdf_mem_malloc(msg_len);
if (NULL == lim_msg) {
sme_err("Malloc failed");
qdf_mem_free(cmd->u.data_end_req);
cmd->u.data_end_req = NULL;
return QDF_STATUS_E_NOMEM;
}
lim_msg->msg_type = (uint16_t)eWNI_SME_NDP_END_REQ;
lim_msg->msg_len = msg_len;
lim_msg->req = cmd->u.data_end_req;
status = umac_send_mb_message_to_mac(lim_msg);
if (status != QDF_STATUS_SUCCESS) {
qdf_mem_free(cmd->u.data_end_req);
cmd->u.data_end_req = NULL;
}
return status;
}
/**
* sme_ndp_msg_processor() - message processor for ndp/ndi north-bound SME msg.
* @mac_ctx: Global MAC context
* @msg: ndp/ndi SME message
*
* This function will further call csrRoamCallCallback with appropriate
* roam_status and roam_result thus allowing hdd to correctly identify NDP/NDI
* response.
*
* Return: nothing
*/
void sme_ndp_msg_processor(tpAniSirGlobal mac_ctx, struct scheduler_msg *msg)
{
struct csr_roam_info roam_info = {0};
eCsrRoamResult result;
uint32_t session_id;
tListElem *entry = NULL;
tSmeCmd *cmd = NULL;
bool release_active_cmd = false;
eSmeCommandType cmd_to_rel = eSmeNoCommand;
bool send_to_user = true;
entry = csr_nonscan_active_ll_peek_head(mac_ctx,
LL_ACCESS_LOCK);
if (entry != NULL)
cmd = GET_BASE_ADDR(entry, tSmeCmd, Link);
switch (msg->type) {
case eWNI_SME_NDP_CONFIRM_IND: {
result = eCSR_ROAM_RESULT_NDP_CONFIRM_IND;
/* copy msg from msg body to roam info passed to callback */
qdf_mem_copy(&roam_info.ndp.ndp_confirm_params, msg->bodyptr,
sizeof(roam_info.ndp.ndp_confirm_params));
session_id = roam_info.ndp.ndp_confirm_params.vdev_id;
break;
}
case eWNI_SME_NDP_INITIATOR_RSP: {
if (true == msg->bodyval) {
/* rsp was locally generated, do not send to HDD */
send_to_user = false;
} else {
result = eCSR_ROAM_RESULT_NDP_INITIATOR_RSP;
qdf_mem_copy(&roam_info.ndp.ndp_init_rsp_params,
msg->bodyptr,
sizeof(roam_info.ndp.ndp_init_rsp_params));
session_id = roam_info.ndp.ndp_init_rsp_params.vdev_id;
}
release_active_cmd = true;
cmd_to_rel = eSmeCommandNdpInitiatorRequest;
break;
}
case eWNI_SME_NDP_NEW_PEER_IND: {
result = eCSR_ROAM_RESULT_NDP_NEW_PEER_IND;
/* copy msg from msg body to roam info passed to callback */
qdf_mem_copy(&roam_info.ndp.ndp_peer_ind_params,
msg->bodyptr,
sizeof(roam_info.ndp.ndp_peer_ind_params));
session_id = roam_info.ndp.ndp_peer_ind_params.session_id;
break;
}
case eWNI_SME_NDP_INDICATION:
result = eCSR_ROAM_RESULT_NDP_INDICATION;
/* copy msg from msg body to roam info passed to callback */
qdf_mem_copy(&roam_info.ndp.ndp_indication_params,
msg->bodyptr, sizeof(struct ndp_indication_event));
session_id = roam_info.ndp.ndp_indication_params.vdev_id;
break;
case eWNI_SME_NDP_RESPONDER_RSP:
if (true == msg->bodyval) {
/* rsp was locally generated, do not send to HDD */
send_to_user = false;
} else {
result = eCSR_ROAM_RESULT_NDP_RESPONDER_RSP;
/*
* Copy msg from msg body to roam info passed to
* callback
*/
qdf_mem_copy(&roam_info.ndp.ndp_responder_rsp_params,
msg->bodyptr,
sizeof(struct ndp_responder_rsp_event));
session_id =
roam_info.ndp.ndp_responder_rsp_params.vdev_id;
}
release_active_cmd = true;
cmd_to_rel = eSmeCommandNdpResponderRequest;
break;
case eWNI_SME_NDP_END_RSP: {
if (true == msg->bodyval) {
/* rsp was locally generated, do not send to HDD */
send_to_user = false;
} else {
result = eCSR_ROAM_RESULT_NDP_END_RSP;
roam_info.ndp.ndp_end_rsp_params = msg->bodyptr;
/*
* NDP_END_IND is independent of session, but session_id
* is needed for csrRoamCallCallback(). Set it to 0
* which is a valid session.
*/
session_id = 0;
}
release_active_cmd = true;
cmd_to_rel = eSmeCommandNdpDataEndInitiatorRequest;
break;
}
case eWNI_SME_NDP_END_IND:
result = eCSR_ROAM_RESULT_NDP_END_IND;
roam_info.ndp.ndp_end_ind_params = msg->bodyptr;
/*
* NDP_END_IND is independent of session, but session_id is
* needed for csr_roam_call_callback(). Set it to vdev_id of
* first entry which is a valid session. vdev_id is likely to
* be same for all.
*/
session_id =
roam_info.ndp.ndp_end_ind_params->ndp_map[0].vdev_id;
break;
case eWNI_SME_NDP_PEER_DEPARTED_IND:
result = eCSR_ROAM_RESULT_NDP_PEER_DEPARTED_IND;
/* copy msg from msg body to roam info passed to callback */
qdf_mem_copy(&roam_info.ndp.ndp_peer_ind_params,
msg->bodyptr,
sizeof(roam_info.ndp.ndp_peer_ind_params));
session_id =
((struct sme_ndp_peer_ind *)msg->bodyptr)->session_id;
break;
default:
sme_err("Unhandled NDP rsp");
qdf_mem_free(msg->bodyptr);
return;
}
if (true == send_to_user)
csr_roam_call_callback(mac_ctx, session_id, &roam_info, 0,
eCSR_ROAM_NDP_STATUS_UPDATE, result);
/*
* free ndp_cfg and ndp_app_info if required
* For some commands this info may be needed in HDD
* so free them after roam callback.
*/
switch (msg->type) {
case eWNI_SME_NDP_INITIATOR_RSP:
if (cmd && eSmeCommandNdpInitiatorRequest == cmd->command) {
qdf_mem_free(cmd->u.initiator_req.ndp_config.ndp_cfg);
qdf_mem_free(
cmd->u.initiator_req.ndp_info.ndp_app_info);
}
break;
case eWNI_SME_NDP_INDICATION:
qdf_mem_free(roam_info.ndp.ndp_indication_params.scid.scid);
qdf_mem_free(
roam_info.ndp.ndp_indication_params.ndp_config.ndp_cfg);
qdf_mem_free(
roam_info.ndp.ndp_indication_params.ndp_info.ndp_app_info);
break;
case eWNI_SME_NDP_END_RSP:
if (cmd &&
eSmeCommandNdpDataEndInitiatorRequest == cmd->command) {
qdf_mem_free(cmd->u.data_end_req);
cmd->u.data_end_req = NULL;
}
break;
case eWNI_SME_NDP_END_IND:
break;
default:
break;
}
qdf_mem_free(msg->bodyptr);
msg->bodyptr = NULL;
if (release_active_cmd && cmd && cmd_to_rel == cmd->command) {
/* Now put this cmd back on the avilable command list */
if (csr_nonscan_active_ll_remove_entry(mac_ctx,
entry, LL_ACCESS_LOCK))
csr_release_command(mac_ctx, cmd);
}
}
/**
* csr_release_ndp_initiator_req() - free resouces from sme command for ndp
* and release the cmd
* initiator request
* @mac_ctx: Global MAC context
* @cmd: sme command msg
*
* Return: None
*/
void csr_release_ndp_initiator_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
{
csr_free_ndp_initiator_req(cmd);
}
/**
* csr_release_ndp_responder_req() - free resouces from sme command for ndp
* responder request and release the command
* @mac_ctx: Global MAC context
* @cmd: sme command msg
*
* Return: None
*/
void csr_release_ndp_responder_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
{
csr_free_ndp_responder_req(cmd);
}
/**
* csr_release_ndp_data_end_req() - free resouces from sme command for ndp
* data end request
* @mac_ctx: Global MAC context
* @cmd: sme command msg
*
* Return: None
*/
void csr_release_ndp_data_end_req(tpAniSirGlobal mac_ctx, tSmeCmd *cmd)
{
qdf_mem_free(cmd->u.data_end_req);
cmd->u.data_end_req = NULL;
}
#endif /* WLAN_FEATURE_NAN_CONVERGENCE */

13
core/wma/inc/wma_api.h
View file

@ -223,19 +223,6 @@ static inline void wma_register_egap_event_handle(WMA_HANDLE handle) {}
QDF_STATUS wma_set_tx_power_scale(uint8_t vdev_id, int value);
QDF_STATUS wma_set_tx_power_scale_decr_db(uint8_t vdev_id, int value);
#if defined(WLAN_FEATURE_NAN_DATAPATH) && !defined(WLAN_FEATURE_NAN_CONVERGENCE)
QDF_STATUS wma_register_ndp_cb(QDF_STATUS (*pe_ndp_event_handler)
(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg));
#else
static inline QDF_STATUS wma_register_ndp_cb(QDF_STATUS (*pe_ndp_event_handler)
(tpAniSirGlobal mac_ctx,
struct scheduler_msg *msg))
{
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_FEATURE_NAN_DATAPATH && !WLAN_FEATURE_NAN_CONVERGENCE */
bool wma_is_csa_offload_enabled(void);
bool wma_is_p2p_lo_capable(void);
bool wma_capability_enhanced_mcast_filter(void);

15
core/wma/src/wma_main.c
View file

@ -2924,7 +2924,6 @@ QDF_STATUS wma_open(struct wlan_objmgr_psoc *psoc,
WMA_RX_WORK_CTX);
}
wma_ndp_register_all_event_handlers(wma_handle);
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_peer_antdiv_info_event_id,
wma_peer_ant_info_evt_handler,
@ -4062,7 +4061,6 @@ QDF_STATUS wma_close(void)
wma_unified_radio_tx_mem_free(wma_handle);
wma_ndp_unregister_all_event_handlers(wma_handle);
if (wma_handle->pdev) {
wlan_objmgr_pdev_release_ref(wma_handle->pdev,
WLAN_LEGACY_WMA_ID);
@ -7982,19 +7980,6 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
wma_set_bpf_instructions(wma_handle, msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case SIR_HAL_NDP_INITIATOR_REQ:
wma_handle_ndp_initiator_req(wma_handle, msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case SIR_HAL_NDP_RESPONDER_REQ:
wma_handle_ndp_responder_req(wma_handle, msg->bodyptr);
break;
case SIR_HAL_NDP_END_REQ:
wma_handle_ndp_end_req(wma_handle, msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case SIR_HAL_POWER_DBG_CMD:
wma_process_hal_pwr_dbg_cmd(wma_handle,
msg->bodyptr);

967
core/wma/src/wma_nan_datapath.c
View file

@ -36,947 +36,6 @@
#include "cdp_txrx_misc.h"
#include <cdp_txrx_handle.h>
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* wma_handle_ndp_initiator_req() - NDP initiator request handler
* @wma_handle: wma handle
* @req: request parameters
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS wma_handle_ndp_initiator_req(tp_wma_handle wma_handle, void *req)
{
QDF_STATUS status;
int ret;
uint16_t len;
uint32_t vdev_id, ndp_cfg_len, ndp_app_info_len, pmk_len;
struct ndp_initiator_rsp ndp_rsp = {0};
void *vdev;
wmi_buf_t buf;
wmi_ndp_initiator_req_fixed_param *cmd;
struct scheduler_msg pe_msg = {0};
struct ndp_initiator_req *ndp_req = req;
wmi_channel *ch_tlv;
uint8_t *tlv_ptr;
if (NULL == ndp_req) {
WMA_LOGE(FL("Invalid ndp_req."));
goto send_ndp_initiator_fail;
}
vdev_id = ndp_req->vdev_id;
vdev = wma_find_vdev_by_id(wma_handle, vdev_id);
if (!vdev) {
WMA_LOGE(FL("vdev not found for vdev id %d."), vdev_id);
goto send_ndp_initiator_fail;
}
if (!WMA_IS_VDEV_IN_NDI_MODE(wma_handle->interfaces, vdev_id)) {
WMA_LOGE(FL("vdev :%d, not in NDI mode"), vdev_id);
goto send_ndp_initiator_fail;
}
/*
* 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(wma_handle->wmi_handle, len);
if (!buf) {
WMA_LOGE(FL("wmi_buf_alloc failed"));
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 = ndp_req->vdev_id;
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;
WMA_LOGE(FL("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);
WMA_LOGE(FL("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);
WMA_LOGE(FL("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);
WMA_LOGE(FL("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);
WMA_LOGE(FL("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);
WMA_LOGE(FL("sending WMI_NDP_INITIATOR_REQ_CMDID(0x%X)"),
WMI_NDP_INITIATOR_REQ_CMDID);
ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
WMI_NDP_INITIATOR_REQ_CMDID);
if (ret < 0) {
WMA_LOGE(FL("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:
status = QDF_STATUS_E_FAILURE;
if (ndp_req) {
ndp_rsp.vdev_id = ndp_req->vdev_id;
ndp_rsp.transaction_id = ndp_req->transaction_id;
ndp_rsp.ndp_instance_id = ndp_req->service_instance_id;
ndp_rsp.status = NDP_DATA_INITIATOR_REQ_FAILED;
} else {
/* unblock SME queue, but do not send rsp to HDD */
pe_msg.bodyval = true;
}
pe_msg.type = SIR_HAL_NDP_INITIATOR_RSP;
pe_msg.bodyptr = &ndp_rsp;
return wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
}
/**
* wma_handle_ndp_responder_req() - NDP responder request handler
* @wma_handle: wma handle
* @req_params: request parameters
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS wma_handle_ndp_responder_req(tp_wma_handle wma_handle,
struct ndp_responder_req *req_params)
{
wmi_buf_t buf;
void *vdev;
uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len;
uint8_t *tlv_ptr;
int ret;
wmi_ndp_responder_req_fixed_param *cmd;
uint16_t len;
struct ndp_responder_rsp_event rsp = {0};
struct scheduler_msg pe_msg = {0};
if (NULL == req_params) {
WMA_LOGE(FL("Invalid req_params."));
return QDF_STATUS_E_INVAL;
}
vdev_id = req_params->vdev_id;
WMA_LOGD(FL("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d"),
req_params->vdev_id, req_params->transaction_id,
req_params->ndp_rsp,
req_params->ndp_instance_id,
req_params->ndp_info.ndp_app_info_len);
vdev = wma_find_vdev_by_id(wma_handle, vdev_id);
if (!vdev) {
WMA_LOGE(FL("vdev not found for vdev id %d."), vdev_id);
goto send_ndp_responder_fail;
}
if (!WMA_IS_VDEV_IN_NDI_MODE(wma_handle->interfaces, vdev_id)) {
WMA_LOGE(FL("vdev :$%d, not in NDI mode"), vdev_id);
goto send_ndp_responder_fail;
}
/*
* 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(req_params->ndp_config.ndp_cfg_len, 4);
ndp_app_info_len = qdf_roundup(req_params->ndp_info.ndp_app_info_len, 4);
pmk_len = qdf_roundup(req_params->pmk.pmk_len, 4);
/* allocated memory for fixed params as well as variable size data */
len = sizeof(*cmd) + 3*WMI_TLV_HDR_SIZE + ndp_cfg_len + ndp_app_info_len
+ pmk_len;
buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
if (!buf) {
WMA_LOGE(FL("wmi_buf_alloc failed"));
goto send_ndp_responder_fail;
}
cmd = (wmi_ndp_responder_req_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ndp_responder_req_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(
wmi_ndp_responder_req_fixed_param));
cmd->vdev_id = req_params->vdev_id;
cmd->transaction_id = req_params->transaction_id;
cmd->ndp_instance_id = req_params->ndp_instance_id;
cmd->rsp_code = req_params->ndp_rsp;
cmd->ndp_cfg_len = req_params->ndp_config.ndp_cfg_len;
cmd->ndp_app_info_len = req_params->ndp_info.ndp_app_info_len;
cmd->nan_pmk_len = req_params->pmk.pmk_len;
cmd->nan_csid = req_params->ncs_sk_type;
tlv_ptr = (uint8_t *)&cmd[1];
WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len);
qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE],
req_params->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],
req_params->ndp_info.ndp_app_info,
req_params->ndp_info.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], req_params->pmk.pmk,
cmd->nan_pmk_len);
tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len;
WMA_LOGE(FL("vdev_id = %d, transaction_id: %d, csid: %d"),
cmd->vdev_id, cmd->transaction_id, cmd->nan_csid);
WMA_LOGD(FL("ndp_config len: %d"),
req_params->ndp_config.ndp_cfg_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
req_params->ndp_config.ndp_cfg,
req_params->ndp_config.ndp_cfg_len);
WMA_LOGD(FL("ndp_app_info len: %d"),
req_params->ndp_info.ndp_app_info_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
req_params->ndp_info.ndp_app_info,
req_params->ndp_info.ndp_app_info_len);
WMA_LOGE(FL("pmk len: %d"), cmd->nan_pmk_len);
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
req_params->pmk.pmk, cmd->nan_pmk_len);
WMA_LOGE(FL("sending WMI_NDP_RESPONDER_REQ_CMDID(0x%X)"),
WMI_NDP_RESPONDER_REQ_CMDID);
ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
WMI_NDP_RESPONDER_REQ_CMDID);
if (ret < 0) {
WMA_LOGE(FL("WMI_NDP_RESPONDER_REQ_CMDID failed, ret: %d"),
ret);
wmi_buf_free(buf);
goto send_ndp_responder_fail;
}
return QDF_STATUS_SUCCESS;
send_ndp_responder_fail:
qdf_mem_zero(&rsp, sizeof(rsp));
rsp.vdev_id = req_params->vdev_id;
rsp.transaction_id = req_params->transaction_id;
rsp.status = NDP_RSP_STATUS_ERROR;
rsp.reason = NDP_DATA_RESPONDER_REQ_FAILED;
pe_msg.bodyptr = &rsp;
pe_msg.type = SIR_HAL_NDP_RESPONDER_RSP;
return wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
}
/**
* wma_handle_ndp_end_req() - NDP end request handler
* @wma_handle: wma handle
* @ptr: request parameters
*
* Return: QDF_STATUS_SUCCESS on success; error number otherwise
*/
QDF_STATUS wma_handle_ndp_end_req(tp_wma_handle wma_handle, void *ptr)
{
int ret;
uint16_t len;
uint32_t ndp_end_req_len, i;
wmi_ndp_end_req *ndp_end_req_lst;
wmi_buf_t buf;
struct scheduler_msg pe_msg = {0};
wmi_ndp_end_req_fixed_param *cmd;
struct ndp_end_rsp_event end_rsp = {0};
struct ndp_end_req *req = ptr;
if (NULL == req) {
WMA_LOGE(FL("Invalid ndp_end_req"));
goto send_ndp_end_fail;
}
/* len of tlv following fixed param */
ndp_end_req_len = sizeof(wmi_ndp_end_req) * req->num_ndp_instances;
/* above comes out to 4 byte alligned already, no need of padding */
len = sizeof(*cmd) + ndp_end_req_len + WMI_TLV_HDR_SIZE;
buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
if (!buf) {
WMA_LOGE(FL("Malloc failed"));
return QDF_STATUS_E_NOMEM;
}
cmd = (wmi_ndp_end_req_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_ndp_end_req_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_ndp_end_req_fixed_param));
cmd->transaction_id = req->transaction_id;
/* set tlv pointer to end of fixed param */
WMITLV_SET_HDR((uint8_t *)&cmd[1], WMITLV_TAG_ARRAY_STRUC,
ndp_end_req_len);
ndp_end_req_lst = (wmi_ndp_end_req *)((uint8_t *)&cmd[1] +
WMI_TLV_HDR_SIZE);
for (i = 0; i < req->num_ndp_instances; i++) {
WMITLV_SET_HDR(&ndp_end_req_lst[i],
WMITLV_TAG_ARRAY_FIXED_STRUC,
(sizeof(*ndp_end_req_lst) - WMI_TLV_HDR_SIZE));
ndp_end_req_lst[i].ndp_instance_id = req->ndp_ids[i];
}
WMA_LOGD(FL("Sending WMI_NDP_END_REQ_CMDID to FW"));
ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
WMI_NDP_END_REQ_CMDID);
if (ret < 0) {
WMA_LOGE(FL("WMI_NDP_END_REQ_CMDID failed, ret: %d"), ret);
wmi_buf_free(buf);
goto send_ndp_end_fail;
}
return QDF_STATUS_SUCCESS;
send_ndp_end_fail:
pe_msg.type = SIR_HAL_NDP_END_RSP;
if (req) {
end_rsp.status = NDP_RSP_STATUS_ERROR;
end_rsp.reason = NDP_END_FAILED;
end_rsp.transaction_id = req->transaction_id;
pe_msg.bodyptr = &end_rsp;
} else {
pe_msg.bodyval = true;
}
wma_handle->pe_ndp_event_handler(wma_handle->mac_context, &pe_msg);
return QDF_STATUS_E_FAILURE;
}
/**
* wma_ndp_indication_event_handler() - NDP indication event handler
* @handle: wma handle
* @event_info: event handler data
* @len: length of event_info
*
* Handler for WMI_NDP_INDICATION_EVENTID
* Return: 0 on success, negative errno on failure
*/
static int wma_ndp_indication_event_handler(void *handle, uint8_t *event_info,
uint32_t len)
{
struct scheduler_msg pe_msg = {0};
WMI_NDP_INDICATION_EVENTID_param_tlvs *event;
wmi_ndp_indication_event_fixed_param *fixed_params;
struct ndp_indication_event ind_event = {0};
tp_wma_handle wma_handle = handle;
event = (WMI_NDP_INDICATION_EVENTID_param_tlvs *)event_info;
fixed_params =
(wmi_ndp_indication_event_fixed_param *)event->fixed_param;
ind_event.vdev_id = fixed_params->vdev_id;
ind_event.service_instance_id = fixed_params->service_instance_id;
ind_event.ndp_instance_id = fixed_params->ndp_instance_id;
ind_event.role = fixed_params->self_ndp_role;
ind_event.policy = fixed_params->accept_policy;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
ind_event.peer_mac_addr.bytes);
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_discovery_mac_addr,
ind_event.peer_discovery_mac_addr.bytes);
WMA_LOGD(FL("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d"),
WMI_NDP_INDICATION_EVENTID, fixed_params->vdev_id);
WMA_LOGD(FL("service_instance %d, ndp_instance %d, role %d, policy %d"),
fixed_params->service_instance_id,
fixed_params->ndp_instance_id, fixed_params->self_ndp_role,
fixed_params->accept_policy);
WMA_LOGD(FL("csid: %d, scid_len: %d, peer_mac_addr: %pM, peer_disc_mac_addr: %pM"),
fixed_params->nan_csid, fixed_params->nan_scid_len,
ind_event.peer_mac_addr.bytes,
ind_event.peer_discovery_mac_addr.bytes);
WMA_LOGD(FL("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);
WMA_LOGD(FL("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);
ind_event.ndp_config.ndp_cfg_len = fixed_params->ndp_cfg_len;
ind_event.ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len;
ind_event.ncs_sk_type = fixed_params->nan_csid;
ind_event.scid.scid_len = fixed_params->nan_scid_len;
if (fixed_params->ndp_cfg_len > event->num_ndp_cfg ||
fixed_params->ndp_app_info_len > event->num_ndp_app_info ||
fixed_params->nan_scid_len > event->num_ndp_scid) {
WMA_LOGD(FL("Invalid ndp_cfg_len: %d, ndp_app_info_len: %d, nan_scid_len: %d"),
fixed_params->ndp_cfg_len,
fixed_params->ndp_app_info_len,
fixed_params->nan_scid_len);
return -EINVAL;
}
if (ind_event.ndp_config.ndp_cfg_len) {
ind_event.ndp_config.ndp_cfg =
qdf_mem_malloc(fixed_params->ndp_cfg_len);
if (NULL == ind_event.ndp_config.ndp_cfg) {
WMA_LOGE(FL("malloc failed"));
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(ind_event.ndp_config.ndp_cfg, event->ndp_cfg,
ind_event.ndp_config.ndp_cfg_len);
}
if (ind_event.ndp_info.ndp_app_info_len) {
ind_event.ndp_info.ndp_app_info =
qdf_mem_malloc(ind_event.ndp_info.ndp_app_info_len);
if (NULL == ind_event.ndp_info.ndp_app_info) {
WMA_LOGE(FL("malloc failed"));
qdf_mem_free(ind_event.ndp_config.ndp_cfg);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(ind_event.ndp_info.ndp_app_info,
event->ndp_app_info,
ind_event.ndp_info.ndp_app_info_len);
}
if (ind_event.scid.scid_len) {
ind_event.scid.scid =
qdf_mem_malloc(ind_event.scid.scid_len);
if (NULL == ind_event.scid.scid) {
WMA_LOGE(FL("malloc failed"));
qdf_mem_free(ind_event.ndp_config.ndp_cfg);
qdf_mem_free(ind_event.ndp_info.ndp_app_info);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(ind_event.scid.scid,
event->ndp_scid, ind_event.scid.scid_len);
WMA_LOGD(FL("scid hex dump:"));
QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
ind_event.scid.scid, ind_event.scid.scid_len);
}
pe_msg.type = SIR_HAL_NDP_INDICATION;
pe_msg.bodyptr = &ind_event;
return wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
}
/**
* wma_ndp_responder_rsp_event_handler() - NDP responder response event handler
* @handle: wma handle
* @event_info: event handler data
* @len: length of event_info
*
* Handler for WMI_NDP_RESPONDER_RSP_EVENTID
* Return: 0 on success, negative errno on failure
*/
static int wma_ndp_responder_rsp_event_handler(void *handle,
uint8_t *event_info, uint32_t len)
{
struct scheduler_msg pe_msg = {0};
tp_wma_handle wma_handle = handle;
WMI_NDP_RESPONDER_RSP_EVENTID_param_tlvs *event;
wmi_ndp_responder_rsp_event_fixed_param *fixed_params;
struct ndp_responder_rsp_event rsp = {0};
event = (WMI_NDP_RESPONDER_RSP_EVENTID_param_tlvs *)event_info;
fixed_params = event->fixed_param;
rsp.vdev_id = fixed_params->vdev_id;
rsp.transaction_id = fixed_params->transaction_id;
rsp.reason = fixed_params->reason_code;
rsp.status = fixed_params->rsp_status;
rsp.create_peer = fixed_params->create_peer;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
rsp.peer_mac_addr.bytes);
WMA_LOGD(FL("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: %pM,transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d"),
WMI_NDP_RESPONDER_RSP_EVENTID, rsp.vdev_id,
rsp.peer_mac_addr.bytes, rsp.transaction_id,
rsp.status, rsp.reason, rsp.create_peer);
pe_msg.bodyptr = &rsp;
pe_msg.type = SIR_HAL_NDP_RESPONDER_RSP;
return wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
}
/**
* wma_ndp_confirm_event_handler() - NDP confirm event handler
* @handle: wma handle
* @event_info: event handler data
* @len: length of event_info
*
* Handler for WMI_NDP_CONFIRM_EVENTID
* Return: 0 on success, negative errno on failure
*/
static int wma_ndp_confirm_event_handler(void *handle, uint8_t *event_info,
uint32_t len)
{
struct ndp_confirm_event ndp_confirm = {0};
struct scheduler_msg msg = {0};
WMI_NDP_CONFIRM_EVENTID_param_tlvs *event;
wmi_ndp_confirm_event_fixed_param *fixed_params;
tp_wma_handle wma_handle = handle;
event = (WMI_NDP_CONFIRM_EVENTID_param_tlvs *) event_info;
fixed_params = (wmi_ndp_confirm_event_fixed_param *)event->fixed_param;
WMA_LOGE(FL("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);
WMA_LOGE(FL("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);
WMA_LOGE(FL("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);
ndp_confirm.vdev_id = fixed_params->vdev_id;
ndp_confirm.ndp_instance_id = fixed_params->ndp_instance_id;
ndp_confirm.rsp_code = fixed_params->rsp_code;
ndp_confirm.reason_code = fixed_params->reason_code;
ndp_confirm.num_active_ndps_on_peer =
fixed_params->num_active_ndps_on_peer;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
ndp_confirm.peer_ndi_mac_addr.bytes);
ndp_confirm.ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len;
if (ndp_confirm.ndp_info.ndp_app_info_len > event->num_ndp_app_info) {
WMA_LOGE(FL("Invalid ndp_app_info_len: %d"),
ndp_confirm.ndp_info.ndp_app_info_len);
return -EINVAL;
}
if (ndp_confirm.ndp_info.ndp_app_info_len) {
ndp_confirm.ndp_info.ndp_app_info =
qdf_mem_malloc(fixed_params->ndp_app_info_len);
if (NULL == ndp_confirm.ndp_info.ndp_app_info) {
WMA_LOGE(FL("malloc failed"));
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(&ndp_confirm.ndp_info.ndp_app_info,
event->ndp_app_info,
ndp_confirm.ndp_info.ndp_app_info_len);
}
msg.type = SIR_HAL_NDP_CONFIRM;
msg.bodyptr = &ndp_confirm;
return wma_handle->pe_ndp_event_handler(wma_handle->mac_context, &msg);
}
/**
* wma_ndp_end_response_event_handler() - NDP end response event handler
* @handle: wma handle
* @event_info: event handler data
* @len: length of event_info
*
* Handler for WMI_NDP_END_RSP_EVENTID
* Return: 0 on success, negative errno on failure
*/
static int wma_ndp_end_response_event_handler(void *handle,
uint8_t *event_info, uint32_t len)
{
int ret = 0;
QDF_STATUS status;
struct scheduler_msg pe_msg = {0};
struct ndp_end_rsp_event *end_rsp;
WMI_NDP_END_RSP_EVENTID_param_tlvs *event;
wmi_ndp_end_rsp_event_fixed_param *fixed_params = NULL;
tp_wma_handle wma_handle = handle;
event = (WMI_NDP_END_RSP_EVENTID_param_tlvs *) event_info;
fixed_params = (wmi_ndp_end_rsp_event_fixed_param *)event->fixed_param;
WMA_LOGD(FL("WMI_NDP_END_RSP_EVENTID(0x%X) recieved. transaction_id: %d, rsp_status: %d, reason_code: %d"),
WMI_NDP_END_RSP_EVENTID, fixed_params->transaction_id,
fixed_params->rsp_status, fixed_params->reason_code);
end_rsp = qdf_mem_malloc(sizeof(*end_rsp));
if (NULL == end_rsp) {
WMA_LOGE("malloc failed");
pe_msg.bodyval = true;
ret = -ENOMEM;
goto send_ndp_end_rsp;
}
pe_msg.bodyptr = end_rsp;
qdf_mem_zero(end_rsp, sizeof(*end_rsp));
end_rsp->transaction_id = fixed_params->transaction_id;
end_rsp->reason = fixed_params->reason_code;
end_rsp->status = fixed_params->rsp_status;
send_ndp_end_rsp:
pe_msg.type = SIR_HAL_NDP_END_RSP;
status = wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
if (!QDF_IS_STATUS_SUCCESS(status))
ret = -EINVAL;
qdf_mem_free(end_rsp);
return ret;
}
/**
* wma_ndp_end_indication_event_handler() - NDP end indication event handler
* @handle: wma handle
* @event_info: event handler data
* @len: length of event_info
*
* Handler for WMI_NDP_END_INDICATION_EVENTID
* Return: 0 on success, negative errno on failure
*/
static int wma_ndp_end_indication_event_handler(void *handle,
uint8_t *event_info, uint32_t len)
{
tp_wma_handle wma_handle = handle;
WMI_NDP_END_INDICATION_EVENTID_param_tlvs *event;
wmi_ndp_end_indication *ind;
struct scheduler_msg pe_msg = {0};
struct ndp_end_indication_event *ndp_event_buf;
int i, ret, buf_size;
struct qdf_mac_addr peer_addr;
event = (WMI_NDP_END_INDICATION_EVENTID_param_tlvs *) event_info;
if (event->num_ndp_end_indication_list == 0) {
WMA_LOGE(
FL("Error: Event ignored, 0 ndp instances"));
return -EINVAL;
}
WMA_LOGD(FL("number of ndp instances = %d"),
event->num_ndp_end_indication_list);
if (event->num_ndp_end_indication_list > ((WMI_SVC_MSG_MAX_SIZE -
sizeof(*ndp_event_buf)) / sizeof(ndp_event_buf->ndp_map[0]))) {
WMA_LOGE("%s: excess data received from fw num_ndp_end_indication_list %d",
__func__, event->num_ndp_end_indication_list);
return -EINVAL;
}
buf_size = sizeof(*ndp_event_buf) + event->num_ndp_end_indication_list *
sizeof(ndp_event_buf->ndp_map[0]);
ndp_event_buf = qdf_mem_malloc(buf_size);
if (!ndp_event_buf) {
WMA_LOGP(FL("Failed to allocate memory"));
return -ENOMEM;
}
qdf_mem_zero(ndp_event_buf, buf_size);
ndp_event_buf->num_ndp_ids = event->num_ndp_end_indication_list;
ind = event->ndp_end_indication_list;
for (i = 0; i < ndp_event_buf->num_ndp_ids; i++) {
WMI_MAC_ADDR_TO_CHAR_ARRAY(
&ind[i].peer_ndi_mac_addr,
peer_addr.bytes);
WMA_LOGD(
FL("ind[%d]: type %d, reason_code %d, instance_id %d num_active %d MAC: " MAC_ADDRESS_STR),
i,
ind[i].type,
ind[i].reason_code,
ind[i].ndp_instance_id,
ind[i].num_active_ndps_on_peer,
MAC_ADDR_ARRAY(peer_addr.bytes));
/* Add each instance entry to the list */
ndp_event_buf->ndp_map[i].ndp_instance_id =
ind[i].ndp_instance_id;
ndp_event_buf->ndp_map[i].vdev_id = ind[i].vdev_id;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&ind[i].peer_ndi_mac_addr,
ndp_event_buf->ndp_map[i].peer_ndi_mac_addr.bytes);
ndp_event_buf->ndp_map[i].num_active_ndp_sessions =
ind[i].num_active_ndps_on_peer;
ndp_event_buf->ndp_map[i].type = ind[i].type;
ndp_event_buf->ndp_map[i].reason_code =
ind[i].reason_code;
}
pe_msg.type = SIR_HAL_NDP_END_IND;
pe_msg.bodyptr = ndp_event_buf;
pe_msg.bodyval = 0;
ret = wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
qdf_mem_free(ndp_event_buf);
return ret;
}
/**
* wma_ndp_initiator_rsp_event_handler() -NDP initiator rsp event handler
* @handle: wma handle
* @event_info: event handler data
* @len: length of event_info
*
* Handler for WMI_NDP_INITIATOR_RSP_EVENTID
* Return: 0 on success, negative errno on failure
*/
static int wma_ndp_initiator_rsp_event_handler(void *handle,
uint8_t *event_info, uint32_t len)
{
struct scheduler_msg pe_msg = {0};
WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *event;
wmi_ndp_initiator_rsp_event_fixed_param *fixed_params;
struct ndp_initiator_rsp ndp_rsp = {0};
tp_wma_handle wma_handle = handle;
event = (WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *)event_info;
fixed_params = event->fixed_param;
ndp_rsp.vdev_id = fixed_params->vdev_id;
ndp_rsp.transaction_id = fixed_params->transaction_id;
ndp_rsp.ndp_instance_id = fixed_params->ndp_instance_id;
ndp_rsp.status = fixed_params->rsp_status;
ndp_rsp.reason = fixed_params->reason_code;
pe_msg.type = SIR_HAL_NDP_INITIATOR_RSP;
pe_msg.bodyptr = &ndp_rsp;
return wma_handle->pe_ndp_event_handler(wma_handle->mac_context,
&pe_msg);
}
/**
* wma_ndp_register_all_event_handlers() - Register all NDP event handlers
* @wma_handle: WMA context
*
* Register the handlers for NAN datapath events from firmware.
*
* Return: None
*/
void wma_ndp_register_all_event_handlers(tp_wma_handle wma_handle)
{
WMA_LOGD(FL("Register WMI_NDP_INITIATOR_RSP_EVENTID"));
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_ndp_initiator_rsp_event_id,
wma_ndp_initiator_rsp_event_handler,
WMA_RX_SERIALIZER_CTX);
WMA_LOGD(FL("Register WMI_NDP_RESPONDER_RSP_EVENTID"));
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_ndp_responder_rsp_event_id,
wma_ndp_responder_rsp_event_handler,
WMA_RX_SERIALIZER_CTX);
WMA_LOGD(FL("Register WMI_NDP_END_RSP_EVENTID"));
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_ndp_end_rsp_event_id,
wma_ndp_end_response_event_handler,
WMA_RX_SERIALIZER_CTX);
WMA_LOGD(FL("Register WMI_NDP_INDICATION_EVENTID"));
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_ndp_indication_event_id,
wma_ndp_indication_event_handler,
WMA_RX_SERIALIZER_CTX);
WMA_LOGD(FL("Register WMI_NDP_CONFIRM_EVENTID"));
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_ndp_confirm_event_id,
wma_ndp_confirm_event_handler,
WMA_RX_SERIALIZER_CTX);
WMA_LOGD(FL("Register WMI_NDP_END_INDICATION_EVENTID"));
wmi_unified_register_event_handler(wma_handle->wmi_handle,
wmi_ndp_end_indication_event_id,
wma_ndp_end_indication_event_handler,
WMA_RX_SERIALIZER_CTX);
}
/**
* wma_ndp_unregister_all_event_handlers() - Unregister all NDP event handlers
* @wma_handle: WMA context
*
* Register the handlers for NAN datapath events from firmware.
*
* Return: None
*/
void wma_ndp_unregister_all_event_handlers(tp_wma_handle wma_handle)
{
WMA_LOGD(FL("Unregister WMI_NDP_INITIATOR_RSP_EVENTID"));
wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
wmi_ndp_initiator_rsp_event_id);
WMA_LOGD(FL("Unregister WMI_NDP_RESPONDER_RSP_EVENTID"));
wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
wmi_ndp_responder_rsp_event_id);
WMA_LOGD(FL("Unregister WMI_NDP_END_RSP_EVENTID"));
wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
wmi_ndp_end_rsp_event_id);
WMA_LOGD(FL("Unregister WMI_NDP_INDICATION_EVENTID"));
wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
wmi_ndp_indication_event_id);
WMA_LOGD(FL("Unregister WMI_NDP_CONFIRM_EVENTID"));
wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
wmi_ndp_confirm_event_id);
WMA_LOGD(FL("Unregister WMI_NDP_END_INDICATION_EVENTID"));
wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
wmi_ndp_end_indication_event_id);
}
/**
* wma_ndp_get_eventid_from_tlvtag() - map tlv tag to event id
* @tag: WMI TLV tag
*
* map the tag to known NDP event fixed_param tags and return the
* corresponding NDP event id.
*
* Return: 0 if TLV tag is invalid
* else return corresponding WMI event id
*/
uint32_t wma_ndp_get_eventid_from_tlvtag(uint32_t tag)
{
uint32_t event_id;
switch (tag) {
case WMITLV_TAG_STRUC_wmi_ndp_initiator_rsp_event_fixed_param:
event_id = WMI_NDP_INITIATOR_RSP_EVENTID;
break;
case WMITLV_TAG_STRUC_wmi_ndp_responder_rsp_event_fixed_param:
event_id = WMI_NDP_RESPONDER_RSP_EVENTID;
break;
case WMITLV_TAG_STRUC_wmi_ndp_end_rsp_event_fixed_param:
event_id = WMI_NDP_END_RSP_EVENTID;
break;
case WMITLV_TAG_STRUC_wmi_ndp_indication_event_fixed_param:
event_id = WMI_NDP_INDICATION_EVENTID;
break;
case WMITLV_TAG_STRUC_wmi_ndp_confirm_event_fixed_param:
event_id = WMI_NDP_CONFIRM_EVENTID;
break;
case WMITLV_TAG_STRUC_wmi_ndp_end_indication_event_fixed_param:
event_id = WMI_NDP_END_INDICATION_EVENTID;
break;
default:
event_id = 0;
WMA_LOGE(FL("Unknown tag: %d"), tag);
break;
}
WMA_LOGI(FL("For tag %d WMI event 0x%x"), tag, event_id);
return event_id;
}
/**
* wma_ndp_wow_event_callback() - NAN data path wow event callback
* @handle: WMA handle
* @event: event buffer
* @len: length of @event buffer
* @event_id: event id for ndp wow event
*
* The wow event WOW_REASON_NAN_DATA is followed by the payload of the event
* which generated the wow event.
* Payload is 4 bytes of length followed by event buffer. First 4 bytes
* of event buffer is common tlv header, which is a combination
* of tag (higher 2 bytes) and length (lower 2 bytes). The tag is used to
* identify the event which triggered wow event.
*
* Return: Errno
*/
int wma_ndp_wow_event_callback(void *handle, void *event, uint32_t len,
uint32_t event_id)
{
QDF_STATUS status;
WMA_LOGD(FL("ndp_wow_event dump"));
qdf_trace_hex_dump(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
event, len);
switch (event_id) {
case WMI_NDP_INITIATOR_RSP_EVENTID:
status = wma_ndp_initiator_rsp_event_handler(handle, event,
len);
break;
case WMI_NDP_RESPONDER_RSP_EVENTID:
status = wma_ndp_responder_rsp_event_handler(handle, event,
len);
break;
case WMI_NDP_END_RSP_EVENTID:
status = wma_ndp_end_response_event_handler(handle, event, len);
break;
case WMI_NDP_INDICATION_EVENTID:
status = wma_ndp_indication_event_handler(handle, event, len);
break;
case WMI_NDP_CONFIRM_EVENTID:
status = wma_ndp_confirm_event_handler(handle, event, len);
break;
case WMI_NDP_END_INDICATION_EVENTID:
status = wma_ndp_end_indication_event_handler(handle, event,
len);
break;
default:
WMA_LOGE(FL("Unknown event: %d"), event_id);
status = QDF_STATUS_SUCCESS;
}
return qdf_status_to_os_return(status);
}
#endif /* WLAN_FEATURE_NAN_CONVERGENCE */
/**
* wma_add_bss_ndi_mode() - Process BSS creation request while adding NaN
* Data interface
@ -1062,32 +121,6 @@ send_fail_resp:
wma_send_msg_high_priority(wma, WMA_ADD_BSS_RSP, (void *)add_bss, 0);
}
#ifndef WLAN_FEATURE_NAN_CONVERGENCE
/**
* wma_register_ndp_cb() - Register NDP callbacks
* @pe_ndp_event_handler: PE NDP callback routine pointer
*
* Register the PE callback NDP routines with WMA for
* handling NDP events
*
* Return: Success or Failure Status
*/
QDF_STATUS wma_register_ndp_cb(QDF_STATUS (*pe_ndp_event_handler)
(tpAniSirGlobal mac_ctx, struct scheduler_msg *msg))
{
tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
if (!wma) {
WMA_LOGE("%s: Failed to get WMA context", __func__);
return QDF_STATUS_E_FAILURE;
}
wma->pe_ndp_event_handler = pe_ndp_event_handler;
WMA_LOGD("Registered NDP callbacks with WMA successfully");
return QDF_STATUS_SUCCESS;
}
#endif /* WLAN_FEATURE_NAN_CONVERGENCE */
/**
* wma_add_sta_ndi_mode() - Process ADD_STA for NaN Data path
* @wma: wma handle

36
core/wma/src/wma_nan_datapath.h
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@ -33,50 +33,16 @@
#include "sir_api.h"
#include "sme_nan_datapath.h"
#if defined(WLAN_FEATURE_NAN_DATAPATH) && !defined(WLAN_FEATURE_NAN_CONVERGENCE)
QDF_STATUS wma_handle_ndp_responder_req(tp_wma_handle wma_handle,
struct ndp_responder_req *req_params);
void wma_ndp_register_all_event_handlers(tp_wma_handle wma_handle);
void wma_ndp_unregister_all_event_handlers(tp_wma_handle wma_handle);
int wma_ndp_wow_event_callback(void *handle, void *event,
uint32_t len, uint32_t event_id);
QDF_STATUS wma_handle_ndp_initiator_req(tp_wma_handle wma_handle, void *req);
QDF_STATUS wma_handle_ndp_end_req(tp_wma_handle wma_handle, void *req);
uint32_t wma_ndp_get_eventid_from_tlvtag(uint32_t tag);
#else
static inline void wma_ndp_register_all_event_handlers(
tp_wma_handle wma_handle) {}
static inline void wma_ndp_unregister_all_event_handlers(
tp_wma_handle wma_handle) {}
static inline int wma_ndp_wow_event_callback(void *handle, void *event,
uint32_t len, uint32_t event_id)
{
return 0;
}
static inline QDF_STATUS wma_handle_ndp_initiator_req(tp_wma_handle wma_handle,
void *req)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS wma_handle_ndp_responder_req(tp_wma_handle wma_handle,
void *req_params)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS wma_handle_ndp_end_req(tp_wma_handle wma_handle,
void *req)
{
return QDF_STATUS_SUCCESS;
}
static inline uint32_t wma_ndp_get_eventid_from_tlvtag(uint32_t tag)
{
return 0;
}
#endif /* WLAN_FEATURE_NAN_DATAPATH !WLAN_FEATURE_NAN_CONVERGENCE */
#ifdef WLAN_FEATURE_NAN_DATAPATH
#define WMA_IS_VDEV_IN_NDI_MODE(intf, vdev_id) \