qcacmn: scan convergence - interface definition

Add north interface, south interface and offload interface
API definitions

Change-Id: Iccae20d266e7248088241416730d9ea317c3f77b
CRs-Fixed: 1095299

umac/scan/core/src/wlan_scan_main.h

@@ -24,6 +24,8 @@
 #define _WLAN_SCAN_MAIN_API_H_
 
 #include <qdf_atomic.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
 #include <wlan_objmgr_vdev_obj.h>
 #include <wlan_scan_public_structs.h>
 #include "wlan_scan_cache_db.h"

umac/scan/core/src/wlan_scan_manager.c

@@ -19,3 +19,492 @@
 /*
  * DOC: contains scan manager functionality
  */
+
+#include <wlan_serialization_api.h>
+#include <wlan_scan_ucfg_api.h>
+#include <wlan_scan_tgt_api.h>
+#include "wlan_scan_main.h"
+#include "wlan_scan_manager.h"
+
+static QDF_STATUS
+scm_free_scan_request_mem(struct scan_start_request *req)
+{
+	void *ie;
+
+	if (!req) {
+		scm_err("null request");
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+	scm_info("freed scan request: 0x%p, scan_id: %d, requester: %d",
+		req, req->scan_req.scan_id, req->scan_req.scan_req_id);
+	/* Free vendor(extra) ie */
+	ie = req->scan_req.extraie.ptr;
+	if (ie) {
+		req->scan_req.extraie.ptr = NULL;
+		req->scan_req.extraie.len = 0;
+		qdf_mem_free(ie);
+	}
+
+	/* Free htcap ie */
+	ie = req->scan_req.htcap.ptr;
+	if (ie) {
+		req->scan_req.htcap.len = 0;
+		req->scan_req.htcap.ptr = NULL;
+		qdf_mem_free(ie);
+	}
+
+	/* Free vhtcap ie */
+	ie = req->scan_req.vhtcap.ptr;
+	if (ie) {
+		req->scan_req.vhtcap.len = 0;
+		req->scan_req.vhtcap.ptr = NULL;
+		qdf_mem_free(ie);
+	}
+	/* free scan_start_request memory */
+	qdf_mem_free(req);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+scm_scan_get_pdev_global_event_handlers(struct scan_event_listeners *listeners,
+		struct pdev_scan_ev_handler *pdev_ev_handler)
+{
+	uint32_t i;
+	struct cb_handler *cb_handlers  = &(pdev_ev_handler->cb_handlers[0]);
+
+	for (i = 0; i < MAX_SCAN_EVENT_HANDLERS_PER_PDEV; i++, cb_handlers++) {
+		if ((cb_handlers->func) &&
+		    (listeners->count < MAX_SCAN_EVENT_LISTENERS)) {
+			listeners->cb[listeners->count].func =
+				cb_handlers->func;
+			listeners->cb[listeners->count].arg =
+				cb_handlers->arg;
+			listeners->count++;
+		}
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+scm_scan_get_requester_event_handler(struct scan_event_listeners *listeners,
+		struct scan_requester_info *requesters,
+		wlan_scan_requester requester_id)
+{
+	uint32_t idx = requester_id & ~WLAN_SCAN_REQUESTER_ID_PREFIX;
+	struct cb_handler *ev_handler = &(requesters[idx].ev_handler);
+
+	if (ev_handler->func) {
+		if (listeners->count < MAX_SCAN_EVENT_LISTENERS) {
+			listeners->cb[listeners->count].func = ev_handler->func;
+			listeners->cb[listeners->count].arg = ev_handler->arg;
+			listeners->count++;
+		}
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static void scm_scan_post_event(struct wlan_objmgr_vdev *vdev,
+		struct scan_event *event)
+{
+	uint32_t i = 0;
+	struct wlan_scan_obj *scan;
+	struct pdev_scan_ev_handler *pdev_ev_handler;
+	struct cb_handler *cb_handlers;
+	struct scan_requester_info *requesters;
+	struct scan_event_listeners *listeners;
+
+	if (!vdev || !event) {
+		scm_err("vdev: 0x%p, event: 0x%p", vdev, event);
+		return;
+	}
+	if (!event->requester) {
+		scm_err("invalid requester id");
+		QDF_ASSERT(0);
+	}
+	scm_info("vdev: 0x%p, event: 0x%p", vdev, event);
+
+	scan = wlan_vdev_get_scan_obj(vdev);
+	pdev_ev_handler = wlan_vdev_get_pdev_scan_ev_handlers(vdev);
+	cb_handlers = &(pdev_ev_handler->cb_handlers[0]);
+	requesters = scan->requesters;
+
+	scm_info("vdev: %d, type: %d, reason: %d, freq: %d, req: %d, scanid: %d",
+		event->vdev_id, event->type, event->reason, event->chan_freq,
+		event->requester, event->scan_id);
+
+	listeners = qdf_mem_malloc(sizeof(*listeners));
+	if (!listeners) {
+		scm_warn("couldn't allocate listeners list");
+		return;
+	}
+
+	/* initialize number of listeners */
+	listeners->count = 0;
+
+	/*
+	 * Initiator of scan request decides which all scan events
+	 * he is interested in and FW will send only those scan events
+	 * to host driver.
+	 * All the events received by scan module will be notified
+	 * to all registered handlers.
+	 */
+
+	qdf_spin_lock_bh(&scan->lock);
+	/* find all global scan event handlers on this pdev */
+	scm_scan_get_pdev_global_event_handlers(listeners, pdev_ev_handler);
+	/* find owner who triggered this scan request */
+	scm_scan_get_requester_event_handler(listeners, requesters,
+			event->requester);
+	qdf_spin_unlock_bh(&scan->lock);
+
+	/* notify all interested handlers */
+	for (i = 0; i < listeners->count; i++) {
+		scm_debug("func: 0x%p, arg: 0x%p",
+			listeners->cb[i].func, listeners->cb[i].arg);
+		listeners->cb[i].func(vdev, event, listeners->cb[i].arg);
+	}
+	qdf_mem_free(listeners);
+}
+
+static QDF_STATUS
+scm_release_serialization_command(struct wlan_objmgr_vdev *vdev,
+		uint32_t scan_id)
+{
+	struct wlan_serialization_queued_cmd_info cmd = {0};
+
+	cmd.requestor = WLAN_UMAC_COMP_SCAN;
+	cmd.cmd_type = WLAN_SER_CMD_SCAN;
+	cmd.cmd_id = scan_id;
+	cmd.req_type = WLAN_SER_CANCEL_SINGLE_SCAN;
+	cmd.vdev = vdev;
+	cmd.queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
+
+	/* Inform serialization for command completion */
+	wlan_serialization_remove_cmd(&cmd);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+scm_post_internal_scan_complete_event(struct scan_start_request *req,
+		enum scan_completion_reason reason)
+{
+	struct scan_event event = {0, };
+
+	/* prepare internal scan complete event */
+	event.type = SCAN_EVENT_TYPE_COMPLETED;
+	event.reason = reason;
+	event.chan_freq = 0; /* Invalid frequency */
+	event.vdev_id =  req->scan_req.vdev_id;
+	event.requester = req->scan_req.scan_req_id;
+	event.scan_id = req->scan_req.scan_id;
+
+	/* post scan event to registered handlers */
+	scm_scan_post_event(req->vdev, &event);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline struct pdev_scan_info *
+scm_scan_get_pdev_priv_info(uint8_t pdev_id, struct wlan_scan_obj *scan_obj)
+{
+	return &scan_obj->pdev_info[pdev_id];
+}
+
+static QDF_STATUS
+scm_update_last_scan_time(struct scan_start_request *req)
+{
+	uint8_t pdev_id;
+	struct wlan_scan_obj *scan_obj;
+	struct pdev_scan_info *pdev_scan_info;
+
+	scan_obj = wlan_vdev_get_scan_obj(req->vdev);
+	pdev_id = wlan_scan_vdev_get_pdev_id(req->vdev);
+	pdev_scan_info = scm_scan_get_pdev_priv_info(pdev_id, scan_obj);
+	/* update last scan start time */
+	pdev_scan_info->last_scan_time = qdf_system_ticks();
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+scm_activate_scan_request(struct scan_start_request *req)
+{
+	QDF_STATUS status;
+
+	status = tgt_scan_start(req);
+	if (status != QDF_STATUS_SUCCESS) {
+		scm_info("tgt_scan_start failed, status: %d", status);
+		/* scan could not be started and hence
+		 * we will not receive any completions.
+		 * post scan cancelled
+		 */
+		scm_post_internal_scan_complete_event(req,
+				SCAN_REASON_CANCELLED);
+		return status;
+	}
+	/* save last scan start time */
+	status = scm_update_last_scan_time(req);
+
+	return status;
+}
+
+static QDF_STATUS
+scm_cancel_scan_request(struct scan_start_request *req)
+{
+	struct scan_cancel_request cancel_req = {0, };
+	QDF_STATUS status;
+
+	cancel_req.vdev = req->vdev;
+	cancel_req.cancel_req.scan_id = req->scan_req.scan_id;
+	cancel_req.cancel_req.requester = req->scan_req.scan_req_id;
+	cancel_req.cancel_req.req_type = WLAN_SCAN_CANCEL_SINGLE;
+	cancel_req.cancel_req.vdev_id = req->scan_req.vdev_id;
+	/* send scan cancel to fw */
+	status = tgt_scan_cancel(&cancel_req);
+	if (status != QDF_STATUS_SUCCESS)
+		scm_err("tgt_scan_cancel failed: status: %d, scanid: %d",
+			status, req->scan_req.scan_id);
+	/* notify event handler about scan cancellation */
+	scm_post_internal_scan_complete_event(req, SCAN_REASON_CANCELLED);
+
+	return status;
+}
+
+static QDF_STATUS
+scm_scan_serialize_callback(struct wlan_serialization_command *cmd,
+	enum wlan_serialization_cb_reason reason)
+{
+	struct scan_start_request *req;
+	QDF_STATUS status;
+
+	if (!cmd || !cmd->umac_cmd) {
+		scm_err("cmd: %p, umac_cmd: %p, reason: %d",
+			cmd, cmd->umac_cmd, reason);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	req = cmd->umac_cmd;
+	scm_info("reason: %d, reqid:%d, scanid: %d, vdev_id: %d",
+		reason, req->scan_req.scan_req_id,
+		req->scan_req.scan_id, req->scan_req.vdev_id);
+
+	switch (reason) {
+	case WLAN_SER_CB_ACTIVATE_CMD:
+		/* command moved to active list
+		 * modify the params if required for concurency case.
+		 */
+		status = scm_activate_scan_request(req);
+		break;
+
+	case WLAN_SER_CB_CANCEL_CMD:
+		/* command removed from pending list.
+		 * notify registered scan event handlers with
+		 * status completed and reason cancelled.
+		 */
+		status = scm_post_internal_scan_complete_event(req,
+				SCAN_REASON_CANCELLED);
+		break;
+
+	case WLAN_SER_CB_ACTIVE_CMD_TIMEOUT:
+		/* active command timed out.
+		 * prepare internal scan cancel request
+		 */
+		status = scm_cancel_scan_request(req);
+		break;
+
+	case WLAN_SER_CB_RELEASE_MEM_CMD:
+		/* command successfully completed.
+		 * release scan_start_request memory
+		 */
+		status = scm_free_scan_request_mem(req);
+		break;
+
+	default:
+		/* Do nothing but logging */
+		QDF_ASSERT(0);
+		status = QDF_STATUS_E_INVAL;
+		break;
+	}
+
+	return status;
+}
+
+QDF_STATUS
+scm_scan_start_req(struct scheduler_msg *msg)
+{
+	struct wlan_serialization_command cmd = {0, };
+	enum wlan_serialization_status ser_cmd_status;
+	struct scan_start_request *req;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	if (!msg || !msg->bodyptr) {
+		scm_err("msg: 0x%p, bodyptr: 0x%p", msg, msg->bodyptr);
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	req = msg->bodyptr;
+	cmd.cmd_type = WLAN_SER_CMD_SCAN;
+	cmd.cmd_id = req->scan_req.scan_id;
+	cmd.cmd_cb = (wlan_serialization_cmd_callback)
+		scm_scan_serialize_callback;
+	cmd.umac_cmd = req;
+	cmd.source = WLAN_UMAC_COMP_SCAN;
+	cmd.is_high_priority = false;
+	cmd.cmd_timeout_duration = req->scan_req.max_scan_time +
+		SCAN_TIMEOUT_GRACE_PERIOD;
+	cmd.vdev = req->vdev;
+
+	scm_info("req: 0x%p, reqid: %d, scanid: %d, vdevid: %d",
+		req, req->scan_req.scan_req_id, req->scan_req.scan_id,
+		req->scan_req.vdev_id);
+
+	ser_cmd_status = wlan_serialization_request(&cmd);
+	scm_info("wlan_serialization_request status:%d", ser_cmd_status);
+
+	switch (ser_cmd_status) {
+	case WLAN_SER_CMD_PENDING:
+		/* command moved to pending list.Do nothing */
+		break;
+	case WLAN_SER_CMD_ACTIVE:
+		/* command moved to active list. Do nothing */
+		break;
+	case WLAN_SER_CMD_DENIED_LIST_FULL:
+	case WLAN_SER_CMD_DENIED_RULES_FAILED:
+	case WLAN_SER_CMD_DENIED_UNSPECIFIED:
+		/* notify registered scan event handlers
+		 * about internal error
+		 */
+		scm_post_internal_scan_complete_event(req,
+				SCAN_REASON_INTERNAL_FAILURE);
+		/* cmd can't be serviced.
+		 * release scan_start_request memory.
+		 */
+		scm_free_scan_request_mem(req);
+		break;
+	default:
+		QDF_ASSERT(0);
+		status = QDF_STATUS_E_INVAL;
+		break;
+	}
+
+	return status;
+}
+
+static inline enum wlan_serialization_cancel_type
+get_serialization_cancel_type(enum scan_cancel_req_type type)
+{
+	enum wlan_serialization_cancel_type serialization_type;
+
+	switch (type) {
+	case WLAN_SCAN_CANCEL_SINGLE:
+		serialization_type = WLAN_SER_CANCEL_SINGLE_SCAN;
+		break;
+	case WLAN_SCAN_CANCEL_VDEV_ALL:
+		serialization_type = WLAN_SER_CANCEL_VDEV_SCANS;
+		break;
+	case WLAN_SCAN_CANCEL_PDEV_ALL:
+		serialization_type = WLAN_SER_CANCEL_PDEV_SCANS;
+		break;
+	default:
+		QDF_ASSERT(0);
+		scm_warn("invalid scan_cancel_req_type: %d", type);
+		serialization_type = WLAN_SER_CANCEL_PDEV_SCANS;
+		break;
+	}
+
+	return serialization_type;
+}
+
+QDF_STATUS
+scm_scan_cancel_req(struct scheduler_msg *msg)
+{
+	struct wlan_serialization_queued_cmd_info cmd = {0,};
+	enum wlan_serialization_cmd_status ser_cmd_status;
+	struct scan_cancel_request *req;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	if (!msg || !msg->bodyptr) {
+		scm_err("msg: 0x%p, bodyptr: 0x%p", msg, msg->bodyptr);
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	req = msg->bodyptr;
+	cmd.requestor = 0;
+	cmd.cmd_type = WLAN_SER_CMD_SCAN;
+	cmd.cmd_id = req->cancel_req.scan_id;
+	cmd.vdev = req->vdev;
+	cmd.queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE |
+		WLAN_SERIALIZATION_PENDING_QUEUE;
+	cmd.req_type = get_serialization_cancel_type(req->cancel_req.req_type);
+
+	ser_cmd_status = wlan_serialization_cancel_request(&cmd);
+
+	scm_info("status: %d, reqid: %d, scanid: %d, vdevid: %d, type: %d",
+		ser_cmd_status, req->cancel_req.requester,
+		req->cancel_req.scan_id, req->cancel_req.vdev_id,
+		req->cancel_req.req_type);
+
+	switch (ser_cmd_status) {
+	case WLAN_SER_CMD_IN_PENDING_LIST:
+		/* do nothing */
+		break;
+	case WLAN_SER_CMD_IN_ACTIVE_LIST:
+	case WLAN_SER_CMDS_IN_ALL_LISTS:
+		/* send wmi scan cancel to fw */
+		status = tgt_scan_cancel(req);
+		break;
+	case WLAN_SER_CMD_NOT_FOUND:
+		/* do nothing */
+		break;
+	default:
+		QDF_ASSERT(0);
+		status = QDF_STATUS_E_INVAL;
+		break;
+	}
+	/* Free cancel request memory */
+	qdf_mem_free(req);
+
+	return status;
+}
+
+QDF_STATUS
+scm_scan_event_handler(struct scheduler_msg *msg)
+{
+	struct wlan_objmgr_vdev *vdev;
+	struct scan_event *event;
+	struct scan_event_info *event_info;
+
+	if (!msg || !msg->bodyptr) {
+		scm_err("msg: %p, bodyptr: %p", msg, msg->bodyptr);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	event_info = msg->bodyptr;
+	vdev = event_info->vdev;
+	event = &(event_info->event);
+
+	scm_info("vdev: %d, type: %d, reason: %d, freq: %d, req: %d, scanid: %d",
+		event->vdev_id, event->type, event->reason, event->chan_freq,
+		event->requester, event->scan_id);
+
+	switch (event->type) {
+	case SCAN_EVENT_TYPE_COMPLETED:
+	case SCAN_EVENT_TYPE_START_FAILED:
+	case SCAN_EVENT_TYPE_DEQUEUED:
+		scm_release_serialization_command(vdev, event->scan_id);
+		break;
+	default:
+		break;
+	}
+
+	/* Notify all interested parties */
+	scm_scan_post_event(vdev, event);
+	/* free event info memory */
+	qdf_mem_free(event_info);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_SCAN_ID);
+
+	return QDF_STATUS_SUCCESS;
+}

umac/scan/dispatcher/inc/wlan_scan_tgt_api.h

@@ -23,11 +23,11 @@
 #ifndef _WLAN_SCAN_TGT_API_H_
 #define _WLAN_SCAN_TGT_API_H_
 
-#include <wlan_scan_structs.h>
 #include <wlan_objmgr_psoc_obj.h>
 #include <wlan_objmgr_pdev_obj.h>
 #include <wlan_objmgr_vdev_obj.h>
 #include <wlan_objmgr_peer_obj.h>
+#include <wlan_scan_public_structs.h>
 #include <wlan_mgmt_txrx_utils_api.h>
 
 /**

umac/scan/dispatcher/inc/wlan_scan_ucfg_api.h

@@ -24,10 +24,10 @@
 #define _WLAN_SCAN_UCFG_API_H_
 
 #include <scheduler_api.h>
-#include <wlan_scan_public_structs.h>
 #include <wlan_objmgr_psoc_obj.h>
 #include <wlan_objmgr_pdev_obj.h>
 #include <wlan_objmgr_vdev_obj.h>
+#include <wlan_scan_public_structs.h>
 
 /**
  * ucfg_scan_register_requester() - assigns requester ID to caller and

umac/scan/dispatcher/inc/wlan_scan_utils_api.h

@@ -25,6 +25,9 @@
 
 #include <wlan_objmgr_cmn.h>
 #include <qdf_mc_timer.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_vdev_obj.h>
 #include <wlan_scan_public_structs.h>
 #include<wlan_mgmt_txrx_utils_api.h>
 

umac/scan/dispatcher/src/wlan_scan_tgt_api.c

@@ -19,3 +19,159 @@
 /*
  * DOC: contains scan south bound interface definitions
  */
+
+#include <wlan_scan_ucfg_api.h>
+#include <wlan_scan_tgt_api.h>
+#include <wlan_objmgr_cmn.h>
+#include <wlan_lmac_if_def.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_vdev_obj.h>
+#include <../../core/src/wlan_scan_manager.h>
+
+static inline struct wlan_lmac_if_scan_tx_ops *
+wlan_psoc_get_scan_txops(struct wlan_objmgr_psoc *psoc)
+{
+	return &((psoc->soc_cb.tx_ops.scan));
+}
+
+static inline struct wlan_lmac_if_scan_tx_ops *
+wlan_vdev_get_scan_txops(struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_objmgr_psoc *psoc = NULL;
+
+	psoc = wlan_vdev_get_psoc(vdev);
+
+	return wlan_psoc_get_scan_txops(psoc);
+}
+
+static inline struct wlan_lmac_if_scan_rx_ops *
+wlan_vdev_get_scan_rxops(struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_objmgr_psoc *psoc = NULL;
+
+	psoc = wlan_vdev_get_psoc(vdev);
+
+	return &((psoc->soc_cb.rx_ops.scan));
+}
+
+QDF_STATUS
+tgt_scan_nlo_complete_evt_handler(void *handle, uint8_t *event,
+	uint32_t len)
+{
+	/*
+	 * Convert the tlv/non tlv data to struct scan_event
+	 * (SCM_EVENT_NLO_COMPLETE) (same as WIN does by calling a win API) and
+	 * Post msg to target_if queue
+	 */
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+tgt_nlo_match_evt_handler(void *handle, uint8_t *event,
+		uint32_t len)
+{
+	/*
+	 * Convert the tlv/non tlv data to comman data
+	 * and set the pno match received flag in vdev scan info
+	 */
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+tgt_scan_start(struct scan_start_request *req)
+{
+	struct wlan_lmac_if_scan_tx_ops *scan_ops = NULL;
+	struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(req->vdev);
+
+	scan_ops = wlan_vdev_get_scan_txops(req->vdev);
+	/* invoke wmi_unified_scan_start_cmd_send() */
+	QDF_ASSERT(scan_ops->scan_start);
+	if (scan_ops->scan_start)
+		return scan_ops->scan_start(psoc, req);
+	else
+		return QDF_STATUS_SUCCESS;
+}
+
+
+QDF_STATUS
+tgt_scan_cancel(struct scan_cancel_request *req)
+{
+	struct wlan_lmac_if_scan_tx_ops *scan_ops = NULL;
+	struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(req->vdev);
+
+	scan_ops = wlan_vdev_get_scan_txops(req->vdev);
+	/* invoke wmi_unified_scan_stop_cmd_send() */
+	QDF_ASSERT(scan_ops->scan_cancel);
+	if (scan_ops->scan_cancel)
+		return scan_ops->scan_cancel(psoc, &(req->cancel_req));
+	else
+		return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+tgt_scan_register_ev_handler(struct wlan_objmgr_psoc *psoc)
+{
+	struct wlan_lmac_if_scan_tx_ops *scan_ops = NULL;
+
+	scan_ops = wlan_psoc_get_scan_txops(psoc);
+	/* invoke wmi_unified_register_event_handler()
+	 * since event id, handler function and context is
+	 * already known to offload lmac, passing NULL as argument.
+	 * DA can pass necessary arguments by clubing then into
+	 * some structure.
+	 */
+	QDF_ASSERT(scan_ops->scan_reg_ev_handler);
+	if (scan_ops->scan_reg_ev_handler)
+		return scan_ops->scan_reg_ev_handler(psoc, NULL);
+	else
+		return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+tgt_scan_unregister_ev_handler(struct wlan_objmgr_psoc *psoc)
+{
+	struct wlan_lmac_if_scan_tx_ops *scan_ops = NULL;
+
+	scan_ops = wlan_psoc_get_scan_txops(psoc);
+	/* invoke wmi_unified_register_event_handler()
+	 * since event id, handler function and context is
+	 * already known to offload lmac, passing NULL as argument.
+	 * DA can pass necessary arguments by clubing then into
+	 * some structure.
+	 */
+	QDF_ASSERT(scan_ops->scan_unreg_ev_handler);
+	if (scan_ops->scan_unreg_ev_handler)
+		return scan_ops->scan_unreg_ev_handler(psoc, NULL);
+	else
+		return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+tgt_scan_event_handler(struct wlan_objmgr_psoc *psoc,
+		struct scan_event_info *event_info)
+{
+	struct scheduler_msg msg = {0,};
+	struct scan_event *event = &event_info->event;
+	uint8_t vdev_id = event->vdev_id;
+
+	if (!psoc || !event_info) {
+		scm_err("psoc: 0x%p, event_info: 0x%p", psoc, event_info);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	scm_info("vdev: %d, type: %d, reason: %d, freq: %d, req: %d, scanid: %d",
+		vdev_id, event->type, event->reason, event->chan_freq,
+		event->requester, event->scan_id);
+
+	event_info->vdev =
+		wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+				vdev_id, WLAN_SCAN_ID);
+	if (!event_info->vdev) {
+		scm_err("null vdev, vdev_id: %d, psoc: 0x%p", vdev_id, psoc);
+		return QDF_STATUS_E_INVAL;
+	}
+	msg.bodyptr = event_info;
+	msg.callback = scm_scan_event_handler;
+
+	return scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
+}

umac/scan/dispatcher/src/wlan_scan_ucfg_api.c

@@ -20,11 +20,15 @@
  * DOC: contains scan north bound interface definitions
  */
 
-#include <wlan_cmn.h>
-#include <wlan_scan_utils_api.h>
+#include <scheduler_api.h>
 #include <wlan_scan_ucfg_api.h>
-#include "../../core/src/wlan_scan_main.h"
 #include <wlan_objmgr_global_obj.h>
+#include <wlan_objmgr_cmn.h>
+#include <wlan_serialization_api.h>
+#include <wlan_scan_tgt_api.h>
+#include "../../core/src/wlan_scan_main.h"
+#include "../../core/src/wlan_scan_manager.h"
+#include "../../core/src/wlan_scan_cache_db.h"
 
 QDF_STATUS ucfg_scan_init(void)
 {
@@ -53,7 +57,7 @@ fail_create_psoc:
 
 QDF_STATUS ucfg_scan_deinit(void)
 {
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	QDF_STATUS status;
 
 	status = wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_SCAN,
 		wlan_scan_psoc_created_notification, NULL);
@@ -69,9 +73,222 @@ QDF_STATUS ucfg_scan_deinit(void)
 	return status;
 }
 
-static QDF_STATUS wlan_scan_global_init(struct wlan_scan_obj *scan_obj)
+QDF_STATUS
+ucfg_scan_start(struct scan_start_request *req)
 {
+	struct scheduler_msg msg = {0, };
 
+	if (!req || !req->vdev) {
+		scm_err("vdev: %p, req: %p", req->vdev, req);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	scm_info("reqid: %d, scanid: %d, vdevid: %d",
+		req->scan_req.scan_req_id, req->scan_req.scan_id,
+		req->scan_req.vdev_id);
+	msg.bodyptr = req;
+	msg.callback = scm_scan_start_req;
+
+	return scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg);
+}
+
+QDF_STATUS
+ucfg_scan_cancel(struct scan_cancel_request *req)
+{
+	struct scheduler_msg msg = {0, };
+
+	if (!req || !req->vdev) {
+		scm_err("vdev: %p, req: %p", req->vdev, req);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	scm_info("reqid: %d, scanid: %d, vdevid: %d, type: %d",
+		req->cancel_req.requester, req->cancel_req.scan_id,
+		req->cancel_req.vdev_id, req->cancel_req.req_type);
+	msg.bodyptr = req;
+	msg.callback = scm_scan_cancel_req;
+
+	return scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg);
+}
+
+wlan_scan_requester
+ucfg_scan_register_requester(struct wlan_objmgr_psoc *psoc,
+	uint8_t *name, scan_event_handler event_cb, void *arg)
+{
+	int i, j;
+	struct wlan_scan_obj *scan;
+	struct scan_requester_info *requesters;
+	wlan_scan_requester requester = {0};
+
+	if (!psoc) {
+		scm_err("null psoc");
+		return 0;
+	}
+	scan = wlan_psoc_get_scan_obj(psoc);
+	requesters = scan->requesters;
+	qdf_spin_lock_bh(&scan->lock);
+	for (i = 0; i < WLAN_MAX_REQUESTORS; ++i) {
+		if (requesters[i].requester == 0) {
+			requesters[i].requester =
+				WLAN_SCAN_REQUESTER_ID_PREFIX | i;
+			j = 0;
+			while (name[j] && (j < (WLAN_MAX_MODULE_NAME - 1))) {
+				requesters[i].module[j] = name[j];
+				++j;
+			}
+			requesters[i].module[j] = 0;
+			requesters[i].ev_handler.func = event_cb;
+			requesters[i].ev_handler.arg = arg;
+			requester = requesters[i].requester;
+			break;
+		}
+	}
+	qdf_spin_unlock_bh(&scan->lock);
+	scm_info("module: %s, event_cb: 0x%p, arg: 0x%p, reqid: %d",
+		name, event_cb, arg, requester);
+
+	return requester;
+}
+
+void
+ucfg_scan_unregister_requester(struct wlan_objmgr_psoc *psoc,
+	wlan_scan_requester requester)
+{
+	int idx = requester & ~WLAN_SCAN_REQUESTER_ID_PREFIX;
+	struct wlan_scan_obj *scan;
+	struct scan_requester_info *requesters;
+
+	if (!psoc) {
+		scm_err("null psoc");
+		return;
+	}
+	scan = wlan_psoc_get_scan_obj(psoc);
+	requesters = scan->requesters;
+	scm_info("reqid: %d", requester);
+
+	qdf_spin_lock_bh(&scan->lock);
+	requesters[idx].requester = 0;
+	requesters[idx].module[0] = 0;
+	requesters[idx].ev_handler.func = NULL;
+	requesters[idx].ev_handler.arg = NULL;
+	qdf_spin_unlock_bh(&scan->lock);
+}
+
+uint8_t*
+ucfg_get_scan_requester_name(struct wlan_objmgr_psoc *psoc,
+	wlan_scan_requester requester)
+{
+	int idx = requester & ~WLAN_SCAN_REQUESTER_ID_PREFIX;
+	struct wlan_scan_obj *scan;
+	struct scan_requester_info *requesters;
+
+	if (!psoc) {
+		scm_err("null psoc");
+		return "null";
+	}
+	scan = wlan_psoc_get_scan_obj(psoc);
+	requesters = scan->requesters;
+
+	if ((idx < WLAN_MAX_REQUESTORS) &&
+		(requesters[idx].requester == requester)) {
+		return requesters[idx].module;
+	}
+
+	return (uint8_t *)"unknown";
+}
+
+wlan_scan_id
+ucfg_scan_get_scan_id(struct wlan_objmgr_psoc *psoc)
+{
+	wlan_scan_id id;
+	struct wlan_scan_obj *scan;
+
+	if (!psoc) {
+		QDF_ASSERT(0);
+		scm_err("null psoc");
+		return 0;
+	}
+	scan = wlan_psoc_get_scan_obj(psoc);
+
+	id = qdf_atomic_inc_return(&scan->scan_ids);
+	id =  id & WLAN_SCAN_ID_MASK;
+	/* Mark this scan request as triggered by host
+	 * by setting WLAN_HOST_SCAN_REQ_ID_PREFIX flag.
+	 */
+	id =  id | WLAN_HOST_SCAN_REQ_ID_PREFIX;
+	scm_info("scan_id: 0x%x", id);
+
+	return id;
+}
+
+static QDF_STATUS
+scm_add_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler,
+	scan_event_handler event_cb, void *arg)
+{
+	struct cb_handler *cb_handler;
+	uint32_t handler_cnt = pdev_ev_handler->handler_cnt;
+
+	/* Assign next available slot to this registration request */
+	cb_handler = &(pdev_ev_handler->cb_handlers[handler_cnt]);
+	cb_handler->func = event_cb;
+	cb_handler->arg = arg;
+	pdev_ev_handler->handler_cnt++;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+ucfg_scan_register_event_handler(struct wlan_objmgr_vdev *vdev,
+	scan_event_handler event_cb, void *arg)
+{
+	uint32_t idx;
+	struct wlan_scan_obj *scan;
+	struct pdev_scan_ev_handler *pdev_ev_handler;
+	struct cb_handler *cb_handler;
+
+	/* scan event handler call back can't be NULL */
+	if (!vdev || !event_cb) {
+		scm_err("vdev: %p, event_cb: %p", vdev, event_cb);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	scm_info("vdev: %p, event_cb: %p, arg: %p\n", vdev, event_cb, arg);
+
+	scan = wlan_vdev_get_scan_obj(vdev);
+	pdev_ev_handler = wlan_vdev_get_pdev_scan_ev_handlers(vdev);
+	cb_handler = &(pdev_ev_handler->cb_handlers[0]);
+
+	qdf_spin_lock_bh(&scan->lock);
+	/* Ensure its not a duplicate registration request */
+	for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV;
+		idx++, cb_handler++) {
+		if ((cb_handler->func == event_cb) &&
+			(cb_handler->arg == arg)) {
+			qdf_spin_unlock_bh(&scan->lock);
+			scm_warn("func: %p, arg: %p already exists",
+				event_cb, arg);
+			return QDF_STATUS_SUCCESS;
+		}
+	}
+
+	QDF_ASSERT(pdev_ev_handler->handler_cnt <
+			MAX_SCAN_EVENT_HANDLERS_PER_PDEV);
+
+	if (pdev_ev_handler->handler_cnt >= MAX_SCAN_EVENT_HANDLERS_PER_PDEV) {
+		qdf_spin_unlock_bh(&scan->lock);
+		scm_warn("No more registrations possible");
+		return QDF_STATUS_E_NOMEM;
+	}
+
+	scm_add_scan_event_handler(pdev_ev_handler, event_cb, arg);
+	qdf_spin_unlock_bh(&scan->lock);
+
+	scm_info("event_cb: 0x%p, arg: 0x%p", event_cb, arg);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+wlan_scan_global_init(struct wlan_scan_obj *scan_obj)
+{
 	scan_obj->scan_def.active_dwell = SCAN_ACTIVE_DWELL_TIME;
 	scan_obj->scan_def.passive_dwell = SCAN_PASSIVE_DWELL_TIME;
 	scan_obj->scan_def.max_rest_time = SCAN_MAX_REST_TIME;
@@ -102,28 +319,301 @@ static QDF_STATUS wlan_scan_global_init(struct wlan_scan_obj *scan_obj)
 	scan_obj->scan_def.scan_ev_bss_chan = true;
 	scan_obj->scan_def.scan_ev_foreign_chan = true;
 	scan_obj->scan_def.scan_ev_dequeued = true;
-
+	/* init scan id seed */
 	qdf_atomic_init(&scan_obj->scan_ids);
 
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS ucfg_scan_psoc_enable(struct wlan_objmgr_psoc *psoc)
+static QDF_STATUS
+scm_remove_scan_event_handler(struct pdev_scan_ev_handler *pdev_ev_handler,
+	struct cb_handler *entry)
 {
+	struct cb_handler *last_entry;
+	uint32_t handler_cnt = pdev_ev_handler->handler_cnt;
+
+	/* Replace event handler being deleted
+	 * with the last one in the list.
+	 */
+	last_entry = &(pdev_ev_handler->cb_handlers[handler_cnt - 1]);
+	entry->func = last_entry->func;
+	entry->arg = last_entry->arg;
+
+	/* Clear our last entry */
+	last_entry->func = NULL;
+	last_entry->arg = NULL;
+	pdev_ev_handler->handler_cnt--;
+
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS ucfg_scan_psoc_disable(struct wlan_objmgr_psoc *psoc)
+void
+ucfg_scan_unregister_event_handler(struct wlan_objmgr_vdev *vdev,
+	scan_event_handler event_cb, void *arg)
 {
+	uint8_t found = false;
+	uint32_t idx;
+	uint32_t handler_cnt;
+	struct wlan_scan_obj *scan;
+	struct cb_handler *cb_handler;
+	struct pdev_scan_ev_handler *pdev_ev_handler;
+
+	scm_info("vdev: %p, event_cb: 0x%p, arg: 0x%p", vdev, event_cb, arg);
+	if (!vdev) {
+		scm_err("null vdev");
+		return;
+	}
+	scan = wlan_vdev_get_scan_obj(vdev);
+	pdev_ev_handler = wlan_vdev_get_pdev_scan_ev_handlers(vdev);
+	cb_handler = &(pdev_ev_handler->cb_handlers[0]);
+
+	qdf_spin_lock_bh(&scan->lock);
+	handler_cnt = pdev_ev_handler->handler_cnt;
+	if (!handler_cnt) {
+		qdf_spin_unlock_bh(&scan->lock);
+		scm_info("No event handlers registered");
+	}
+
+	for (idx = 0; idx < MAX_SCAN_EVENT_HANDLERS_PER_PDEV;
+		idx++, cb_handler++) {
+		if ((cb_handler->func == event_cb) &&
+			(cb_handler->arg == arg)) {
+			/* Event handler found, remove it
+			 * from event handler list.
+			 */
+			found = true;
+			scm_remove_scan_event_handler(pdev_ev_handler,
+				cb_handler);
+			handler_cnt--;
+			break;
+		}
+	}
+	qdf_spin_unlock_bh(&scan->lock);
+
+	scm_info("event handler %s, remaining handlers: %d",
+		(found ? "removed" : "not found"), handler_cnt);
+}
+
+QDF_STATUS
+ucfg_scan_init_default_params(struct wlan_objmgr_vdev *vdev,
+	struct scan_start_request *req)
+{
+	struct scan_default_params *def;
+
+	if (!vdev | !req) {
+		scm_err("vdev: 0x%p, req: 0x%p", vdev, req);
+		return QDF_STATUS_E_INVAL;
+	}
+	def = wlan_vdev_get_def_scan_params(vdev);
+
+	/* Zero out everything and explicitly set fields as required */
+	qdf_mem_zero(req, sizeof(*req));
+
+	req->vdev = vdev;
+	req->scan_req.vdev_id = wlan_vdev_get_id(vdev);
+	req->scan_req.scan_priority = def->scan_priority;
+	req->scan_req.dwell_time_active = def->active_dwell;
+	req->scan_req.dwell_time_passive = def->passive_dwell;
+	req->scan_req.min_rest_time = def->min_rest_time;
+	req->scan_req.max_rest_time = def->max_rest_time;
+	req->scan_req.repeat_probe_time = def->repeat_probe_time;
+	req->scan_req.probe_spacing_time = def->probe_spacing_time;
+	req->scan_req.idle_time = def->idle_time;
+	req->scan_req.max_scan_time = def->max_scan_time;
+	req->scan_req.probe_delay = def->probe_delay;
+	req->scan_req.burst_duration = def->burst_duration;
+	req->scan_req.n_probes = def->num_probes;
+	req->scan_req.scan_flags = def->scan_flags;
+	req->scan_req.scan_events = def->scan_events;
+
 	return QDF_STATUS_SUCCESS;
 }
 
-
-QDF_STATUS ucfg_scan_psoc_open(struct wlan_objmgr_psoc *psoc)
+QDF_STATUS
+ucfg_scan_init_ssid_params(struct scan_start_request *req,
+		uint32_t num_ssid, struct wlan_ssid *ssid_list)
+{
+	uint32_t max_ssid = sizeof(req->scan_req.ssid) /
+				sizeof(req->scan_req.ssid[0]);
+
+	if (!req) {
+		scm_err("null request");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	if (!num_ssid) {
+		/* empty channel list provided */
+		req->scan_req.num_ssids = 0;
+		qdf_mem_zero(&req->scan_req.ssid[0],
+			sizeof(req->scan_req.ssid));
+		return QDF_STATUS_SUCCESS;
+	}
+	if (!ssid_list) {
+		scm_err("null ssid_list while num_ssid: %d", num_ssid);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	if (num_ssid > max_ssid) {
+		/* got a big list. alert and continue */
+		scm_warn("overflow: received %d, max supported : %d",
+			num_ssid, max_ssid);
+		return QDF_STATUS_E_E2BIG;
+	}
+
+	if (max_ssid > num_ssid)
+		max_ssid = num_ssid;
+
+	req->scan_req.num_ssids = max_ssid;
+	qdf_mem_copy(&req->scan_req.ssid[0], ssid_list,
+		(req->scan_req.num_ssids * sizeof(req->scan_req.ssid[0])));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+ucfg_scan_init_bssid_params(struct scan_start_request *req,
+		uint32_t num_bssid, struct qdf_mac_addr *bssid_list)
+{
+	uint32_t max_bssid = sizeof(req->scan_req.bssid_list) /
+				sizeof(req->scan_req.bssid_list[0]);
+
+	if (!req) {
+		scm_err("null request");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	if (!num_bssid) {
+		/* empty channel list provided */
+		req->scan_req.num_bssid = 0;
+		qdf_mem_zero(&req->scan_req.bssid_list[0],
+			sizeof(req->scan_req.bssid_list));
+		return QDF_STATUS_SUCCESS;
+	}
+	if (!bssid_list) {
+		scm_err("null bssid_list while num_bssid: %d", num_bssid);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	if (num_bssid > max_bssid) {
+		/* got a big list. alert and continue */
+		scm_warn("overflow: received %d, max supported : %d",
+			num_bssid, max_bssid);
+		return QDF_STATUS_E_E2BIG;
+	}
+
+	if (max_bssid > num_bssid)
+		max_bssid = num_bssid;
+
+	req->scan_req.num_bssid = max_bssid;
+	qdf_mem_copy(&req->scan_req.bssid_list[0], bssid_list,
+		req->scan_req.num_bssid * sizeof(req->scan_req.bssid_list[0]));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+ucfg_scan_init_chanlist_params(struct scan_start_request *req,
+		uint32_t num_chans, uint32_t *chan_list)
+{
+
+	uint32_t max_chans = sizeof(req->scan_req.chan_list) /
+				sizeof(req->scan_req.chan_list[0]);
+	if (!req) {
+		scm_err("null request");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	if (!num_chans) {
+		/* empty channel list provided */
+		req->scan_req.num_chan = 0;
+		qdf_mem_zero(&req->scan_req.chan_list[0],
+			sizeof(req->scan_req.chan_list));
+		return QDF_STATUS_SUCCESS;
+	}
+	if (!chan_list) {
+		scm_err("null chan_list while num_chans: %d", num_chans);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	if (num_chans > max_chans) {
+		/* got a big list. alert and continue */
+		scm_warn("overflow: received %d, max supported : %d",
+			num_chans, max_chans);
+		return QDF_STATUS_E_E2BIG;
+	}
+
+	if (max_chans > num_chans)
+		max_chans = num_chans;
+
+	req->scan_req.num_chan = max_chans;
+	qdf_mem_copy(&req->scan_req.chan_list[0], chan_list,
+		req->scan_req.num_chan * sizeof(req->scan_req.chan_list[0]));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline enum scm_scan_status
+get_scan_status_from_serialization_status(
+	enum wlan_serialization_cmd_status status)
+{
+	enum scm_scan_status scan_status;
+
+	switch (status) {
+	case WLAN_SER_CMD_IN_PENDING_LIST:
+		scan_status = SCAN_IS_PENDING;
+		break;
+	case WLAN_SER_CMD_IN_ACTIVE_LIST:
+		scan_status = SCAN_IS_ACTIVE;
+		break;
+	case WLAN_SER_CMDS_IN_ALL_LISTS:
+		scan_status = SCAN_IS_ACTIVE_AND_PENDING;
+		break;
+	case WLAN_SER_CMD_NOT_FOUND:
+		scan_status = SCAN_NOT_IN_PROGRESS;
+		break;
+	default:
+		scm_warn("invalid serialization status %d", status);
+		QDF_ASSERT(0);
+		scan_status = SCAN_NOT_IN_PROGRESS;
+		break;
+	}
+
+	return scan_status;
+}
+
+enum scm_scan_status
+ucfg_scan_get_vdev_status(struct wlan_objmgr_vdev *vdev)
+{
+	enum wlan_serialization_cmd_status status;
+
+	if (!vdev) {
+		scm_err("null vdev");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	status = wlan_serialization_vdev_scan_status(vdev);
+
+	return get_scan_status_from_serialization_status(status);
+}
+
+enum scm_scan_status
+ucfg_scan_get_pdev_status(struct wlan_objmgr_pdev *pdev)
+{
+	enum wlan_serialization_cmd_status status;
+
+	if (!pdev) {
+		scm_err("null pdev");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+	status = wlan_serialization_pdev_scan_status(pdev);
+
+	return get_scan_status_from_serialization_status(status);
+}
+
+QDF_STATUS
+ucfg_scan_psoc_open(struct wlan_objmgr_psoc *psoc)
 {
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct wlan_scan_obj *scan_obj;
 
+	scm_info("psoc open: 0x%p", psoc);
+	if (!psoc) {
+		scm_err("null psoc");
+		return QDF_STATUS_E_FAILURE;
+	}
 	scan_obj = wlan_psoc_get_scan_obj(psoc);
 	if (scan_obj == NULL) {
 		scm_err("Failed to get scan object");
@@ -131,24 +621,63 @@ QDF_STATUS ucfg_scan_psoc_open(struct wlan_objmgr_psoc *psoc)
 	}
 	/* Initialize the scan Globals */
 	wlan_scan_global_init(scan_obj);
-
+	qdf_spinlock_create(&scan_obj->lock);
 	scm_db_init(psoc);
 
-	return status;
+	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS ucfg_scan_psoc_close(struct wlan_objmgr_psoc *psoc)
+QDF_STATUS
+ucfg_scan_psoc_close(struct wlan_objmgr_psoc *psoc)
 {
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct wlan_scan_obj *scan_obj;
 
+	scm_info("psoc close: 0x%p", psoc);
+	if (!psoc) {
+		scm_err("null psoc");
+		return QDF_STATUS_E_FAILURE;
+	}
 	scan_obj = wlan_psoc_get_scan_obj(psoc);
 	if (scan_obj == NULL) {
 		scm_err("Failed to get scan object");
 		return QDF_STATUS_E_FAILURE;
 	}
-
+	qdf_spinlock_destroy(&scan_obj->lock);
 	scm_db_deinit(psoc);
 
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+ucfg_scan_psoc_enable(struct wlan_objmgr_psoc *psoc)
+{
+	QDF_STATUS status;
+
+	scm_info("psoc enable: 0x%p", psoc);
+	if (!psoc) {
+		scm_err("null psoc");
+		return QDF_STATUS_E_FAILURE;
+	}
+	/* Subscribe for scan events from lmac layesr */
+	status = tgt_scan_register_ev_handler(psoc);
+	QDF_ASSERT(status == QDF_STATUS_SUCCESS);
+
+	return status;
+}
+
+QDF_STATUS
+ucfg_scan_psoc_disable(struct wlan_objmgr_psoc *psoc)
+{
+	QDF_STATUS status;
+
+	scm_info("psoc disable: 0x%p", psoc);
+	if (!psoc) {
+		scm_err("null psoc");
+		return QDF_STATUS_E_FAILURE;
+	}
+	/* Unsubscribe for scan events from lmac layesr */
+	status = tgt_scan_unregister_ev_handler(psoc);
+	QDF_ASSERT(status == QDF_STATUS_SUCCESS);
+
 	return status;
 }

umac/scan/dispatcher/src/wlan_scan_utils_api.c

@@ -19,3 +19,87 @@
 /*
  * DOC: Defines scan utility functions
  */
+
+#include <wlan_scan_ucfg_api.h>
+#include <wlan_scan_utils_api.h>
+#include <../../core/src/wlan_scan_cache_db.h>
+#include <../../core/src/wlan_scan_main.h>
+
+const char*
+util_scan_get_ev_type_name(enum scan_event_type type)
+{
+	static const char * const event_name[] = {
+		[SCAN_EVENT_TYPE_STARTED] = "STARTED",
+		[SCAN_EVENT_TYPE_COMPLETED] = "COMPLETED",
+		[SCAN_EVENT_TYPE_BSS_CHANNEL] = "HOME_CHANNEL",
+		[SCAN_EVENT_TYPE_FOREIGN_CHANNEL] = "FOREIGN_CHANNEL",
+		[SCAN_EVENT_TYPE_DEQUEUED] = "DEQUEUED",
+		[SCAN_EVENT_TYPE_PREEMPTED] = "PREEMPTED",
+		[SCAN_EVENT_TYPE_START_FAILED] = "START_FAILED",
+		[SCAN_EVENT_TYPE_RESTARTED] = "RESTARTED",
+		[SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT] = "FOREIGN_CHANNEL_EXIT",
+		[SCAN_EVENT_TYPE_SUSPENDED] = "SUSPENDED",
+		[SCAN_EVENT_TYPE_RESUMED] = "RESUMED",
+		[SCAN_EVENT_TYPE_NLO_COMPLETE] = "NLO_COMPLETE",
+		[SCAN_EVENT_TYPE_INVALID] = "INVALID",
+		[SCAN_EVENT_TYPE_GPIO_TIMEOUT] = "GPIO_TIMEOUT",
+		[SCAN_EVENT_TYPE_RADIO_MEASUREMENT_START] =
+			"RADIO_MEASUREMENT_START",
+		[SCAN_EVENT_TYPE_RADIO_MEASUREMENT_END] =
+			"RADIO_MEASUREMENT_END",
+		[SCAN_EVENT_TYPE_BSSID_MATCH] = "BSSID_MATCH",
+		[SCAN_EVENT_TYPE_FOREIGN_CHANNEL_GET_NF] =
+			"FOREIGN_CHANNEL_GET_NF",
+	};
+
+	if (type >= SCAN_EVENT_TYPE_MAX) {
+		scm_err("unknown type : %d", type);
+		QDF_ASSERT(0);
+		return "UNKNOWN";
+	}
+
+	return event_name[type];
+}
+
+
+const char*
+util_scan_get_ev_reason_name(enum scan_completion_reason reason)
+{
+	static const char * const reason_name[] = {
+		[SCAN_REASON_NONE] = "NONE",
+		[SCAN_REASON_COMPLETED] = "COMPLETED",
+		[SCAN_REASON_CANCELLED] = "CANCELLED",
+		[SCAN_REASON_PREEMPTED] = "PREEMPTED",
+		[SCAN_REASON_TIMEDOUT] = "TIMEDOUT",
+		[SCAN_REASON_INTERNAL_FAILURE] = "INTERNAL_FAILURE",
+		[SCAN_REASON_SUSPENDED] = "SUSPENDED",
+		[SCAN_REASON_RUN_FAILED] = "RUN_FAILED",
+		[SCAN_REASON_TERMINATION_FUNCTION] = "TERMINATION_FUNCTION",
+		[SCAN_REASON_MAX_OFFCHAN_RETRIES] = "MAX_OFFCHAN_RETRIES",
+	};
+
+	if (reason >= SCAN_REASON_MAX) {
+		scm_err("unknown reason : %d", reason);
+		QDF_ASSERT(0);
+		return "UNKNOWN";
+	}
+
+	return reason_name[reason];
+}
+
+qdf_time_t
+util_get_last_scan_time(struct wlan_objmgr_vdev *vdev)
+{
+	uint8_t pdev_id;
+	struct wlan_scan_obj *scan_obj;
+
+	if (!vdev) {
+		scm_warn("null vdev");
+		QDF_ASSERT(0);
+		return 0;
+	}
+	pdev_id = wlan_scan_vdev_get_pdev_id(vdev);
+	scan_obj = wlan_vdev_get_scan_obj(vdev);
+
+	return scan_obj->pdev_info[pdev_id].last_scan_time;
+}