qcacld-3.0: Fix compilation issues after rebase

Remove the compilation issues for references to cdf after rebase

Change-Id: Ia39c5c72fe5c95f9a91d5f6967ea60904b46f756
CRs-Fixed: 981188

core/bmi/inc/bmi.h

@@ -38,7 +38,7 @@
 #include "hif.h"
 
 struct ol_context;
-QDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx);
+QDF_STATUS ol_cds_init(qdf_device_t cdf_dev, void *hif_ctx);
 void ol_cds_free(void);
 
 /**

core/bmi/src/bmi.c

@@ -60,7 +60,7 @@ QDF_STATUS bmi_init(struct ol_context *ol_ctx)
 {
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	struct hif_opaque_softc *scn = ol_ctx->scn;
-	cdf_device_t cdf_dev = ol_ctx->cdf_dev;
+	qdf_device_t cdf_dev = ol_ctx->cdf_dev;
 
 	if (!scn) {
 		BMI_ERR("Invalid scn Context");
@@ -105,7 +105,7 @@ end:
 void bmi_cleanup(struct ol_context *ol_ctx)
 {
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
-	cdf_device_t cdf_dev = ol_ctx->cdf_dev;
+	qdf_device_t cdf_dev = ol_ctx->cdf_dev;
 
 	if (!cdf_dev->dev) {
 		BMI_ERR("%s: Invalid Device Pointer", __func__);
@@ -153,8 +153,8 @@ bmi_get_target_info(struct bmi_target_info *targ_info,
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
 	uint32_t cid, length;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("BMI Phase is Already Done");
@@ -239,8 +239,8 @@ QDF_STATUS bmi_read_soc_register(uint32_t address, uint32_t *param,
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	bmi_assert(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address)));
 	cdf_mem_set(bmi_cmd_buff, 0, sizeof(cid) + sizeof(address));
@@ -284,8 +284,8 @@ QDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint32_t size = sizeof(cid) + sizeof(address) + sizeof(param);
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	bmi_assert(BMI_COMMAND_FITS(size));
 	cdf_mem_set(bmi_cmd_buff, 0, size);
@@ -329,8 +329,8 @@ bmilz_data(uint8_t *buffer, uint32_t length, struct ol_context *ol_ctx)
 	struct hif_opaque_softc *scn = ol_ctx->scn;
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	bmi_assert(BMI_COMMAND_FITS(BMI_DATASZ_MAX + header));
 	cdf_mem_set(bmi_cmd_buff, 0, BMI_DATASZ_MAX + header);
@@ -386,8 +386,8 @@ QDF_STATUS bmi_sign_stream_start(uint32_t address, uint8_t *buffer,
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint32_t remaining, txlen;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	bmi_assert(BMI_COMMAND_FITS(BMI_DATASZ_MAX + header));
 	cdf_mem_set(bmi_cmd_buff, 0, BMI_DATASZ_MAX + header);
@@ -449,8 +449,8 @@ bmilz_stream_start(uint32_t address, struct ol_context *ol_ctx)
 	struct hif_opaque_softc *scn = ol_ctx->scn;
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	bmi_assert(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address)));
 	cdf_mem_set(bmi_cmd_buff, 0, sizeof(cid) + sizeof(address));
@@ -522,7 +522,7 @@ end:
  *
  * Return: Success/Failure
  */
-QDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx)
+QDF_STATUS ol_cds_init(qdf_device_t cdf_dev, void *hif_ctx)
 {
 	struct ol_context *ol_info;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
@@ -543,7 +543,7 @@ QDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx)
 	ol_info->scn = hif_ctx;
 	ol_info->tgt_def.targetdef = hif_get_targetdef(hif_ctx);
 
-	cdf_create_work(&ol_info->ramdump_work, ramdump_work_handler, ol_info);
+	qdf_create_work(cdf_dev, &ol_info->ramdump_work, ramdump_work_handler, ol_info);
 
 	return status;
 }

core/bmi/src/bmi_1.c

@@ -43,8 +43,8 @@ bmi_read_memory(uint32_t address,
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
 	uint32_t align;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_DBG("command disallowed");
@@ -119,8 +119,8 @@ QDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 	uint8_t *src;
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
@@ -193,8 +193,8 @@ bmi_execute(uint32_t address, A_UINT32 *param, struct ol_context *ol_ctx)
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
 	uint32_t size = sizeof(cid) + sizeof(address) + sizeof(param);
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
@@ -289,8 +289,8 @@ QDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
 	int status;
 	uint32_t cid;
 	struct bmi_info *info;
-	cdf_device_t cdf_dev = ol_ctx->cdf_dev;
-	cdf_dma_addr_t cmd, rsp;
+	qdf_device_t cdf_dev = ol_ctx->cdf_dev;
+	qdf_dma_addr_t cmd, rsp;
 
 	if (!scn) {
 		BMI_ERR("Invalid scn context");

core/bmi/src/bmi_2.c

@@ -44,8 +44,8 @@ bmi_no_command(struct ol_context *ol_ctx)
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed: BMI DONE ALREADY");
@@ -88,9 +88,9 @@ bmi_done_local(struct ol_context *ol_ctx)
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
-	cdf_device_t cdf_dev = ol_ctx->cdf_dev;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_device_t cdf_dev = ol_ctx->cdf_dev;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
@@ -159,8 +159,8 @@ QDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
@@ -235,8 +235,8 @@ bmi_read_memory(uint32_t address, uint8_t *buffer,
 	/* note we reuse the same buffer to receive on */
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
 	uint32_t size = sizeof(cid) + sizeof(address) + sizeof(length);
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
@@ -307,8 +307,8 @@ bmi_execute(uint32_t address, uint32_t *param, struct ol_context *ol_ctx)
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
@@ -355,8 +355,8 @@ bmi_load_image(dma_addr_t address,
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 	uint8_t *bmi_cmd_buff = info->bmi_cmd_buff;
 	uint8_t *bmi_rsp_buff = info->bmi_rsp_buff;
-	cdf_dma_addr_t cmd = info->bmi_cmd_da;
-	cdf_dma_addr_t rsp = info->bmi_rsp_da;
+	qdf_dma_addr_t cmd = info->bmi_cmd_da;
+	qdf_dma_addr_t rsp = info->bmi_rsp_da;
 
 	uint32_t addr_h, addr_l;
 

core/bmi/src/i_bmi.h

@@ -157,8 +157,8 @@ struct ol_context {
 	struct bmi_info bmi;
 	struct ol_config_info cfg_info;
 	uint8_t *cal_in_flash;
-	cdf_device_t cdf_dev;
-	cdf_work_t ramdump_work;
+	qdf_device_t cdf_dev;
+	qdf_work_t ramdump_work;
 	struct hif_opaque_softc *scn;
 	struct targetdef_t {
 		struct targetdef_s *targetdef;

core/bmi/src/ol_fw.c

@@ -151,7 +151,7 @@ __ol_transfer_bin_file(struct ol_context *ol_ctx, ATH_BIN_FILE file,
 	struct hif_target_info *tgt_info = hif_get_target_info_handle(scn);
 	uint32_t target_type = tgt_info->target_type;
 	struct bmi_info *bmi_ctx = GET_BMI_CONTEXT(ol_ctx);
-	cdf_device_t cdf_dev = ol_ctx->cdf_dev;
+	qdf_device_t cdf_dev = ol_ctx->cdf_dev;
 
 	switch (file) {
 	default:
@@ -611,13 +611,13 @@ void ol_target_failure(void *instance, QDF_STATUS status)
 {
 	struct ol_context *ol_ctx = instance;
 	struct hif_opaque_softc *scn = ol_ctx->scn;
-	tp_wma_handle wma = cds_get_context(CDF_MODULE_ID_WMA);
+	tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
 	struct ol_config_info *ini_cfg = ol_get_ini_handle(ol_ctx);
 	int ret;
 	ol_target_status target_status =
 			hif_get_target_status(scn);
 
-	cdf_event_set(&wma->recovery_event);
+	qdf_event_set(&wma->recovery_event);
 
 	if (OL_TRGET_STATUS_RESET == target_status) {
 		BMI_ERR("Target is already asserted, ignore!");
@@ -655,7 +655,7 @@ void ol_target_failure(void *instance, QDF_STATUS status)
 #if  defined(CONFIG_CNSS)
 	/* Collect the RAM dump through a workqueue */
 	if (ini_cfg->enable_ramdump_collection)
-		cdf_schedule_work(&ol_ctx->ramdump_work);
+		qdf_sched_work(0, &ol_ctx->ramdump_work);
 	else
 		pr_debug("%s: athdiag read for target reg\n", __func__);
 #endif

core/cdf/inc/cdf_nbuf.h

@@ -188,7 +188,7 @@ static inline unsigned char *cdf_nbuf_get_frag_vaddr(cdf_nbuf_t buf,
  *
  * Return: Fragment physical address
  */
-static inline cdf_dma_addr_t cdf_nbuf_get_frag_paddr(cdf_nbuf_t buf, int frag_num)
+static inline qdf_dma_addr_t cdf_nbuf_get_frag_paddr(cdf_nbuf_t buf, int frag_num)
 {
 	BUG_ON(frag_num >= NBUF_CB_TX_MAX_EXTRA_FRAGS);
 	return __cdf_nbuf_get_frag_paddr(buf, frag_num);
@@ -273,7 +273,7 @@ static inline void cdf_nbuf_ipa_priv_set(cdf_nbuf_t buf, uint32_t priv)
  *
  * Return: none
  */
-static inline cdf_dma_addr_t
+static inline qdf_dma_addr_t
 cdf_nbuf_mapped_paddr_get(cdf_nbuf_t buf)
 {
 	return __cdf_nbuf_mapped_paddr_get(buf);
@@ -286,7 +286,7 @@ cdf_nbuf_mapped_paddr_get(cdf_nbuf_t buf)
  * Return: none
  */
 static inline void
-cdf_nbuf_mapped_paddr_set(cdf_nbuf_t buf, cdf_dma_addr_t paddr)
+cdf_nbuf_mapped_paddr_set(cdf_nbuf_t buf, qdf_dma_addr_t paddr)
 {
 	__cdf_nbuf_mapped_paddr_set(buf, paddr);
 }
@@ -305,7 +305,7 @@ static inline void
 cdf_nbuf_frag_push_head(cdf_nbuf_t buf,
 			int frag_len,
 			char *frag_vaddr,
-			cdf_dma_addr_t frag_paddr)
+			qdf_dma_addr_t frag_paddr)
 {
 	__cdf_nbuf_frag_push_head(buf, frag_len, frag_vaddr, frag_paddr);
 }

core/cdf/src/cdf_memory.c

@@ -483,7 +483,7 @@ void cdf_mem_multi_pages_alloc(qdf_device_t osdev,
 	void **cacheable_pages = NULL;
 	uint16_t i;
 
-	CDF_BUG(PAGE_SIZE >= element_size);
+	QDF_BUG(PAGE_SIZE >= element_size);
 
 	pages->num_element_per_page = PAGE_SIZE / element_size;
 	if (!pages->num_element_per_page) {

core/cdf/src/cdf_nbuf.c

@@ -218,7 +218,7 @@ void __cdf_nbuf_free(struct sk_buff *skb)
 {
 	if (cdf_nbuf_ipa_owned_get(skb))
 		/* IPA cleanup function will need to be called here */
-		CDF_BUG(1);
+		QDF_BUG(1);
 	else
 		dev_kfree_skb_any(skb);
 }
@@ -289,7 +289,7 @@ __cdf_nbuf_unmap(qdf_device_t osdev, struct sk_buff *skb, qdf_dma_dir_t dir)
 QDF_STATUS
 __cdf_nbuf_map_single(qdf_device_t osdev, cdf_nbuf_t buf, qdf_dma_dir_t dir)
 {
-	cdf_dma_addr_t paddr;
+	qdf_dma_addr_t paddr;
 
 /* tempory hack for simulation */
 #ifdef A_SIMOS_DEVHOST
@@ -802,7 +802,7 @@ uint8_t __cdf_nbuf_get_tso_cmn_seg_info(struct sk_buff *skb,
  *
  * Return: N/A
 */
-static inline void cdf_dmaaddr_to_32s(cdf_dma_addr_t dmaaddr,
+static inline void cdf_dmaaddr_to_32s(qdf_dma_addr_t dmaaddr,
 				      uint32_t *lo, uint32_t *hi)
 {
 	if (sizeof(dmaaddr) > sizeof(uint32_t)) {
@@ -834,7 +834,7 @@ uint32_t __cdf_nbuf_get_tso_info(qdf_device_t osdev, struct sk_buff *skb,
 
 	/* segment specific */
 	char *tso_frag_vaddr;
-	cdf_dma_addr_t tso_frag_paddr = 0;
+	qdf_dma_addr_t tso_frag_paddr = 0;
 	uint32_t       tso_frag_paddr_lo, tso_frag_paddr_hi;
 	uint32_t num_seg = 0;
 	struct cdf_tso_seg_elem_t *curr_seg;
@@ -917,7 +917,7 @@ uint32_t __cdf_nbuf_get_tso_info(qdf_device_t osdev, struct sk_buff *skb,
 		curr_seg->seg.tso_frags[0].length = tso_cmn_info.eit_hdr_len;
 		tso_info->total_len = curr_seg->seg.tso_frags[0].length;
 		{
-			cdf_dma_addr_t mapped;
+			qdf_dma_addr_t mapped;
 			uint32_t       lo, hi;
 
 			mapped = dma_map_single(osdev->dev, tso_cmn_info.eit_hdr,

core/cdf/src/i_cdf_nbuf.h

@@ -59,11 +59,11 @@ typedef struct sk_buff *__cdf_nbuf_t;
 #define NBUF_CB_TX_MAX_EXTRA_FRAGS 2
 
 /*
- * Make sure that cdf_dma_addr_t in the cb block is always 64 bit aligned
+ * Make sure that qdf_dma_addr_t in the cb block is always 64 bit aligned
  */
 typedef union {
 	uint64_t       u64;
-	cdf_dma_addr_t dma_addr;
+	qdf_dma_addr_t dma_addr;
 } cdf_paddr_t;
 
 /**

core/cds/inc/cds_api.h

@@ -211,7 +211,7 @@ QDF_STATUS cds_free_context(void *p_cds_context, QDF_MODULE_ID moduleID,
 
 QDF_STATUS cds_set_context(QDF_MODULE_ID moduleID, void *context);
 
-QDF_STATUS cds_get_vdev_types(enum tCDF_ADAPTER_MODE mode, uint32_t *type,
+QDF_STATUS cds_get_vdev_types(enum tQDF_ADAPTER_MODE mode, uint32_t *type,
 			      uint32_t *subType);
 
 void cds_flush_work(void *work);

core/cds/inc/cds_sched.h

@@ -265,11 +265,11 @@ typedef struct _cds_context_type {
 
 	void *g_ol_context;
 	/*
-	 * cdf_ctx will be used by cdf
+	 * qdf_ctx will be used by cdf
 	 * while allocating dma memory
 	 * to access dev information.
 	 */
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 
 	void *pdev_txrx_ctx;
 

core/cds/src/cds_api.c

@@ -69,7 +69,7 @@
 /* Data definitions */
 static cds_context_type g_cds_context;
 static p_cds_contextType gp_cds_context;
-static struct __qdf_device g_cdf_ctx;
+static struct __qdf_device g_qdf_ctx;
 
 /* Debug variable to detect MC thread stuck */
 static atomic_t cds_wrapper_empty_count;
@@ -94,8 +94,8 @@ v_CONTEXT_t cds_init(void)
 
 	gp_cds_context = &g_cds_context;
 
-	gp_cds_context->qdf_ctx = &g_cdf_ctx;
-	cdf_mem_zero(&g_cdf_ctx, sizeof(g_cdf_ctx));
+	gp_cds_context->qdf_ctx = &g_qdf_ctx;
+	cdf_mem_zero(&g_qdf_ctx, sizeof(g_qdf_ctx));
 
 	qdf_trace_spin_lock_init();
 
@@ -486,7 +486,6 @@ err_probe_event:
  */
 QDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
 {
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	p_cds_contextType p_cds_context = (p_cds_contextType) cds_context;
 	void *scn;
@@ -593,7 +592,6 @@ QDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
  */
 QDF_STATUS cds_enable(v_CONTEXT_t cds_context)
 {
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	tSirRetStatus sirStatus = eSIR_SUCCESS;
 	p_cds_contextType p_cds_context = (p_cds_contextType) cds_context;
@@ -760,7 +758,6 @@ QDF_STATUS cds_disable(v_CONTEXT_t cds_context)
 QDF_STATUS cds_close(v_CONTEXT_t cds_context)
 {
 	QDF_STATUS qdf_status;
-	QDF_STATUS qdf_status;
 
 	qdf_status = wma_wmi_work_close(cds_context);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
@@ -1432,7 +1429,6 @@ void cds_core_return_msg(void *pVContext, p_cds_msg_wrapper pMsgWrapper)
  */
 QDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
 {
-	QDF_STATUS qdf_status;
 	QDF_STATUS qdf_status;
 	tpAniSirGlobal pmac = (((p_cds_contextType)cds_context)->pMACContext);
 

core/dp/htt/htt_tx.c

@@ -196,7 +196,7 @@ static void htt_tx_frag_desc_detach(struct htt_pdev_t *pdev)
  * Return: None
  */
 int htt_tx_frag_alloc(htt_pdev_handle pdev,
-	u_int16_t index, cdf_dma_addr_t *frag_paddr, void **frag_ptr)
+	u_int16_t index, qdf_dma_addr_t *frag_paddr, void **frag_ptr)
 {
 	uint16_t frag_page_index;
 	uint16_t frag_elem_index;
@@ -436,7 +436,7 @@ static qdf_dma_addr_t htt_tx_get_paddr(htt_pdev_handle pdev,
 
 /*--- descriptor allocation functions ---------------------------------------*/
 
-void *htt_tx_desc_alloc(htt_pdev_handle pdev, cdf_dma_addr_t *paddr,
+void *htt_tx_desc_alloc(htt_pdev_handle pdev, qdf_dma_addr_t *paddr,
 			uint16_t index)
 {
 	struct htt_host_tx_desc_t *htt_host_tx_desc;    /* includes HTC hdr */
@@ -477,7 +477,7 @@ void *htt_tx_desc_alloc(htt_pdev_handle pdev, cdf_dma_addr_t *paddr,
 	 * Include the headroom for the HTC frame header when specifying the
 	 * physical address for the HTT tx descriptor.
 	 */
-	*paddr = (cdf_dma_addr_t)htt_tx_get_paddr(pdev, (char *)htt_host_tx_desc);
+	*paddr = (qdf_dma_addr_t)htt_tx_get_paddr(pdev, (char *)htt_host_tx_desc);
 	/*
 	 * The allocated tx descriptor space includes headroom for a
 	 * HTC frame header.  Hide this headroom, so that we don't have
@@ -504,8 +504,8 @@ void htt_tx_desc_free(htt_pdev_handle pdev, void *tx_desc)
 
 void htt_tx_desc_frags_table_set(htt_pdev_handle pdev,
 				 void *htt_tx_desc,
-				 cdf_dma_addr_t paddr,
-				 cdf_dma_addr_t frag_desc_paddr,
+				 qdf_dma_addr_t paddr,
+				 qdf_dma_addr_t frag_desc_paddr,
 				 int reset)
 {
 	uint32_t *fragmentation_descr_field_ptr;
@@ -925,7 +925,7 @@ int htt_tx_ipa_uc_wdi_tx_buf_alloc(struct htt_pdev_t *pdev,
 {
 	unsigned int tx_buffer_count;
 	cdf_nbuf_t buffer_vaddr;
-	cdf_dma_addr_t buffer_paddr;
+	qdf_dma_addr_t buffer_paddr;
 	uint32_t *header_ptr;
 	uint32_t *ring_vaddr;
 #define IPA_UC_TX_BUF_FRAG_DESC_OFFSET 20

core/dp/ol/inc/ol_htt_tx_api.h

@@ -357,7 +357,7 @@ uint16_t htt_tx_compl_desc_id(void *iterator, int num);
  * @param[OUT] paddr_lo - physical address of the HTT descriptor
  * @return success -> descriptor handle, -OR- failure -> NULL
  */
-void *htt_tx_desc_alloc(htt_pdev_handle pdev, cdf_dma_addr_t *paddr,
+void *htt_tx_desc_alloc(htt_pdev_handle pdev, qdf_dma_addr_t *paddr,
 			uint16_t index);
 
 /**
@@ -381,10 +381,10 @@ void htt_tx_desc_free(htt_pdev_handle htt_pdev, void *htt_tx_desc);
  * @return success 0
  */
 int htt_tx_frag_alloc(htt_pdev_handle pdev,
-	u_int16_t index, cdf_dma_addr_t *frag_paddr, void **frag_ptr);
+	u_int16_t index, qdf_dma_addr_t *frag_paddr, void **frag_ptr);
 #else
 static inline int htt_tx_frag_alloc(htt_pdev_handle pdev,
-	u_int16_t index, cdf_dma_addr_t *frag_paddr, void **frag_ptr)
+	u_int16_t index, qdf_dma_addr_t *frag_paddr, void **frag_ptr)
 {
 	*frag_ptr = NULL;
 	return 0;
@@ -530,7 +530,7 @@ static inline
 void
 htt_tx_desc_init(htt_pdev_handle pdev,
 		 void *htt_tx_desc,
-		 cdf_dma_addr_t htt_tx_desc_paddr,
+		 qdf_dma_addr_t htt_tx_desc_paddr,
 		 uint16_t msdu_id,
 		 cdf_nbuf_t msdu, struct htt_msdu_info_t *msdu_info,
 		 struct qdf_tso_info_t *tso_info,
@@ -807,7 +807,7 @@ static inline
 void
 htt_tx_desc_frag(htt_pdev_handle pdev,
 		 void *desc,
-		 int frag_num, cdf_dma_addr_t frag_phys_addr, uint16_t frag_len)
+		 int frag_num, qdf_dma_addr_t frag_phys_addr, uint16_t frag_len)
 {
 	uint32_t *word32;
 #if defined(HELIUMPLUS_PADDR64)
@@ -864,8 +864,8 @@ htt_tx_desc_frag(htt_pdev_handle pdev,
 
 void htt_tx_desc_frags_table_set(htt_pdev_handle pdev,
 				 void *desc,
-				 cdf_dma_addr_t paddr,
-				 cdf_dma_addr_t frag_desc_paddr,
+				 qdf_dma_addr_t paddr,
+				 qdf_dma_addr_t frag_desc_paddr,
 				 int reset);
 
 /**

core/dp/txrx/ol_tx.c

@@ -145,7 +145,7 @@ static inline uint8_t ol_tx_prepare_tso(ol_txrx_vdev_handle vdev,
 cdf_nbuf_t ol_tx_send_data_frame(uint8_t sta_id, cdf_nbuf_t skb,
 				 uint8_t proto_type)
 {
-	void *cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	void *qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 	struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
 	struct ol_txrx_peer_t *peer;
 	cdf_nbuf_t ret;
@@ -156,9 +156,9 @@ cdf_nbuf_t ol_tx_send_data_frame(uint8_t sta_id, cdf_nbuf_t skb,
 			"%s:pdev is null", __func__);
 		return skb;
 	}
-	if (qdf_unlikely(!cdf_ctx)) {
+	if (qdf_unlikely(!qdf_ctx)) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-			"%s:cdf_ctx is null", __func__);
+			"%s:qdf_ctx is null", __func__);
 		return skb;
 	}
 
@@ -181,7 +181,7 @@ cdf_nbuf_t ol_tx_send_data_frame(uint8_t sta_id, cdf_nbuf_t skb,
 		return skb;
 	}
 
-	status = cdf_nbuf_map_single(cdf_ctx, skb, QDF_DMA_TO_DEVICE);
+	status = cdf_nbuf_map_single(qdf_ctx, skb, QDF_DMA_TO_DEVICE);
 	if (qdf_unlikely(status != QDF_STATUS_SUCCESS)) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_WARN,
 			"%s: nbuf map failed", __func__);
@@ -201,7 +201,7 @@ cdf_nbuf_t ol_tx_send_data_frame(uint8_t sta_id, cdf_nbuf_t skb,
 	if (ret) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_WARN,
 			"%s: Failed to tx", __func__);
-		cdf_nbuf_unmap_single(cdf_ctx, ret, QDF_DMA_TO_DEVICE);
+		cdf_nbuf_unmap_single(qdf_ctx, ret, QDF_DMA_TO_DEVICE);
 		return ret;
 	}
 
@@ -461,7 +461,7 @@ ol_tx_prepare_ll_fast(struct ol_txrx_pdev_t *pdev,
 	} else {
 		for (i = 1; i < num_frags; i++) {
 			qdf_size_t frag_len;
-			cdf_dma_addr_t frag_paddr;
+			qdf_dma_addr_t frag_paddr;
 
 			frag_len = cdf_nbuf_get_frag_len(msdu, i);
 			frag_paddr = cdf_nbuf_get_frag_paddr(msdu, i);

core/dp/txrx/ol_tx_desc.c

@@ -307,7 +307,7 @@ extern void
 dump_frag_desc(char *msg, struct ol_tx_desc_t *tx_desc);
 
 void
-dump_pkt(cdf_nbuf_t nbuf, cdf_dma_addr_t nbuf_paddr, int len)
+dump_pkt(cdf_nbuf_t nbuf, qdf_dma_addr_t nbuf_paddr, int len)
 {
 	qdf_print("%s: Pkt: VA 0x%p PA 0x%llx len %d\n", __func__,
 		  cdf_nbuf_data(nbuf), nbuf_paddr, len);
@@ -405,7 +405,7 @@ struct ol_tx_desc_t *ol_tx_desc_ll(struct ol_txrx_pdev_t *pdev,
 	} else {
 		for (i = 1; i < num_frags; i++) {
 			qdf_size_t frag_len;
-			cdf_dma_addr_t frag_paddr;
+			qdf_dma_addr_t frag_paddr;
 #ifdef HELIUMPLUS_DEBUG
 			void *frag_vaddr;
 			frag_vaddr = cdf_nbuf_get_frag_vaddr(netbuf, i);
@@ -488,7 +488,7 @@ void ol_tx_desc_frame_free_nonstd(struct ol_txrx_pdev_t *pdev,
 	/* check the frame type to see what kind of special steps are needed */
 	if ((tx_desc->pkt_type >= OL_TXRX_MGMT_TYPE_BASE) &&
 		   (tx_desc->pkt_type != 0xff)) {
-		cdf_dma_addr_t frag_desc_paddr = 0;
+		qdf_dma_addr_t frag_desc_paddr = 0;
 
 #if defined(HELIUMPLUS_PADDR64)
 		frag_desc_paddr = tx_desc->htt_frag_desc_paddr;

core/dp/txrx/ol_txrx.c

@@ -456,11 +456,11 @@ void htt_pkt_log_init(struct ol_txrx_pdev_t *handle, void *scn)
 	if (handle->pkt_log_init)
 		return;
 
-	if (cds_get_conparam() != CDF_GLOBAL_FTM_MODE &&
+	if (cds_get_conparam() != QDF_GLOBAL_FTM_MODE &&
 			!WLAN_IS_EPPING_ENABLED(cds_get_conparam())) {
 		ol_pl_sethandle(&handle->pl_dev, scn);
 		if (pktlogmod_init(scn))
-			cdf_print("%s: pktlogmod_init failed", __func__);
+			qdf_print("%s: pktlogmod_init failed", __func__);
 		else
 			handle->pkt_log_init = true;
 	}
@@ -475,7 +475,7 @@ void htt_pkt_log_init(struct ol_txrx_pdev_t *handle, void *scn)
  */
 void htt_pktlogmod_exit(struct ol_txrx_pdev_t *handle, void *scn)
 {
-	if (scn && cds_get_conparam() != CDF_GLOBAL_FTM_MODE &&
+	if (scn && cds_get_conparam() != QDF_GLOBAL_FTM_MODE &&
 		!WLAN_IS_EPPING_ENABLED(cds_get_conparam()) &&
 			handle->pkt_log_init) {
 		pktlogmod_exit(scn);
@@ -1193,7 +1193,7 @@ ol_txrx_vdev_detach(ol_txrx_vdev_handle vdev,
 		cdf_nbuf_t next = cdf_nbuf_next(vdev->ll_pause.txq.head);
 		cdf_nbuf_set_next(vdev->ll_pause.txq.head, NULL);
 		cdf_nbuf_unmap(pdev->osdev, vdev->ll_pause.txq.head,
-			       CDF_DMA_TO_DEVICE);
+			       QDF_DMA_TO_DEVICE);
 		cdf_nbuf_tx_free(vdev->ll_pause.txq.head, NBUF_PKT_ERROR);
 		vdev->ll_pause.txq.head = next;
 	}

core/dp/txrx/ol_txrx_types.h

@@ -130,9 +130,9 @@ struct ol_tx_desc_t {
 	cdf_nbuf_t netbuf;
 	void *htt_tx_desc;
 	uint16_t id;
-	cdf_dma_addr_t htt_tx_desc_paddr;
+	qdf_dma_addr_t htt_tx_desc_paddr;
 	void *htt_frag_desc; /* struct msdu_ext_desc_t * */
-	cdf_dma_addr_t htt_frag_desc_paddr;
+	qdf_dma_addr_t htt_frag_desc_paddr;
 	qdf_atomic_t ref_cnt;
 	enum htt_tx_status status;
 

core/hdd/src/wlan_hdd_driver_ops.c

@@ -226,13 +226,13 @@ static int hdd_hif_open(struct device *dev, void *bdev, const hif_bus_id *bid,
 	QDF_STATUS status;
 	int ret = 0;
 	struct hif_opaque_softc *hif_ctx;
-	cdf_device_t cdf_ctx = cds_get_context(CDF_MODULE_ID_CDF_DEVICE);
+	qdf_device_t qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 	struct hif_callbacks cbk;
 	uint32_t mode = cds_get_conparam();
 
 	hdd_hif_init_cds_callbacks(dev, &cbk);
 
-	hif_ctx = hif_open(cdf_ctx, mode, bus_type, &cbk);
+	hif_ctx = hif_open(qdf_ctx, mode, bus_type, &cbk);
 	if (!hif_ctx) {
 		hdd_err("hif_open error");
 		return -ENOMEM;
@@ -304,7 +304,7 @@ static void hdd_hif_close(void *hif_ctx)
  */
 void hdd_init_cdf_ctx(struct device *dev, void *bdev)
 {
-	cdf_device_t cdf_dev = cds_get_context(CDF_MODULE_ID_CDF_DEVICE);
+	qdf_device_t cdf_dev = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
 	cdf_dev->dev = dev;
 	cdf_dev->drv_hdl = bdev;
@@ -329,7 +329,7 @@ static int wlan_hdd_probe(struct device *dev, void *bdev, const hif_bus_id *bid,
 	void *hif_ctx;
 	QDF_STATUS status;
 	int ret = 0;
-	cdf_device_t cdf_dev;
+	qdf_device_t cdf_dev;
 	uint32_t mode = cds_get_conparam();
 
 	pr_info("%s: %sprobing driver v%s\n", WLAN_MODULE_NAME,
@@ -369,7 +369,7 @@ static int wlan_hdd_probe(struct device *dev, void *bdev, const hif_bus_id *bid,
 		goto err_epping_close;
 
 	hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
-	cdf_dev = cds_get_context(CDF_MODULE_ID_CDF_DEVICE);
+	cdf_dev = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
 	status = ol_cds_init(cdf_dev, hif_ctx);
 

core/hdd/src/wlan_hdd_ftm.c

@@ -176,7 +176,7 @@ static QDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 	tMacOpenParameters mac_openParms;
 	p_cds_contextType gp_cds_context = (p_cds_contextType) p_cds_context;
 #if  defined(QCA_WIFI_FTM)
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 	HTC_INIT_INFO htcInfo;
 	void *pHifContext = NULL;
 	void *pHtcContext = NULL;
@@ -262,11 +262,11 @@ static QDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 	htcInfo.pContext = ol_ctx;
 	htcInfo.TargetFailure = ol_target_failure;
 	htcInfo.TargetSendSuspendComplete = wma_target_suspend_acknowledge;
-	cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
 	/* Create HTC */
 	gp_cds_context->htc_ctx =
-		htc_create(pHifContext, &htcInfo, cdf_ctx);
+		htc_create(pHifContext, &htcInfo, qdf_ctx);
 	if (!gp_cds_context->htc_ctx) {
 		QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to Create HTC", __func__);

core/hdd/src/wlan_hdd_ipa.c

@@ -1422,7 +1422,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 		(HDD_IPA_UC_STAT_REASON_DEBUG == hdd_ipa->stat_req_reason)) {
 
 		/* STATs from host */
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC WLAN_HOST CE ====\n"
 			  "CE RING BASE: 0x%llx\n"
 			  "CE RING SIZE: %d\n"
@@ -1430,7 +1430,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 			  (unsigned long long)hdd_ipa->ce_sr_base_paddr,
 			  hdd_ipa->ce_sr_ring_size,
 			  (unsigned long long)hdd_ipa->ce_reg_paddr);
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC WLAN_HOST TX ====\n"
 			  "COMP RING BASE: 0x%llx\n"
 			  "COMP RING SIZE: %d\n"
@@ -1440,7 +1440,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 			  hdd_ipa->tx_comp_ring_size,
 			  hdd_ipa->tx_num_alloc_buffer,
 			  (unsigned long long)hdd_ipa->tx_comp_doorbell_paddr);
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC WLAN_HOST RX ====\n"
 			  "IND RING BASE: 0x%llx\n"
 			  "IND RING SIZE: %d\n"
@@ -1456,7 +1456,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 			  hdd_ipa->stats.num_rx_excep,
 			  hdd_ipa->stats.num_tx_bcmc,
 			  (unsigned long long)hdd_ipa->stats.num_tx_bcmc_err);
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC WLAN_HOST CONTROL ====\n"
 			  "SAP NUM STAs: %d\n"
 			  "STA CONNECTED: %d\n"
@@ -1476,7 +1476,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 		/* STATs from FW */
 		uc_fw_stat = (struct ipa_uc_fw_stats *)
 			     ((uint8_t *)op_msg + sizeof(struct op_msg_type));
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC WLAN_FW TX ====\n"
 			  "COMP RING BASE: 0x%x\n"
 			  "COMP RING SIZE: %d\n"
@@ -1497,7 +1497,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 			  uc_fw_stat->tx_pkts_enqueued,
 			  uc_fw_stat->tx_pkts_completed,
 			  uc_fw_stat->tx_is_suspend, uc_fw_stat->tx_reserved);
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC WLAN_FW RX ====\n"
 			  "IND RING BASE: 0x%x\n"
 			  "IND RING SIZE: %d\n"
@@ -1528,7 +1528,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 			  uc_fw_stat->rx_is_suspend, uc_fw_stat->rx_reserved);
 		/* STATs from IPA */
 		ipa_get_wdi_stats(&ipa_stat);
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC IPA TX ====\n"
 			  "NUM PROCD : %d\n"
 			  "CE DBELL : 0x%x\n"
@@ -1564,7 +1564,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 			  num_bam_int_in_non_runnning_state,
 			  ipa_stat.tx_ch_stats.num_qmb_int_handled);
 
-		CDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
+		QDF_TRACE(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR,
 			  "==== IPA_UC IPA RX ====\n"
 			  "MAX OST PKT : %d\n"
 			  "NUM PKT PRCSD : %d\n"
@@ -3408,7 +3408,7 @@ static void hdd_ipa_cleanup_iface(struct hdd_ipa_iface_context *iface_context)
 	if (!iface_context->hdd_ipa->num_iface) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			"NUM INTF 0, Invalid");
-		CDF_ASSERT(0);
+		QDF_ASSERT(0);
 	}
 	iface_context->hdd_ipa->num_iface--;
 }

core/hdd/src/wlan_hdd_main.c

@@ -6819,7 +6819,7 @@ static int __hdd_module_init(void)
 		goto out;
 	}
 
-	pr_info("%s: driver loaded\n", WLAN_MODULE_NAME);
+	pr_info("%s: qdf driver loaded\n", WLAN_MODULE_NAME);
 
 	return 0;
 out:
@@ -6993,7 +6993,7 @@ static inline bool hdd_is_lpass_supported(hdd_context_t *hdd_ctx)
 static void hdd_update_ol_config(hdd_context_t *hdd_ctx)
 {
 	struct ol_config_info cfg;
-	struct ol_context *ol_ctx = cds_get_context(CDF_MODULE_ID_BMI);
+	struct ol_context *ol_ctx = cds_get_context(QDF_MODULE_ID_BMI);
 
 	if (!ol_ctx)
 		return;
@@ -7015,7 +7015,7 @@ static void hdd_update_ol_config(hdd_context_t *hdd_ctx)
  */
 static void hdd_update_hif_config(hdd_context_t *hdd_ctx)
 {
-	struct hif_opaque_softc *scn = cds_get_context(CDF_MODULE_ID_HIF);
+	struct hif_opaque_softc *scn = cds_get_context(QDF_MODULE_ID_HIF);
 	struct hif_config_info cfg;
 
 	if (!scn)

core/hdd/src/wlan_hdd_memdump.c

@@ -69,7 +69,7 @@ static void memdump_cleanup_timer_cb(void *data)
 	hdd_context_t *hdd_ctx = data;
 	qdf_dma_addr_t paddr;
 	qdf_dma_addr_t dma_ctx = 0;
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 
 	status = wlan_hdd_validate_context(hdd_ctx);
 	if (0 != status) {
@@ -82,15 +82,15 @@ static void memdump_cleanup_timer_cb(void *data)
 		return;
 	}
 
-	cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
-	if (!cdf_ctx) {
+	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	if (!qdf_ctx) {
 		hddLog(LOGE, FL("CDF context is NULL"));
 		return;
 	}
 
 	paddr = hdd_ctx->dump_loc_paddr;
 	mutex_lock(&hdd_ctx->memdump_lock);
-	cdf_os_mem_free_consistent(cdf_ctx,
+	cdf_os_mem_free_consistent(qdf_ctx,
 		FW_MEM_DUMP_SIZE, hdd_ctx->fw_dump_loc, paddr, dma_ctx);
 	hdd_ctx->fw_dump_loc = NULL;
 	hdd_ctx->memdump_in_progress = false;
@@ -204,7 +204,7 @@ static int __wlan_hdd_cfg80211_get_fw_mem_dump(struct wiphy *wiphy,
 	uint8_t loop;
 	qdf_dma_addr_t paddr;
 	qdf_dma_addr_t dma_ctx = 0;
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 	unsigned long rc;
 	struct hdd_fw_dump_context *context;
 
@@ -214,8 +214,8 @@ static int __wlan_hdd_cfg80211_get_fw_mem_dump(struct wiphy *wiphy,
 		return status;
 	}
 
-	cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
-	if (!cdf_ctx) {
+	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	if (!qdf_ctx) {
 		hddLog(LOGE, FL("CDF context is NULL"));
 		return -EINVAL;
 	}
@@ -235,7 +235,7 @@ static int __wlan_hdd_cfg80211_get_fw_mem_dump(struct wiphy *wiphy,
 	mutex_lock(&hdd_ctx->memdump_lock);
 	if (!hdd_ctx->fw_dump_loc) {
 		hdd_ctx->fw_dump_loc = cdf_os_mem_alloc_consistent(
-			cdf_ctx, FW_MEM_DUMP_SIZE, &paddr, dma_ctx);
+			qdf_ctx, FW_MEM_DUMP_SIZE, &paddr, dma_ctx);
 		if (!hdd_ctx->fw_dump_loc) {
 			mutex_unlock(&hdd_ctx->memdump_lock);
 			hddLog(LOGE, FL("cdf_os_mem_alloc_consistent failed"));
@@ -299,7 +299,7 @@ static int __wlan_hdd_cfg80211_get_fw_mem_dump(struct wiphy *wiphy,
 	if (QDF_STATUS_SUCCESS != sme_status) {
 		hddLog(LOGE, FL("sme_fw_mem_dump Failed"));
 		mutex_lock(&hdd_ctx->memdump_lock);
-		cdf_os_mem_free_consistent(cdf_ctx,
+		cdf_os_mem_free_consistent(qdf_ctx,
 			FW_MEM_DUMP_SIZE, hdd_ctx->fw_dump_loc, paddr, dma_ctx);
 		hdd_ctx->fw_dump_loc = NULL;
 		mutex_unlock(&hdd_ctx->memdump_lock);
@@ -395,7 +395,7 @@ static ssize_t memdump_read(struct file *file, char __user *buf,
 	hdd_context_t *hdd_ctx;
 	qdf_dma_addr_t paddr;
 	qdf_dma_addr_t dma_ctx = 0;
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 
 	hdd_ctx = memdump_get_file_data(file);
 
@@ -405,8 +405,8 @@ static ssize_t memdump_read(struct file *file, char __user *buf,
 		hddLog(LOGE, FL("HDD context is not valid"));
 		return -EINVAL;
 	}
-	cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
-	if (!cdf_ctx) {
+	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	if (!qdf_ctx) {
 		hddLog(LOGE, FL("CDF context is NULL"));
 		return -EINVAL;
 	}
@@ -443,7 +443,7 @@ static ssize_t memdump_read(struct file *file, char __user *buf,
 	if (*pos >= FW_MEM_DUMP_SIZE) {
 		paddr = hdd_ctx->dump_loc_paddr;
 		mutex_lock(&hdd_ctx->memdump_lock);
-		cdf_os_mem_free_consistent(cdf_ctx,
+		cdf_os_mem_free_consistent(qdf_ctx,
 			FW_MEM_DUMP_SIZE, hdd_ctx->fw_dump_loc, paddr, dma_ctx);
 		hdd_ctx->fw_dump_loc = NULL;
 		hdd_ctx->memdump_in_progress = false;
@@ -593,7 +593,7 @@ void memdump_deinit(void)
 	hdd_context_t *hdd_ctx;
 	qdf_dma_addr_t paddr;
 	qdf_dma_addr_t dma_ctx = 0;
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 	QDF_STATUS qdf_status;
 
 	hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
@@ -607,8 +607,8 @@ void memdump_deinit(void)
 		return;
 	}
 
-	cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
-	if (!cdf_ctx) {
+	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	if (!qdf_ctx) {
 		hddLog(LOGE, FL("CDF context is NULL"));
 		return;
 	}
@@ -619,7 +619,7 @@ void memdump_deinit(void)
 	mutex_lock(&hdd_ctx->memdump_lock);
 	if (hdd_ctx->fw_dump_loc) {
 		paddr = hdd_ctx->dump_loc_paddr;
-		cdf_os_mem_free_consistent(cdf_ctx,
+		cdf_os_mem_free_consistent(qdf_ctx,
 			FW_MEM_DUMP_SIZE, hdd_ctx->fw_dump_loc, paddr, dma_ctx);
 		hdd_ctx->fw_dump_loc = NULL;
 		hdd_ctx->memdump_in_progress = false;

core/utils/epping/src/epping_main.c

@@ -177,7 +177,7 @@ int epping_enable(struct device *parent_dev)
 	int ret = 0;
 	epping_context_t *pEpping_ctx = NULL;
 	cds_context_type *p_cds_context = NULL;
-	qdf_device_t cdf_ctx;
+	qdf_device_t qdf_ctx;
 	HTC_INIT_INFO htcInfo;
 	struct hif_opaque_softc *scn;
 	tSirMacAddr adapter_macAddr;
@@ -220,7 +220,7 @@ int epping_enable(struct device *parent_dev)
 	/* store target type and target version info in hdd ctx */
 	pEpping_ctx->target_type = tgt_info->target_type;
 
-	ol_ctx = cds_get_context(CDF_MODULE_ID_BMI);
+	ol_ctx = cds_get_context(QDF_MODULE_ID_BMI);
 #ifndef FEATURE_BMI_2
 	/* Initialize BMI and Download firmware */
 	if (bmi_download_firmware(ol_ctx)) {
@@ -236,10 +236,10 @@ int epping_enable(struct device *parent_dev)
 	htcInfo.pContext = ol_ctx;
 	htcInfo.TargetFailure = ol_target_failure;
 	htcInfo.TargetSendSuspendComplete = epping_target_suspend_acknowledge;
-	cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
 	/* Create HTC */
-	p_cds_context->htc_ctx = htc_create(scn, &htcInfo, cdf_ctx);
+	p_cds_context->htc_ctx = htc_create(scn, &htcInfo, qdf_ctx);
 	if (!p_cds_context->htc_ctx) {
 		QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to Create HTC", __func__);

core/wma/inc/wma.h

@@ -1197,7 +1197,7 @@ typedef struct {
 #endif
 	bool wmi_ready;
 	uint32_t wlan_init_status;
-	qdf_device_t cdf_dev;
+	qdf_device_t qdf_dev;
 	uint32_t phy_capability;
 	uint32_t max_frag_entry;
 	uint32_t wmi_service_bitmap[WMI_SERVICE_BM_SIZE];

core/wma/src/wma_data.c

@@ -2354,7 +2354,7 @@ mgmt_wmi_unified_cmd_send(tp_wma_handle wma_handle, void *tx_frame,
 	int32_t cmd_len;
 	uint64_t dma_addr;
 	struct wmi_desc_t *wmi_desc = NULL;
-	void *cdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	void *qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 	uint8_t *bufp;
 	int32_t bufp_len = (frmLen < mgmt_tx_dl_frm_len) ? frmLen :
 		mgmt_tx_dl_frm_len;
@@ -2393,7 +2393,7 @@ mgmt_wmi_unified_cmd_send(tp_wma_handle wma_handle, void *tx_frame,
 							    sizeof(uint32_t)));
 	bufp += WMI_TLV_HDR_SIZE;
 	cdf_mem_copy(bufp, pData, bufp_len);
-	cdf_nbuf_map_single(cdf_ctx, tx_frame, QDF_DMA_TO_DEVICE);
+	cdf_nbuf_map_single(qdf_ctx, tx_frame, QDF_DMA_TO_DEVICE);
 	dma_addr = cdf_nbuf_get_frag_paddr(tx_frame, 0);
 	cmd->paddr_lo = (uint32_t)(dma_addr & 0xffffffff);
 #if defined(HELIUMPLUS_PADDR64)

core/wma/src/wma_main.c

@@ -1596,7 +1596,6 @@ QDF_STATUS wma_open(void *cds_context,
 	qdf_device_t qdf_dev;
 	void *wmi_handle;
 	QDF_STATUS qdf_status;
-	QDF_STATUS qdf_status;
 	struct txrx_pdev_cfg_param_t olCfg = { 0 };
 
 	WMA_LOGD("%s: Enter", __func__);
@@ -1683,7 +1682,7 @@ QDF_STATUS wma_open(void *cds_context,
 	ol_cfg_set_flow_control_parameters(&olCfg, mac_params);
 
 	((p_cds_contextType) cds_context)->cfg_ctx =
-		ol_pdev_cfg_attach(((p_cds_contextType) cds_context)->cdf_ctx,
+		ol_pdev_cfg_attach(((p_cds_contextType) cds_context)->qdf_ctx,
 				   olCfg);
 	if (!(((p_cds_contextType) cds_context)->cfg_ctx)) {
 		WMA_LOGP("%s: failed to init cfg handle", __func__);
@@ -1777,7 +1776,7 @@ QDF_STATUS wma_open(void *cds_context,
 	wma_handle->new_hw_mode_index = WMA_DEFAULT_HW_MODE_INDEX;
 	wma_handle->saved_wmi_init_cmd.buf = NULL;
 
-	qdf_status = cdf_event_init(&wma_handle->wma_ready_event);
+	qdf_status = qdf_event_create(&wma_handle->wma_ready_event);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
 		WMA_LOGP("%s: wma_ready_event initialization failed", __func__);
 		goto err_event_init;
@@ -1787,12 +1786,12 @@ QDF_STATUS wma_open(void *cds_context,
 					QDF_TIMER_TYPE_SW,
 					wma_service_ready_ext_evt_timeout,
 					wma_handle);
-	if (!CDF_IS_STATUS_SUCCESS(qdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		WMA_LOGE("Failed to initialize service ready ext timeout");
 		goto err_event_init;
 	}
 
-	qdf_status = cdf_event_init(&wma_handle->target_suspend);
+	qdf_status = qdf_event_create(&wma_handle->target_suspend);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
 		WMA_LOGP("%s: target suspend event initialization failed",
 			 __func__);
@@ -1800,35 +1799,35 @@ QDF_STATUS wma_open(void *cds_context,
 	}
 
 	/* Init Tx Frame Complete event */
-	qdf_status = cdf_event_init(&wma_handle->tx_frm_download_comp_event);
-	if (!CDF_IS_STATUS_SUCCESS(qdf_status)) {
+	qdf_status = qdf_event_create(&wma_handle->tx_frm_download_comp_event);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		WMA_LOGP("%s: failed to init tx_frm_download_comp_event",
 			 __func__);
 		goto err_event_init;
 	}
 
 	/* Init tx queue empty check event */
-	qdf_status = cdf_event_init(&wma_handle->tx_queue_empty_event);
-	if (!CDF_IS_STATUS_SUCCESS(qdf_status)) {
+	qdf_status = qdf_event_create(&wma_handle->tx_queue_empty_event);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		WMA_LOGP("%s: failed to init tx_queue_empty_event", __func__);
 		goto err_event_init;
 	}
 
-	qdf_status = cdf_event_init(&wma_handle->wma_resume_event);
+	qdf_status = qdf_event_create(&wma_handle->wma_resume_event);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
 		WMA_LOGP("%s: wma_resume_event initialization failed",
 			 __func__);
 		goto err_event_init;
 	}
 
-	qdf_status = cdf_event_init(&wma_handle->runtime_suspend);
+	qdf_status = qdf_event_create(&wma_handle->runtime_suspend);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
 		WMA_LOGP("%s: runtime_suspend event initialization failed",
 			 __func__);
 		goto err_event_init;
 	}
 
-	qdf_status = cdf_event_init(&wma_handle->recovery_event);
+	qdf_status = qdf_event_create(&wma_handle->recovery_event);
 	if (qdf_status != QDF_STATUS_SUCCESS) {
 		WMA_LOGP("%s: recovery event initialization failed", __func__);
 		goto err_event_init;
@@ -3149,16 +3148,16 @@ QDF_STATUS wma_close(void *cds_ctx)
 		WMA_LOGP("%s: dbglog_deinit failed", __func__);
 
 	/* close the cdf events */
-	cdf_event_destroy(&wma_handle->wma_ready_event);
+	qdf_event_destroy(&wma_handle->wma_ready_event);
 	qdf_status = qdf_mc_timer_destroy(&wma_handle->service_ready_ext_timer);
-	if (!CDF_IS_STATUS_SUCCESS(qdf_status))
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status))
 		WMA_LOGP("%s: Failed to destroy service ready ext event timer",
 			__func__);
 
-	cdf_event_destroy(&wma_handle->target_suspend);
-	cdf_event_destroy(&wma_handle->wma_resume_event);
-	cdf_event_destroy(&wma_handle->runtime_suspend);
-	cdf_event_destroy(&wma_handle->recovery_event);
+	qdf_event_destroy(&wma_handle->target_suspend);
+	qdf_event_destroy(&wma_handle->wma_resume_event);
+	qdf_event_destroy(&wma_handle->runtime_suspend);
+	qdf_event_destroy(&wma_handle->recovery_event);
 	wma_cleanup_vdev_resp(wma_handle);
 	wma_cleanup_hold_req(wma_handle);
 	qdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
@@ -4050,7 +4049,7 @@ void wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
 		 */
 		ret = qdf_mc_timer_start(&wma_handle->service_ready_ext_timer,
 				WMA_SERVICE_READY_EXT_TIMEOUT);
-		if (!CDF_IS_STATUS_SUCCESS(ret))
+		if (!QDF_IS_STATUS_SUCCESS(ret))
 			WMA_LOGP("Failed to start the service ready ext timer");
 
 		WMA_LOGA("%s: WMA waiting for WMI_SERVICE_READY_EXT_EVENTID",
@@ -4104,7 +4103,7 @@ void wma_rx_service_ready_ext_event(WMA_HANDLE handle, void *event)
 			ev->default_fw_config_bits);
 
 	ret = qdf_mc_timer_stop(&wma_handle->service_ready_ext_timer);
-	if (!CDF_IS_STATUS_SUCCESS(ret)) {
+	if (!QDF_IS_STATUS_SUCCESS(ret)) {
 		WMA_LOGP("Failed to stop the service ready ext timer");
 		return;
 	}
@@ -4204,7 +4203,7 @@ void wma_rx_ready_event(WMA_HANDLE handle, void *cmd_param_info)
 
 	wma_update_hdd_cfg(wma_handle);
 
-	cdf_event_set(&wma_handle->wma_ready_event);
+	qdf_event_set(&wma_handle->wma_ready_event);
 
 	WMA_LOGD("Exit");
 }
@@ -4269,7 +4268,7 @@ QDF_STATUS wma_wait_for_ready_event(WMA_HANDLE handle)
 	QDF_STATUS qdf_status;
 
 	/* wait until WMI_READY_EVENTID received from FW */
-	qdf_status = cdf_wait_single_event(&(wma_handle->wma_ready_event),
+	qdf_status = qdf_wait_single_event(&(wma_handle->wma_ready_event),
 					   WMA_READY_EVENTID_TIMEOUT);
 
 	if (QDF_STATUS_SUCCESS != qdf_status) {
@@ -4742,7 +4741,7 @@ QDF_STATUS wma_mc_process_msg(void *cds_context, cds_msg_t *msg)
 	case WNI_CFG_DNLD_REQ:
 		WMA_LOGA("McThread: WNI_CFG_DNLD_REQ");
 		qdf_status = wma_wni_cfg_dnld(wma_handle);
-		if (CDF_IS_STATUS_SUCCESS(qdf_status)) {
+		if (QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			cds_wma_complete_cback(cds_context);
 		} else {
 			WMA_LOGD("config download failure");